Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm-4.9 / 7b4ccf8db4c1dc343ad5d6ed19240bbc3b5f945f / . / drivers / telephony / ixj.c
blob: 9585d48dc4fc36ec9bb07bb9c9c21e78a50c0aaa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]44/*
45 * $Log: ixj.c,v $
46 *
47 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
48 * Audit some copy_*_user and minor cleanup.
49 *
50 * Revision 4.7 2001/08/13 06:19:33 craigs
51 * Added additional changes from Alan Cox and John Anderson for
52 * 2.2 to 2.4 cleanup and bounds checking
53 *
54 * Revision 4.6 2001/08/13 01:05:05 craigs
55 * Really fixed PHONE_QUERY_CODEC problem this time
56 *
57 * Revision 4.5 2001/08/13 00:11:03 craigs
58 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
59 *
60 * Revision 4.4 2001/08/07 07:58:12 craigs
61 * Changed back to three digit version numbers
62 * Added tagbuild target to allow automatic and easy tagging of versions
63 *
64 * Revision 4.3 2001/08/07 07:24:47 craigs
65 * Added ixj-ver.h to allow easy configuration management of driver
66 * Added display of version number in /prox/ixj
67 *
68 * Revision 4.2 2001/08/06 07:07:19 craigs
69 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
70 * behaviour of returning int rather than short *
71 *
72 * Revision 4.1 2001/08/05 00:17:37 craigs
73 * More changes for correct PCMCIA installation
74 * Start of changes for backward Linux compatibility
75 *
76 * Revision 4.0 2001/08/04 12:33:12 craigs
77 * New version using GNU autoconf
78 *
79 * Revision 3.105 2001/07/20 23:14:32 eokerson
80 * More work on CallerID generation when using ring cadences.
81 *
82 * Revision 3.104 2001/07/06 01:33:55 eokerson
83 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
84 *
85 * Revision 3.103 2001/07/05 19:20:16 eokerson
86 * Updated HOWTO
87 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
88 *
89 * Revision 3.102 2001/07/03 23:51:21 eokerson
90 * Un-mute mic on Internet LineJACK when in speakerphone mode.
91 *
92 * Revision 3.101 2001/07/02 19:26:56 eokerson
93 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
94 *
95 * Revision 3.100 2001/07/02 19:18:27 eokerson
96 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
97 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
98 * Fixed speaker mode on Internet LineJACK.
99 *
100 * Revision 3.99 2001/05/09 14:11:16 eokerson
101 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
102 *
103 * Revision 3.98 2001/05/08 19:55:33 eokerson
104 * Fixed POTS hookstate detection while it is connected to PSTN port.
105 *
106 * Revision 3.97 2001/05/08 00:01:04 eokerson
107 * Fixed kernel oops when sending caller ID data.
108 *
109 * Revision 3.96 2001/05/04 23:09:30 eokerson
110 * Now uses one kernel timer for each card, instead of one for the entire driver.
111 *
112 * Revision 3.95 2001/04/25 22:06:47 eokerson
113 * Fixed squawking at beginning of some G.723.1 calls.
114 *
115 * Revision 3.94 2001/04/03 23:42:00 eokerson
116 * Added linear volume ioctls
117 * Added raw filter load ioctl
118 *
119 * Revision 3.93 2001/02/27 01:00:06 eokerson
120 * Fixed blocking in CallerID.
121 * Reduced size of ixj structure for smaller driver footprint.
122 *
123 * Revision 3.92 2001/02/20 22:02:59 eokerson
124 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
125 * Improved PSTN ring detection.
126 * Fixed wink generation on POTS ports.
127 *
128 * Revision 3.91 2001/02/13 00:55:44 eokerson
129 * Turn AEC back on after changing frame sizes.
130 *
131 * Revision 3.90 2001/02/12 16:42:00 eokerson
132 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
133 *
134 * Revision 3.89 2001/02/12 15:41:16 eokerson
135 * Fix from Artis Kugevics - Tone gains were not being set correctly.
136 *
137 * Revision 3.88 2001/02/05 23:25:42 eokerson
138 * Fixed lockup bugs with deregister.
139 *
140 * Revision 3.87 2001/01/29 21:00:39 eokerson
141 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
142 * Updated copyright date.
143 *
144 * Revision 3.86 2001/01/23 23:53:46 eokerson
145 * Fixes to G.729 compatibility.
146 *
147 * Revision 3.85 2001/01/23 21:30:36 eokerson
148 * Added verbage about cards supported.
149 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
150 *
151 * Revision 3.84 2001/01/22 23:32:10 eokerson
152 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
153 *
154 * Revision 3.83 2001/01/19 14:51:41 eokerson
155 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
156 *
157 * Revision 3.82 2001/01/19 00:34:49 eokerson
158 * Added verbosity to write overlap errors.
159 *
160 * Revision 3.81 2001/01/18 23:56:54 eokerson
161 * Fixed PSTN line test functions.
162 *
163 * Revision 3.80 2001/01/18 22:29:27 eokerson
164 * Updated AEC/AGC values for different cards.
165 *
166 * Revision 3.79 2001/01/17 02:58:54 eokerson
167 * Fixed AEC reset after Caller ID.
168 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
169 *
170 * Revision 3.78 2001/01/16 19:43:09 eokerson
171 * Added support for Linux 2.4.x kernels.
172 *
173 * Revision 3.77 2001/01/09 04:00:52 eokerson
174 * Linetest will now test the line, even if it has previously succeded.
175 *
176 * Revision 3.76 2001/01/08 19:27:00 eokerson
177 * Fixed problem with standard cable on Internet PhoneCARD.
178 *
179 * Revision 3.75 2000/12/22 16:52:14 eokerson
180 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
181 *
182 * Revision 3.74 2000/12/08 22:41:50 eokerson
183 * Added capability for G729B.
184 *
185 * Revision 3.73 2000/12/07 23:35:16 eokerson
186 * Added capability to have different ring pattern before CallerID data.
187 * Added hookstate checks in CallerID routines to stop FSK.
188 *
189 * Revision 3.72 2000/12/06 19:31:31 eokerson
190 * Modified signal behavior to only send one signal per event.
191 *
192 * Revision 3.71 2000/12/06 03:23:08 eokerson
193 * Fixed CallerID on Call Waiting.
194 *
195 * Revision 3.70 2000/12/04 21:29:37 eokerson
196 * Added checking to Smart Cable gain functions.
197 *
198 * Revision 3.69 2000/12/04 21:05:20 eokerson
199 * Changed ixjdebug levels.
200 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
201 *
202 * Revision 3.68 2000/12/04 00:17:21 craigs
203 * Changed mixer voice gain to +6dB rather than 0dB
204 *
205 * Revision 3.67 2000/11/30 21:25:51 eokerson
206 * Fixed write signal errors.
207 *
208 * Revision 3.66 2000/11/29 22:42:44 eokerson
209 * Fixed PSTN ring detect problems.
210 *
211 * Revision 3.65 2000/11/29 07:31:55 craigs
212 * Added new 425Hz filter co-efficients
213 * Added card-specific DTMF prescaler initialisation
214 *
215 * Revision 3.64 2000/11/28 14:03:32 craigs
216 * Changed certain mixer initialisations to be 0dB rather than 12dB
217 * Added additional information to /proc/ixj
218 *
219 * Revision 3.63 2000/11/28 11:38:41 craigs
220 * Added display of AEC modes in AUTO and AGC mode
221 *
222 * Revision 3.62 2000/11/28 04:05:44 eokerson
223 * Improved PSTN ring detection routine.
224 *
225 * Revision 3.61 2000/11/27 21:53:12 eokerson
226 * Fixed flash detection.
227 *
228 * Revision 3.60 2000/11/27 15:57:29 eokerson
229 * More work on G.729 load routines.
230 *
231 * Revision 3.59 2000/11/25 21:55:12 eokerson
232 * Fixed errors in G.729 load routine.
233 *
234 * Revision 3.58 2000/11/25 04:08:29 eokerson
235 * Added board locks around G.729 and TS85 load routines.
236 *
237 * Revision 3.57 2000/11/24 05:35:17 craigs
238 * Added ability to retrieve mixer values on LineJACK
239 * Added complete initialisation of all mixer values at startup
240 * Fixed spelling mistake
241 *
242 * Revision 3.56 2000/11/23 02:52:11 robertj
243 * Added cvs change log keyword.
244 * Fixed bug in capabilities list when using G.729 module.
245 *
246 */
247
248#include "ixj-ver.h"
249
250#define PERFMON_STATS
251#define IXJDEBUG 0
252#define MAXRINGS 5
253
254#include <linux/module.h>
255
256#include <linux/init.h>
257#include <linux/sched.h>
258#include <linux/kernel.h> /* printk() */
259#include <linux/fs.h> /* everything... */
260#include <linux/errno.h> /* error codes */
261#include <linux/slab.h>
262#include <linux/mm.h>
263#include <linux/ioport.h>
264#include <linux/interrupt.h>
265#include <linux/proc_fs.h>
266#include <linux/poll.h>
267#include <linux/timer.h>
268#include <linux/delay.h>
269#include <linux/pci.h>
270
271#include <asm/io.h>
272#include <asm/uaccess.h>
273
274#include <linux/isapnp.h>
275
276#include "ixj.h"
277
278#define TYPE(inode) (iminor(inode) >> 4)
279#define NUM(inode) (iminor(inode) & 0xf)
280
281static int ixjdebug;
282static int hertz = HZ;
283static int samplerate = 100;
284
285module_param(ixjdebug, int, 0);
286
287/************************************************************************
288*
289* ixjdebug meanings are now bit mapped instead of level based
290* Values can be or'ed together to turn on multiple messages
291*
292* bit 0 (0x0001) = any failure
293* bit 1 (0x0002) = general messages
294* bit 2 (0x0004) = POTS ringing related
295* bit 3 (0x0008) = PSTN events
296* bit 4 (0x0010) = PSTN Cadence state details
297* bit 5 (0x0020) = Tone detection triggers
298* bit 6 (0x0040) = Tone detection cadence details
299* bit 7 (0x0080) = ioctl tracking
300* bit 8 (0x0100) = signal tracking
301* bit 9 (0x0200) = CallerID generation details
302*
303************************************************************************/
304
305#ifdef IXJ_DYN_ALLOC
306
307static IXJ *ixj[IXJMAX];
308#define get_ixj(b) ixj[(b)]
309
310/*
311 * Allocate a free IXJ device
312 */
313
314static IXJ *ixj_alloc()
315{
316 for(cnt=0; cnt<IXJMAX; cnt++)
317 {
318 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
319 {
320 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
321 if (j == NULL)
322 return NULL;
323 ixj[cnt] = j;
324 return j;
325 }
326 }
327 return NULL;
328}
329
330static void ixj_fsk_free(IXJ *j)
331{
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]332 kfree(j->fskdata);
333 j->fskdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]334}
335
336static void ixj_fsk_alloc(IXJ *j)
337{
338 if(!j->fskdata) {
339 j->fskdata = kmalloc(8000, GFP_KERNEL);
340 if (!j->fskdata) {
341 if(ixjdebug & 0x0200) {
342 printk("IXJ phone%d - allocate failed\n", j->board);
343 }
344 return;
345 } else {
346 j->fsksize = 8000;
347 if(ixjdebug & 0x0200) {
348 printk("IXJ phone%d - allocate succeded\n", j->board);
349 }
350 }
351 }
352}
353
354#else
355
356static IXJ ixj[IXJMAX];
357#define get_ixj(b) (&ixj[(b)])
358
359/*
360 * Allocate a free IXJ device
361 */
362
363static IXJ *ixj_alloc(void)
364{
365 int cnt;
366 for(cnt=0; cnt<IXJMAX; cnt++) {
367 if(!ixj[cnt].DSPbase)
368 return &ixj[cnt];
369 }
370 return NULL;
371}
372
373static inline void ixj_fsk_free(IXJ *j) {;}
374
375static inline void ixj_fsk_alloc(IXJ *j)
376{
377 j->fsksize = 8000;
378}
379
380#endif
381
382#ifdef PERFMON_STATS
383#define ixj_perfmon(x) ((x)++)
384#else
385#define ixj_perfmon(x) do { } while(0)
386#endif
387
388static int ixj_convert_loaded;
389
390static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
391
392/************************************************************************
393*
394* These are function definitions to allow external modules to register
395* enhanced functionality call backs.
396*
397************************************************************************/
398
399static int Stub(IXJ * J, unsigned long arg)
400{
401 return 0;
402}
403
404static IXJ_REGFUNC ixj_PreRead = &Stub;
405static IXJ_REGFUNC ixj_PostRead = &Stub;
406static IXJ_REGFUNC ixj_PreWrite = &Stub;
407static IXJ_REGFUNC ixj_PostWrite = &Stub;
408
409static void ixj_read_frame(IXJ *j);
410static void ixj_write_frame(IXJ *j);
411static void ixj_init_timer(IXJ *j);
412static void ixj_add_timer(IXJ * j);
413static void ixj_timeout(unsigned long ptr);
414static int read_filters(IXJ *j);
415static int LineMonitor(IXJ *j);
416static int ixj_fasync(int fd, struct file *, int mode);
417static int ixj_set_port(IXJ *j, int arg);
418static int ixj_set_pots(IXJ *j, int arg);
419static int ixj_hookstate(IXJ *j);
420static int ixj_record_start(IXJ *j);
421static void ixj_record_stop(IXJ *j);
422static void set_rec_volume(IXJ *j, int volume);
423static int get_rec_volume(IXJ *j);
424static int set_rec_codec(IXJ *j, int rate);
425static void ixj_vad(IXJ *j, int arg);
426static int ixj_play_start(IXJ *j);
427static void ixj_play_stop(IXJ *j);
428static int ixj_set_tone_on(unsigned short arg, IXJ *j);
429static int ixj_set_tone_off(unsigned short, IXJ *j);
430static int ixj_play_tone(IXJ *j, char tone);
431static void ixj_aec_start(IXJ *j, int level);
432static int idle(IXJ *j);
433static void ixj_ring_on(IXJ *j);
434static void ixj_ring_off(IXJ *j);
435static void aec_stop(IXJ *j);
436static void ixj_ringback(IXJ *j);
437static void ixj_busytone(IXJ *j);
438static void ixj_dialtone(IXJ *j);
439static void ixj_cpt_stop(IXJ *j);
440static char daa_int_read(IXJ *j);
441static char daa_CR_read(IXJ *j, int cr);
442static int daa_set_mode(IXJ *j, int mode);
443static int ixj_linetest(IXJ *j);
444static int ixj_daa_write(IXJ *j);
445static int ixj_daa_cid_read(IXJ *j);
446static void DAA_Coeff_US(IXJ *j);
447static void DAA_Coeff_UK(IXJ *j);
448static void DAA_Coeff_France(IXJ *j);
449static void DAA_Coeff_Germany(IXJ *j);
450static void DAA_Coeff_Australia(IXJ *j);
451static void DAA_Coeff_Japan(IXJ *j);
452static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
453static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
454static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
455static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
456static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
457/* Serial Control Interface funtions */
458static int SCI_Control(IXJ *j, int control);
459static int SCI_Prepare(IXJ *j);
460static int SCI_WaitHighSCI(IXJ *j);
461static int SCI_WaitLowSCI(IXJ *j);
462static DWORD PCIEE_GetSerialNumber(WORD wAddress);
463static int ixj_PCcontrol_wait(IXJ *j);
464static void ixj_pre_cid(IXJ *j);
465static void ixj_write_cid(IXJ *j);
466static void ixj_write_cid_bit(IXJ *j, int bit);
467static int set_base_frame(IXJ *j, int size);
468static int set_play_codec(IXJ *j, int rate);
469static void set_rec_depth(IXJ *j, int depth);
470static int ixj_mixer(long val, IXJ *j);
471
472/************************************************************************
473CT8020/CT8021 Host Programmers Model
474Host address Function Access
475DSPbase +
4760-1 Aux Software Status Register (reserved) Read Only
4772-3 Software Status Register Read Only
4784-5 Aux Software Control Register (reserved) Read Write
4796-7 Software Control Register Read Write
4808-9 Hardware Status Register Read Only
481A-B Hardware Control Register Read Write
482C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
483E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
484************************************************************************/
485
486static inline void ixj_read_HSR(IXJ *j)
487{
488 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
489 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
490}
491
492static inline int IsControlReady(IXJ *j)
493{
494 ixj_read_HSR(j);
495 return j->hsr.bits.controlrdy ? 1 : 0;
496}
497
498static inline int IsPCControlReady(IXJ *j)
499{
500 j->pccr1.byte = inb_p(j->XILINXbase + 3);
501 return j->pccr1.bits.crr ? 1 : 0;
502}
503
504static inline int IsStatusReady(IXJ *j)
505{
506 ixj_read_HSR(j);
507 return j->hsr.bits.statusrdy ? 1 : 0;
508}
509
510static inline int IsRxReady(IXJ *j)
511{
512 ixj_read_HSR(j);
513 ixj_perfmon(j->rxreadycheck);
514 return j->hsr.bits.rxrdy ? 1 : 0;
515}
516
517static inline int IsTxReady(IXJ *j)
518{
519 ixj_read_HSR(j);
520 ixj_perfmon(j->txreadycheck);
521 return j->hsr.bits.txrdy ? 1 : 0;
522}
523
524static inline void set_play_volume(IXJ *j, int volume)
525{
526 if (ixjdebug & 0x0002)
527 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
528 ixj_WriteDSPCommand(0xCF02, j);
529 ixj_WriteDSPCommand(volume, j);
530}
531
532static int set_play_volume_linear(IXJ *j, int volume)
533{
534 int newvolume, dspplaymax;
535
536 if (ixjdebug & 0x0002)
537 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
538 if(volume > 100 || volume < 0) {
539 return -1;
540 }
541
542 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
543 switch (j->cardtype) {
544 case QTI_PHONEJACK:
545 dspplaymax = 0x380;
546 break;
547 case QTI_LINEJACK:
548 if(j->port == PORT_PSTN) {
549 dspplaymax = 0x48;
550 } else {
551 dspplaymax = 0x100;
552 }
553 break;
554 case QTI_PHONEJACK_LITE:
555 dspplaymax = 0x380;
556 break;
557 case QTI_PHONEJACK_PCI:
558 dspplaymax = 0x6C;
559 break;
560 case QTI_PHONECARD:
561 dspplaymax = 0x50;
562 break;
563 default:
564 return -1;
565 }
566 newvolume = (dspplaymax * volume) / 100;
567 set_play_volume(j, newvolume);
568 return 0;
569}
570
571static inline void set_play_depth(IXJ *j, int depth)
572{
573 if (depth > 60)
574 depth = 60;
575 if (depth < 0)
576 depth = 0;
577 ixj_WriteDSPCommand(0x5280 + depth, j);
578}
579
580static inline int get_play_volume(IXJ *j)
581{
582 ixj_WriteDSPCommand(0xCF00, j);
583 return j->ssr.high << 8 | j->ssr.low;
584}
585
586static int get_play_volume_linear(IXJ *j)
587{
588 int volume, newvolume, dspplaymax;
589
590 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
591 switch (j->cardtype) {
592 case QTI_PHONEJACK:
593 dspplaymax = 0x380;
594 break;
595 case QTI_LINEJACK:
596 if(j->port == PORT_PSTN) {
597 dspplaymax = 0x48;
598 } else {
599 dspplaymax = 0x100;
600 }
601 break;
602 case QTI_PHONEJACK_LITE:
603 dspplaymax = 0x380;
604 break;
605 case QTI_PHONEJACK_PCI:
606 dspplaymax = 0x6C;
607 break;
608 case QTI_PHONECARD:
609 dspplaymax = 100;
610 break;
611 default:
612 return -1;
613 }
614 volume = get_play_volume(j);
615 newvolume = (volume * 100) / dspplaymax;
616 if(newvolume > 100)
617 newvolume = 100;
618 return newvolume;
619}
620
621static inline BYTE SLIC_GetState(IXJ *j)
622{
623 if (j->cardtype == QTI_PHONECARD) {
624 j->pccr1.byte = 0;
625 j->psccr.bits.dev = 3;
626 j->psccr.bits.rw = 1;
627 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
628 ixj_PCcontrol_wait(j);
629 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
630 ixj_PCcontrol_wait(j);
631 if (j->pslic.bits.powerdown)
632 return PLD_SLIC_STATE_OC;
633 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
634 return PLD_SLIC_STATE_ACTIVE;
635 else
636 return PLD_SLIC_STATE_RINGING;
637 } else {
638 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
639 }
640 return j->pld_slicr.bits.state;
641}
642
643static BOOL SLIC_SetState(BYTE byState, IXJ *j)
644{
645 BOOL fRetVal = FALSE;
646
647 if (j->cardtype == QTI_PHONECARD) {
648 if (j->flags.pcmciasct) {
649 switch (byState) {
650 case PLD_SLIC_STATE_TIPOPEN:
651 case PLD_SLIC_STATE_OC:
652 j->pslic.bits.powerdown = 1;
653 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
654 fRetVal = TRUE;
655 break;
656 case PLD_SLIC_STATE_RINGING:
657 if (j->readers || j->writers) {
658 j->pslic.bits.powerdown = 0;
659 j->pslic.bits.ring0 = 1;
660 j->pslic.bits.ring1 = 0;
661 fRetVal = TRUE;
662 }
663 break;
664 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
665
666 case PLD_SLIC_STATE_STANDBY:
667 case PLD_SLIC_STATE_ACTIVE:
668 if (j->readers || j->writers) {
669 j->pslic.bits.powerdown = 0;
670 } else {
671 j->pslic.bits.powerdown = 1;
672 }
673 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
674 fRetVal = TRUE;
675 break;
676 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
677
678 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
679
680 default:
681 fRetVal = FALSE;
682 break;
683 }
684 j->psccr.bits.dev = 3;
685 j->psccr.bits.rw = 0;
686 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
687 ixj_PCcontrol_wait(j);
688 }
689 } else {
690 /* Set the C1, C2, C3 & B2EN signals. */
691 switch (byState) {
692 case PLD_SLIC_STATE_OC:
693 j->pld_slicw.bits.c1 = 0;
694 j->pld_slicw.bits.c2 = 0;
695 j->pld_slicw.bits.c3 = 0;
696 j->pld_slicw.bits.b2en = 0;
697 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
698 fRetVal = TRUE;
699 break;
700 case PLD_SLIC_STATE_RINGING:
701 j->pld_slicw.bits.c1 = 1;
702 j->pld_slicw.bits.c2 = 0;
703 j->pld_slicw.bits.c3 = 0;
704 j->pld_slicw.bits.b2en = 1;
705 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
706 fRetVal = TRUE;
707 break;
708 case PLD_SLIC_STATE_ACTIVE:
709 j->pld_slicw.bits.c1 = 0;
710 j->pld_slicw.bits.c2 = 1;
711 j->pld_slicw.bits.c3 = 0;
712 j->pld_slicw.bits.b2en = 0;
713 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
714 fRetVal = TRUE;
715 break;
716 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
717
718 j->pld_slicw.bits.c1 = 1;
719 j->pld_slicw.bits.c2 = 1;
720 j->pld_slicw.bits.c3 = 0;
721 j->pld_slicw.bits.b2en = 0;
722 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
723 fRetVal = TRUE;
724 break;
725 case PLD_SLIC_STATE_TIPOPEN:
726 j->pld_slicw.bits.c1 = 0;
727 j->pld_slicw.bits.c2 = 0;
728 j->pld_slicw.bits.c3 = 1;
729 j->pld_slicw.bits.b2en = 0;
730 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
731 fRetVal = TRUE;
732 break;
733 case PLD_SLIC_STATE_STANDBY:
734 j->pld_slicw.bits.c1 = 1;
735 j->pld_slicw.bits.c2 = 0;
736 j->pld_slicw.bits.c3 = 1;
737 j->pld_slicw.bits.b2en = 1;
738 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
739 fRetVal = TRUE;
740 break;
741 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
742
743 j->pld_slicw.bits.c1 = 0;
744 j->pld_slicw.bits.c2 = 1;
745 j->pld_slicw.bits.c3 = 1;
746 j->pld_slicw.bits.b2en = 0;
747 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
748 fRetVal = TRUE;
749 break;
750 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
751
752 j->pld_slicw.bits.c1 = 1;
753 j->pld_slicw.bits.c2 = 1;
754 j->pld_slicw.bits.c3 = 1;
755 j->pld_slicw.bits.b2en = 0;
756 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
757 fRetVal = TRUE;
758 break;
759 default:
760 fRetVal = FALSE;
761 break;
762 }
763 }
764
765 return fRetVal;
766}
767
768static int ixj_wink(IXJ *j)
769{
770 BYTE slicnow;
771
772 slicnow = SLIC_GetState(j);
773
774 j->pots_winkstart = jiffies;
775 SLIC_SetState(PLD_SLIC_STATE_OC, j);
776
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]777 msleep(jiffies_to_msecs(j->winktime));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]778
779 SLIC_SetState(slicnow, j);
780 return 0;
781}
782
783static void ixj_init_timer(IXJ *j)
784{
785 init_timer(&j->timer);
786 j->timer.function = ixj_timeout;
787 j->timer.data = (unsigned long)j;
788}
789
790static void ixj_add_timer(IXJ *j)
791{
792 j->timer.expires = jiffies + (hertz / samplerate);
793 add_timer(&j->timer);
794}
795
796static void ixj_tone_timeout(IXJ *j)
797{
798 IXJ_TONE ti;
799
800 j->tone_state++;
801 if (j->tone_state == 3) {
802 j->tone_state = 0;
803 if (j->cadence_t) {
804 j->tone_cadence_state++;
805 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
806 switch (j->cadence_t->termination) {
807 case PLAY_ONCE:
808 ixj_cpt_stop(j);
809 break;
810 case REPEAT_LAST_ELEMENT:
811 j->tone_cadence_state--;
812 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
813 break;
814 case REPEAT_ALL:
815 j->tone_cadence_state = 0;
816 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
817 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
818 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
819 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
820 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
821 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
822 ixj_init_tone(j, &ti);
823 }
824 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
825 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
826 ixj_play_tone(j, j->cadence_t->ce[0].index);
827 break;
828 }
829 } else {
830 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
831 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
832 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
833 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
834 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
835 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
836 ixj_init_tone(j, &ti);
837 }
838 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
839 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
840 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
841 }
842 }
843 }
844}
845
846static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
847{
848 if(j->ixj_signals[event]) {
849 if(ixjdebug & 0x0100)
850 printk("Sending signal for event %d\n", event);
851 /* Send apps notice of change */
852 /* see config.h for macro definition */
853 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
854 }
855}
856
857static void ixj_pstn_state(IXJ *j)
858{
859 int var;
860 union XOPXR0 XR0, daaint;
861
862 var = 10;
863
864 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
865 daaint.reg = 0;
866 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
867
868 j->pld_scrr.byte = inb_p(j->XILINXbase);
869 if (j->pld_scrr.bits.daaflag) {
870 daa_int_read(j);
871 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
872 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
873 daaint.bitreg.RING = 1;
874 if(ixjdebug & 0x0008) {
875 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
876 }
877 } else {
878 daa_set_mode(j, SOP_PU_RESET);
879 }
880 }
881 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
882 daaint.bitreg.Caller_ID = 1;
883 j->pstn_cid_intr = 1;
884 j->pstn_cid_received = jiffies;
885 if(ixjdebug & 0x0008) {
886 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
887 }
888 }
889 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
890 daaint.bitreg.Cadence = 1;
891 if(ixjdebug & 0x0008) {
892 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
893 }
894 }
895 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
896 daaint.bitreg.VDD_OK = 1;
897 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
898 }
899 }
900 daa_CR_read(j, 1);
901 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)) {
902 daaint.bitreg.RMR = 1;
903 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
904 if(ixjdebug & 0x0008) {
905 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);
906 }
907 j->pstn_prev_rmr = j->pstn_last_rmr;
908 j->pstn_last_rmr = jiffies;
909 }
910 switch(j->daa_mode) {
911 case SOP_PU_SLEEP:
912 if (daaint.bitreg.RING) {
913 if (!j->flags.pstn_ringing) {
914 if (j->daa_mode != SOP_PU_RINGING) {
915 j->pstn_ring_int = jiffies;
916 daa_set_mode(j, SOP_PU_RINGING);
917 }
918 }
919 }
920 break;
921 case SOP_PU_RINGING:
922 if (daaint.bitreg.RMR) {
923 if (ixjdebug & 0x0008) {
924 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
925 }
926 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
927 j->flags.pstn_rmr = 1;
928 j->pstn_ring_start = jiffies;
929 j->pstn_ring_stop = 0;
930 j->ex.bits.pstn_ring = 0;
931 if (j->cadence_f[4].state == 0) {
932 j->cadence_f[4].state = 1;
933 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
934 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
935 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
936 } else if (j->cadence_f[4].state == 2) {
937 if((time_after(jiffies, j->cadence_f[4].off1min) &&
938 time_before(jiffies, j->cadence_f[4].off1max))) {
939 if (j->cadence_f[4].on2) {
940 j->cadence_f[4].state = 3;
941 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
942 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
943 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
944 } else {
945 j->cadence_f[4].state = 7;
946 }
947 } else {
948 if (ixjdebug & 0x0008) {
949 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
950 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
951 j->cadence_f[4].off1);
952 }
953 j->cadence_f[4].state = 0;
954 }
955 } else if (j->cadence_f[4].state == 4) {
956 if((time_after(jiffies, j->cadence_f[4].off2min) &&
957 time_before(jiffies, j->cadence_f[4].off2max))) {
958 if (j->cadence_f[4].on3) {
959 j->cadence_f[4].state = 5;
960 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
961 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
962 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
963 } else {
964 j->cadence_f[4].state = 7;
965 }
966 } else {
967 if (ixjdebug & 0x0008) {
968 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
969 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
970 j->cadence_f[4].off2);
971 }
972 j->cadence_f[4].state = 0;
973 }
974 } else if (j->cadence_f[4].state == 6) {
975 if((time_after(jiffies, j->cadence_f[4].off3min) &&
976 time_before(jiffies, j->cadence_f[4].off3max))) {
977 j->cadence_f[4].state = 7;
978 } else {
979 if (ixjdebug & 0x0008) {
980 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
981 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
982 j->cadence_f[4].off3);
983 }
984 j->cadence_f[4].state = 0;
985 }
986 } else {
987 j->cadence_f[4].state = 0;
988 }
989 } else { /* Falling edge of RMR */
990 j->pstn_ring_start = 0;
991 j->pstn_ring_stop = jiffies;
992 if (j->cadence_f[4].state == 1) {
993 if(!j->cadence_f[4].on1) {
994 j->cadence_f[4].state = 7;
995 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
996 time_before(jiffies, j->cadence_f[4].on1max))) {
997 if (j->cadence_f[4].off1) {
998 j->cadence_f[4].state = 2;
999 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1000 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1001 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1002 } else {
1003 j->cadence_f[4].state = 7;
1004 }
1005 } else {
1006 if (ixjdebug & 0x0008) {
1007 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1008 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1009 j->cadence_f[4].on1);
1010 }
1011 j->cadence_f[4].state = 0;
1012 }
1013 } else if (j->cadence_f[4].state == 3) {
1014 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1015 time_before(jiffies, j->cadence_f[4].on2max))) {
1016 if (j->cadence_f[4].off2) {
1017 j->cadence_f[4].state = 4;
1018 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1019 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1020 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1021 } else {
1022 j->cadence_f[4].state = 7;
1023 }
1024 } else {
1025 if (ixjdebug & 0x0008) {
1026 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1027 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1028 j->cadence_f[4].on2);
1029 }
1030 j->cadence_f[4].state = 0;
1031 }
1032 } else if (j->cadence_f[4].state == 5) {
1033 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1034 time_before(jiffies, j->cadence_f[4].on3max))) {
1035 if (j->cadence_f[4].off3) {
1036 j->cadence_f[4].state = 6;
1037 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1038 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1039 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1040 } else {
1041 j->cadence_f[4].state = 7;
1042 }
1043 } else {
1044 j->cadence_f[4].state = 0;
1045 }
1046 } else {
1047 if (ixjdebug & 0x0008) {
1048 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1049 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1050 j->cadence_f[4].on3);
1051 }
1052 j->cadence_f[4].state = 0;
1053 }
1054 }
1055 if (ixjdebug & 0x0010) {
1056 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1057 }
1058 if (ixjdebug & 0x0010) {
1059 switch(j->cadence_f[4].state) {
1060 case 1:
1061 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1062 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1063 break;
1064 case 2:
1065 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1066 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1067 break;
1068 case 3:
1069 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1070 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1071 break;
1072 case 4:
1073 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1074 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1075 break;
1076 case 5:
1077 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1078 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1079 break;
1080 case 6:
1081 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1082 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1083 break;
1084 }
1085 }
1086 }
1087 if (j->cadence_f[4].state == 7) {
1088 j->cadence_f[4].state = 0;
1089 j->pstn_ring_stop = jiffies;
1090 j->ex.bits.pstn_ring = 1;
1091 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1092 if(ixjdebug & 0x0008) {
1093 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1094 }
1095 }
1096 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1097 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1098 if(ixjdebug & 0x0008) {
1099 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1100 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1101 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1102 }
1103 j->pstn_ring_stop = j->pstn_ring_int = 0;
1104 daa_set_mode(j, SOP_PU_SLEEP);
1105 }
1106 outb_p(j->pld_scrw.byte, j->XILINXbase);
1107 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1108 ixj_daa_cid_read(j);
1109 j->ex.bits.caller_id = 1;
1110 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1111 j->pstn_cid_intr = 0;
1112 }
1113 if (daaint.bitreg.Cadence) {
1114 if(ixjdebug & 0x0008) {
1115 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1116 }
1117 daa_set_mode(j, SOP_PU_SLEEP);
1118 j->ex.bits.pstn_ring = 0;
1119 }
1120 break;
1121 case SOP_PU_CONVERSATION:
1122 if (daaint.bitreg.VDD_OK) {
1123 if(!daaint.bitreg.SI_0) {
1124 if (!j->pstn_winkstart) {
1125 if(ixjdebug & 0x0008) {
1126 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1127 }
1128 j->pstn_winkstart = jiffies;
1129 }
1130 } else {
1131 if (j->pstn_winkstart) {
1132 if(ixjdebug & 0x0008) {
1133 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1134 }
1135 j->pstn_winkstart = 0;
1136 }
1137 }
1138 }
1139 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1140 if(ixjdebug & 0x0008) {
1141 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1142 }
1143 daa_set_mode(j, SOP_PU_SLEEP);
1144 j->pstn_winkstart = 0;
1145 j->ex.bits.pstn_wink = 1;
1146 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1147 }
1148 break;
1149 }
1150}
1151
1152static void ixj_timeout(unsigned long ptr)
1153{
1154 int board;
1155 unsigned long jifon;
1156 IXJ *j = (IXJ *)ptr;
1157 board = j->board;
1158
1159 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1160 ixj_perfmon(j->timerchecks);
1161 j->hookstate = ixj_hookstate(j);
1162 if (j->tone_state) {
1163 if (!(j->hookstate)) {
1164 ixj_cpt_stop(j);
1165 if (j->m_hook) {
1166 j->m_hook = 0;
1167 j->ex.bits.hookstate = 1;
1168 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1169 }
1170 clear_bit(board, &j->busyflags);
1171 ixj_add_timer(j);
1172 return;
1173 }
1174 if (j->tone_state == 1)
1175 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1176 else
1177 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1178 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1179 if (j->tone_state == 1) {
1180 ixj_play_tone(j, j->tone_index);
1181 if (j->dsp.low == 0x20) {
1182 clear_bit(board, &j->busyflags);
1183 ixj_add_timer(j);
1184 return;
1185 }
1186 } else {
1187 ixj_play_tone(j, 0);
1188 if (j->dsp.low == 0x20) {
1189 clear_bit(board, &j->busyflags);
1190 ixj_add_timer(j);
1191 return;
1192 }
1193 }
1194 } else {
1195 ixj_tone_timeout(j);
1196 if (j->flags.dialtone) {
1197 ixj_dialtone(j);
1198 }
1199 if (j->flags.busytone) {
1200 ixj_busytone(j);
1201 if (j->dsp.low == 0x20) {
1202 clear_bit(board, &j->busyflags);
1203 ixj_add_timer(j);
1204 return;
1205 }
1206 }
1207 if (j->flags.ringback) {
1208 ixj_ringback(j);
1209 if (j->dsp.low == 0x20) {
1210 clear_bit(board, &j->busyflags);
1211 ixj_add_timer(j);
1212 return;
1213 }
1214 }
1215 if (!j->tone_state) {
1216 ixj_cpt_stop(j);
1217 }
1218 }
1219 }
1220 if (!(j->tone_state && j->dsp.low == 0x20)) {
1221 if (IsRxReady(j)) {
1222 ixj_read_frame(j);
1223 }
1224 if (IsTxReady(j)) {
1225 ixj_write_frame(j);
1226 }
1227 }
1228 if (j->flags.cringing) {
1229 if (j->hookstate & 1) {
1230 j->flags.cringing = 0;
1231 ixj_ring_off(j);
1232 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1233 switch(j->cadence_f[5].state) {
1234 case 0:
1235 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1236 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1237 if(ixjdebug & 0x0004) {
1238 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1239 }
1240 ixj_ring_on(j);
1241 }
1242 j->cadence_f[5].state = 1;
1243 break;
1244 case 1:
1245 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1246 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1247 if(ixjdebug & 0x0004) {
1248 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1249 }
1250 ixj_ring_off(j);
1251 j->cadence_f[5].state = 2;
1252 }
1253 break;
1254 case 2:
1255 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1256 if(ixjdebug & 0x0004) {
1257 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1258 }
1259 ixj_ring_on(j);
1260 if (j->cadence_f[5].on2) {
1261 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1262 j->cadence_f[5].state = 3;
1263 } else {
1264 j->cadence_f[5].state = 7;
1265 }
1266 }
1267 break;
1268 case 3:
1269 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1270 if(ixjdebug & 0x0004) {
1271 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1272 }
1273 ixj_ring_off(j);
1274 if (j->cadence_f[5].off2) {
1275 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1276 j->cadence_f[5].state = 4;
1277 } else {
1278 j->cadence_f[5].state = 7;
1279 }
1280 }
1281 break;
1282 case 4:
1283 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1284 if(ixjdebug & 0x0004) {
1285 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1286 }
1287 ixj_ring_on(j);
1288 if (j->cadence_f[5].on3) {
1289 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1290 j->cadence_f[5].state = 5;
1291 } else {
1292 j->cadence_f[5].state = 7;
1293 }
1294 }
1295 break;
1296 case 5:
1297 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1298 if(ixjdebug & 0x0004) {
1299 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1300 }
1301 ixj_ring_off(j);
1302 if (j->cadence_f[5].off3) {
1303 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1304 j->cadence_f[5].state = 6;
1305 } else {
1306 j->cadence_f[5].state = 7;
1307 }
1308 }
1309 break;
1310 case 6:
1311 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1312 if(ixjdebug & 0x0004) {
1313 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1314 }
1315 j->cadence_f[5].state = 7;
1316 }
1317 break;
1318 case 7:
1319 if(ixjdebug & 0x0004) {
1320 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321 }
1322 j->flags.cidring = 1;
1323 j->cadence_f[5].state = 0;
1324 break;
1325 }
1326 if (j->flags.cidring && !j->flags.cidsent) {
1327 j->flags.cidsent = 1;
1328 if(j->fskdcnt) {
1329 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1330 ixj_pre_cid(j);
1331 }
1332 j->flags.cidring = 0;
1333 }
1334 clear_bit(board, &j->busyflags);
1335 ixj_add_timer(j);
1336 return;
1337 } else {
1338 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1339 if (j->flags.cidring && !j->flags.cidsent) {
1340 j->flags.cidsent = 1;
1341 if(j->fskdcnt) {
1342 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1343 ixj_pre_cid(j);
1344 }
1345 j->flags.cidring = 0;
1346 }
1347 j->ring_cadence_t--;
1348 if (j->ring_cadence_t == -1)
1349 j->ring_cadence_t = 15;
1350 j->ring_cadence_jif = jiffies;
1351
1352 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1353 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1354 j->flags.firstring = 1;
1355 else
1356 ixj_ring_on(j);
1357 } else {
1358 ixj_ring_off(j);
1359 if(!j->flags.cidsent)
1360 j->flags.cidring = 1;
1361 }
1362 }
1363 clear_bit(board, &j->busyflags);
1364 ixj_add_timer(j);
1365 return;
1366 }
1367 }
1368 if (!j->flags.ringing) {
1369 if (j->hookstate) { /* & 1) { */
1370 if (j->dsp.low != 0x20 &&
1371 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1372 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1373 }
1374 LineMonitor(j);
1375 read_filters(j);
1376 ixj_WriteDSPCommand(0x511B, j);
1377 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1378 if (!j->m_hook && (j->hookstate & 1)) {
1379 j->m_hook = j->ex.bits.hookstate = 1;
1380 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1381 }
1382 } else {
1383 if (j->ex.bits.dtmf_ready) {
1384 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1385 }
1386 if (j->m_hook) {
1387 j->m_hook = 0;
1388 j->ex.bits.hookstate = 1;
1389 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1390 }
1391 }
1392 }
1393 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1394 ixj_pstn_state(j);
1395 }
1396 if (j->ex.bytes) {
1397 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1398 }
1399 clear_bit(board, &j->busyflags);
1400 }
1401 ixj_add_timer(j);
1402}
1403
1404static int ixj_status_wait(IXJ *j)
1405{
1406 unsigned long jif;
1407
1408 jif = jiffies + ((60 * hertz) / 100);
1409 while (!IsStatusReady(j)) {
1410 ixj_perfmon(j->statuswait);
1411 if (time_after(jiffies, jif)) {
1412 ixj_perfmon(j->statuswaitfail);
1413 return -1;
1414 }
1415 }
1416 return 0;
1417}
1418
1419static int ixj_PCcontrol_wait(IXJ *j)
1420{
1421 unsigned long jif;
1422
1423 jif = jiffies + ((60 * hertz) / 100);
1424 while (!IsPCControlReady(j)) {
1425 ixj_perfmon(j->pcontrolwait);
1426 if (time_after(jiffies, jif)) {
1427 ixj_perfmon(j->pcontrolwaitfail);
1428 return -1;
1429 }
1430 }
1431 return 0;
1432}
1433
1434static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1435{
1436 BYTES bytes;
1437 unsigned long jif;
1438
1439 atomic_inc(&j->DSPWrite);
1440 if(atomic_read(&j->DSPWrite) > 1) {
1441 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1442 return -1;
1443 }
1444 bytes.high = (cmd & 0xFF00) >> 8;
1445 bytes.low = cmd & 0x00FF;
1446 jif = jiffies + ((60 * hertz) / 100);
1447 while (!IsControlReady(j)) {
1448 ixj_perfmon(j->iscontrolready);
1449 if (time_after(jiffies, jif)) {
1450 ixj_perfmon(j->iscontrolreadyfail);
1451 atomic_dec(&j->DSPWrite);
1452 if(atomic_read(&j->DSPWrite) > 0) {
1453 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1454 while(atomic_read(&j->DSPWrite) > 0) {
1455 atomic_dec(&j->DSPWrite);
1456 }
1457 }
1458 return -1;
1459 }
1460 }
1461 outb(bytes.low, j->DSPbase + 6);
1462 outb(bytes.high, j->DSPbase + 7);
1463
1464 if (ixj_status_wait(j)) {
1465 j->ssr.low = 0xFF;
1466 j->ssr.high = 0xFF;
1467 atomic_dec(&j->DSPWrite);
1468 if(atomic_read(&j->DSPWrite) > 0) {
1469 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1470 while(atomic_read(&j->DSPWrite) > 0) {
1471 atomic_dec(&j->DSPWrite);
1472 }
1473 }
1474 return -1;
1475 }
1476/* Read Software Status Register */
1477 j->ssr.low = inb_p(j->DSPbase + 2);
1478 j->ssr.high = inb_p(j->DSPbase + 3);
1479 atomic_dec(&j->DSPWrite);
1480 if(atomic_read(&j->DSPWrite) > 0) {
1481 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1482 while(atomic_read(&j->DSPWrite) > 0) {
1483 atomic_dec(&j->DSPWrite);
1484 }
1485 }
1486 return 0;
1487}
1488
1489/***************************************************************************
1490*
1491* General Purpose IO Register read routine
1492*
1493***************************************************************************/
1494static inline int ixj_gpio_read(IXJ *j)
1495{
1496 if (ixj_WriteDSPCommand(0x5143, j))
1497 return -1;
1498
1499 j->gpio.bytes.low = j->ssr.low;
1500 j->gpio.bytes.high = j->ssr.high;
1501
1502 return 0;
1503}
1504
1505static inline void LED_SetState(int state, IXJ *j)
1506{
1507 if (j->cardtype == QTI_LINEJACK) {
1508 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1509 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1510 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1511 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1512
1513 outb(j->pld_scrw.byte, j->XILINXbase);
1514 }
1515}
1516
1517/*********************************************************************
1518* GPIO Pins are configured as follows on the Quicknet Internet
1519* PhoneJACK Telephony Cards
1520*
1521* POTS Select GPIO_6=0 GPIO_7=0
1522* Mic/Speaker Select GPIO_6=0 GPIO_7=1
1523* Handset Select GPIO_6=1 GPIO_7=0
1524*
1525* SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1526* SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1527* SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1528*
1529* Hook Switch changes reported on GPIO_3
1530*********************************************************************/
1531static int ixj_set_port(IXJ *j, int arg)
1532{
1533 if (j->cardtype == QTI_PHONEJACK_LITE) {
1534 if (arg != PORT_POTS)
1535 return 10;
1536 else
1537 return 0;
1538 }
1539 switch (arg) {
1540 case PORT_POTS:
1541 j->port = PORT_POTS;
1542 switch (j->cardtype) {
1543 case QTI_PHONECARD:
1544 if (j->flags.pcmciasct == 1)
1545 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1546 else
1547 return 11;
1548 break;
1549 case QTI_PHONEJACK_PCI:
1550 j->pld_slicw.pcib.mic = 0;
1551 j->pld_slicw.pcib.spk = 0;
1552 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1553 break;
1554 case QTI_LINEJACK:
1555 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1556 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1557 Software Control Register */
1558 return 2;
1559 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1560
1561 outb(j->pld_scrw.byte, j->XILINXbase);
1562 j->pld_clock.byte = 0;
1563 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1564 j->pld_slicw.bits.rly1 = 1;
1565 j->pld_slicw.bits.spken = 0;
1566 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1567 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1568 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1569 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1570 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1571 ixj_mixer(0x0E80, j); /*Mic mute */
1572 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1573 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1574 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1575 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1576/* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1577 break;
1578 case QTI_PHONEJACK:
1579 j->gpio.bytes.high = 0x0B;
1580 j->gpio.bits.gpio6 = 0;
1581 j->gpio.bits.gpio7 = 0;
1582 ixj_WriteDSPCommand(j->gpio.word, j);
1583 break;
1584 }
1585 break;
1586 case PORT_PSTN:
1587 if (j->cardtype == QTI_LINEJACK) {
1588 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1589
1590 j->pld_slicw.bits.rly3 = 0;
1591 j->pld_slicw.bits.rly1 = 1;
1592 j->pld_slicw.bits.spken = 0;
1593 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1594 j->port = PORT_PSTN;
1595 } else {
1596 return 4;
1597 }
1598 break;
1599 case PORT_SPEAKER:
1600 j->port = PORT_SPEAKER;
1601 switch (j->cardtype) {
1602 case QTI_PHONECARD:
1603 if (j->flags.pcmciasct) {
1604 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1605 }
1606 break;
1607 case QTI_PHONEJACK_PCI:
1608 j->pld_slicw.pcib.mic = 1;
1609 j->pld_slicw.pcib.spk = 1;
1610 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1611 break;
1612 case QTI_LINEJACK:
1613 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1614 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1615 Software Control Register */
1616 return 2;
1617 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1618
1619 outb(j->pld_scrw.byte, j->XILINXbase);
1620 j->pld_clock.byte = 0;
1621 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1622 j->pld_slicw.bits.rly1 = 1;
1623 j->pld_slicw.bits.spken = 1;
1624 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1625 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1626 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1627 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1628 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1629 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1630 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1631 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1632 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1633 break;
1634 case QTI_PHONEJACK:
1635 j->gpio.bytes.high = 0x0B;
1636 j->gpio.bits.gpio6 = 0;
1637 j->gpio.bits.gpio7 = 1;
1638 ixj_WriteDSPCommand(j->gpio.word, j);
1639 break;
1640 }
1641 break;
1642 case PORT_HANDSET:
1643 if (j->cardtype != QTI_PHONEJACK) {
1644 return 5;
1645 } else {
1646 j->gpio.bytes.high = 0x0B;
1647 j->gpio.bits.gpio6 = 1;
1648 j->gpio.bits.gpio7 = 0;
1649 ixj_WriteDSPCommand(j->gpio.word, j);
1650 j->port = PORT_HANDSET;
1651 }
1652 break;
1653 default:
1654 return 6;
1655 break;
1656 }
1657 return 0;
1658}
1659
1660static int ixj_set_pots(IXJ *j, int arg)
1661{
1662 if (j->cardtype == QTI_LINEJACK) {
1663 if (arg) {
1664 if (j->port == PORT_PSTN) {
1665 j->pld_slicw.bits.rly1 = 0;
1666 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1667 j->flags.pots_pstn = 1;
1668 return 1;
1669 } else {
1670 j->flags.pots_pstn = 0;
1671 return 0;
1672 }
1673 } else {
1674 j->pld_slicw.bits.rly1 = 1;
1675 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1676 j->flags.pots_pstn = 0;
1677 return 1;
1678 }
1679 } else {
1680 return 0;
1681 }
1682}
1683
1684static void ixj_ring_on(IXJ *j)
1685{
1686 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1687 {
1688 if (ixjdebug & 0x0004)
1689 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1690
1691 j->gpio.bytes.high = 0x0B;
1692 j->gpio.bytes.low = 0x00;
1693 j->gpio.bits.gpio1 = 1;
1694 j->gpio.bits.gpio2 = 1;
1695 j->gpio.bits.gpio5 = 0;
1696 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1697 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1698 {
1699 if (ixjdebug & 0x0004)
1700 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1701
1702 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1703 }
1704}
1705
1706static int ixj_siadc(IXJ *j, int val)
1707{
1708 if(j->cardtype == QTI_PHONECARD){
1709 if(j->flags.pcmciascp){
1710 if(val == -1)
1711 return j->siadc.bits.rxg;
1712
1713 if(val < 0 || val > 0x1F)
1714 return -1;
1715
1716 j->siadc.bits.hom = 0; /* Handset Out Mute */
1717 j->siadc.bits.lom = 0; /* Line Out Mute */
1718 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1719 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1720 j->psccr.bits.rw = 0; /* Read / Write flag */
1721 j->psccr.bits.dev = 0;
1722 outb(j->siadc.byte, j->XILINXbase + 0x00);
1723 outb(j->psccr.byte, j->XILINXbase + 0x01);
1724 ixj_PCcontrol_wait(j);
1725 return j->siadc.bits.rxg;
1726 }
1727 }
1728 return -1;
1729}
1730
1731static int ixj_sidac(IXJ *j, int val)
1732{
1733 if(j->cardtype == QTI_PHONECARD){
1734 if(j->flags.pcmciascp){
1735 if(val == -1)
1736 return j->sidac.bits.txg;
1737
1738 if(val < 0 || val > 0x1F)
1739 return -1;
1740
1741 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1742 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1743 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1744 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1745 j->psccr.bits.rw = 0; /* Read / Write flag */
1746 j->psccr.bits.dev = 0;
1747 outb(j->sidac.byte, j->XILINXbase + 0x00);
1748 outb(j->psccr.byte, j->XILINXbase + 0x01);
1749 ixj_PCcontrol_wait(j);
1750 return j->sidac.bits.txg;
1751 }
1752 }
1753 return -1;
1754}
1755
1756static int ixj_pcmcia_cable_check(IXJ *j)
1757{
1758 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1759 if (!j->flags.pcmciastate) {
1760 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1761 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1762 j->flags.pcmciastate = 4;
1763 return 0;
1764 }
1765 if (j->pccr1.bits.ed) {
1766 j->pccr1.bits.ed = 0;
1767 j->psccr.bits.dev = 3;
1768 j->psccr.bits.rw = 1;
1769 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1770 ixj_PCcontrol_wait(j);
1771 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1772 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1773 j->psccr.bits.dev = 3;
1774 j->psccr.bits.rw = 0;
1775 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1776 ixj_PCcontrol_wait(j);
1777 return j->pslic.bits.led2 ? 1 : 0;
1778 } else if (j->flags.pcmciasct) {
1779 return j->r_hook;
1780 } else {
1781 return 1;
1782 }
1783 } else if (j->flags.pcmciastate == 4) {
1784 if (!j->pccr1.bits.drf) {
1785 j->flags.pcmciastate = 3;
1786 }
1787 return 0;
1788 } else if (j->flags.pcmciastate == 3) {
1789 j->pccr2.bits.pwr = 0;
1790 j->pccr2.bits.rstc = 1;
1791 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1792 j->checkwait = jiffies + (hertz * 2);
1793 j->flags.incheck = 1;
1794 j->flags.pcmciastate = 2;
1795 return 0;
1796 } else if (j->flags.pcmciastate == 2) {
1797 if (j->flags.incheck) {
1798 if (time_before(jiffies, j->checkwait)) {
1799 return 0;
1800 } else {
1801 j->flags.incheck = 0;
1802 }
1803 }
1804 j->pccr2.bits.pwr = 0;
1805 j->pccr2.bits.rstc = 0;
1806 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1807 j->flags.pcmciastate = 1;
1808 return 0;
1809 } else if (j->flags.pcmciastate == 1) {
1810 j->flags.pcmciastate = 0;
1811 if (!j->pccr1.bits.drf) {
1812 j->psccr.bits.dev = 3;
1813 j->psccr.bits.rw = 1;
1814 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1815 ixj_PCcontrol_wait(j);
1816 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1817
1818 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1819
1820 if (j->flags.pcmciasct == 3) {
1821 j->flags.pcmciastate = 4;
1822 return 0;
1823 } else if (j->flags.pcmciasct == 0) {
1824 j->pccr2.bits.pwr = 1;
1825 j->pccr2.bits.rstc = 0;
1826 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1827 j->port = PORT_SPEAKER;
1828 } else {
1829 j->port = PORT_POTS;
1830 }
1831 j->sic1.bits.cpd = 0; /* Chip Power Down */
1832 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1833 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1834 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1835 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1836 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1837 j->psccr.bits.rw = 0; /* Read / Write flag */
1838 j->psccr.bits.dev = 0;
1839 outb(j->sic1.byte, j->XILINXbase + 0x00);
1840 outb(j->psccr.byte, j->XILINXbase + 0x01);
1841 ixj_PCcontrol_wait(j);
1842
1843 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1844 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1845 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1846 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1847 j->sic2.bits.hpd = 0; /* HPF disable */
1848 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1849 j->psccr.bits.rw = 0; /* Read / Write flag */
1850 j->psccr.bits.dev = 0;
1851 outb(j->sic2.byte, j->XILINXbase + 0x00);
1852 outb(j->psccr.byte, j->XILINXbase + 0x01);
1853 ixj_PCcontrol_wait(j);
1854
1855 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1856 j->psccr.bits.rw = 0; /* Read / Write flag */
1857 j->psccr.bits.dev = 0;
1858 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1859 outb(j->psccr.byte, j->XILINXbase + 0x01);
1860 ixj_PCcontrol_wait(j);
1861
1862 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1863 j->psccr.bits.rw = 0; /* Read / Write flag */
1864 j->psccr.bits.dev = 0;
1865 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1866 outb(j->psccr.byte, j->XILINXbase + 0x01);
1867 ixj_PCcontrol_wait(j);
1868
1869 j->sirxg.bits.lig = 1; /* Line In Gain */
1870 j->sirxg.bits.lim = 1; /* Line In Mute */
1871 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1872 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1873 j->sirxg.bits.him = 0; /* Handset In Mute */
1874 j->sirxg.bits.iir = 1; /* IIR */
1875 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1876 j->psccr.bits.rw = 0; /* Read / Write flag */
1877 j->psccr.bits.dev = 0;
1878 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1879 outb(j->psccr.byte, j->XILINXbase + 0x01);
1880 ixj_PCcontrol_wait(j);
1881
1882 ixj_siadc(j, 0x17);
1883 ixj_sidac(j, 0x1D);
1884
1885 j->siaatt.bits.sot = 0;
1886 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1887 j->psccr.bits.rw = 0; /* Read / Write flag */
1888 j->psccr.bits.dev = 0;
1889 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1890 outb(j->psccr.byte, j->XILINXbase + 0x01);
1891 ixj_PCcontrol_wait(j);
1892
1893 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1894 j->psccr.byte = j->pslic.byte = 0;
1895 j->pslic.bits.powerdown = 1;
1896 j->psccr.bits.dev = 3;
1897 j->psccr.bits.rw = 0;
1898 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1899 ixj_PCcontrol_wait(j);
1900 }
1901 }
1902 return 0;
1903 } else {
1904 j->flags.pcmciascp = 0;
1905 return 0;
1906 }
1907 return 0;
1908}
1909
1910static int ixj_hookstate(IXJ *j)
1911{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]1912 int fOffHook = 0;
1913
1914 switch (j->cardtype) {
1915 case QTI_PHONEJACK:
1916 ixj_gpio_read(j);
1917 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1918 break;
1919 case QTI_LINEJACK:
1920 case QTI_PHONEJACK_LITE:
1921 case QTI_PHONEJACK_PCI:
1922 SLIC_GetState(j);
1923 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1924 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1925 if(fOffHook != j->p_hook) {
1926 if(!j->checkwait) {
1927 j->checkwait = jiffies;
1928 }
1929 if(time_before(jiffies, j->checkwait + 2)) {
1930 fOffHook ^= 1;
1931 } else {
1932 j->checkwait = 0;
1933 }
1934 j->p_hook = fOffHook;
1935 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1936 }
1937 } else {
1938 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1939 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1940 if (j->flags.ringing || j->flags.cringing) {
1941 if (!in_interrupt()) {
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]1942 msleep(20);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]1943 }
1944 SLIC_GetState(j);
1945 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1946 ixj_ring_on(j);
1947 }
1948 }
1949 if (j->cardtype == QTI_PHONEJACK_PCI) {
1950 j->pld_scrr.byte = inb_p(j->XILINXbase);
1951 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1952 } else
1953 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1954 }
1955 }
1956 break;
1957 case QTI_PHONECARD:
1958 fOffHook = ixj_pcmcia_cable_check(j);
1959 break;
1960 }
1961 if (j->r_hook != fOffHook) {
1962 j->r_hook = fOffHook;
1963 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1964 j->ex.bits.hookstate = 1;
1965 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1966 } else if (!fOffHook) {
1967 j->flash_end = jiffies + ((60 * hertz) / 100);
1968 }
1969 }
1970 if (fOffHook) {
1971 if(time_before(jiffies, j->flash_end)) {
1972 j->ex.bits.flash = 1;
1973 j->flash_end = 0;
1974 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1975 }
1976 } else {
1977 if(time_before(jiffies, j->flash_end)) {
1978 fOffHook = 1;
1979 }
1980 }
1981
1982 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1983 fOffHook |= 2;
1984
1985 if (j->port == PORT_SPEAKER) {
1986 if(j->cardtype == QTI_PHONECARD) {
1987 if(j->flags.pcmciascp && j->flags.pcmciasct) {
1988 fOffHook |= 2;
1989 }
1990 } else {
1991 fOffHook |= 2;
1992 }
1993 }
1994
1995 if (j->port == PORT_HANDSET)
1996 fOffHook |= 2;
1997
1998 return fOffHook;
1999}
2000
2001static void ixj_ring_off(IXJ *j)
2002{
2003 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2004 {
2005 if (ixjdebug & 0x0004)
2006 printk(KERN_INFO "IXJ Ring Off\n");
2007 j->gpio.bytes.high = 0x0B;
2008 j->gpio.bytes.low = 0x00;
2009 j->gpio.bits.gpio1 = 0;
2010 j->gpio.bits.gpio2 = 1;
2011 j->gpio.bits.gpio5 = 0;
2012 ixj_WriteDSPCommand(j->gpio.word, j);
2013 } else /* Internet LineJACK */
2014 {
2015 if (ixjdebug & 0x0004)
2016 printk(KERN_INFO "IXJ Ring Off\n");
2017
2018 if(!j->flags.cidplay)
2019 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2020
2021 SLIC_GetState(j);
2022 }
2023}
2024
2025static void ixj_ring_start(IXJ *j)
2026{
2027 j->flags.cringing = 1;
2028 if (ixjdebug & 0x0004)
2029 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2030 if (ixj_hookstate(j) & 1) {
2031 if (j->port == PORT_POTS)
2032 ixj_ring_off(j);
2033 j->flags.cringing = 0;
2034 if (ixjdebug & 0x0004)
2035 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2036 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2037 j->ring_cadence_jif = jiffies;
2038 j->flags.cidsent = j->flags.cidring = 0;
2039 j->cadence_f[5].state = 0;
2040 if(j->cadence_f[5].on1)
2041 ixj_ring_on(j);
2042 } else {
2043 j->ring_cadence_jif = jiffies;
2044 j->ring_cadence_t = 15;
2045 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2046 ixj_ring_on(j);
2047 } else {
2048 ixj_ring_off(j);
2049 }
2050 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2051 }
2052}
2053
2054static int ixj_ring(IXJ *j)
2055{
2056 char cntr;
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]2057 unsigned long jif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2058
2059 j->flags.ringing = 1;
2060 if (ixj_hookstate(j) & 1) {
2061 ixj_ring_off(j);
2062 j->flags.ringing = 0;
2063 return 1;
2064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2065 for (cntr = 0; cntr < j->maxrings; cntr++) {
2066 jif = jiffies + (1 * hertz);
2067 ixj_ring_on(j);
2068 while (time_before(jiffies, jif)) {
2069 if (ixj_hookstate(j) & 1) {
2070 ixj_ring_off(j);
2071 j->flags.ringing = 0;
2072 return 1;
2073 }
2074 set_current_state(TASK_INTERRUPTIBLE);
2075 schedule_timeout(1);
2076 if (signal_pending(current))
2077 break;
2078 }
2079 jif = jiffies + (3 * hertz);
2080 ixj_ring_off(j);
2081 while (time_before(jiffies, jif)) {
2082 if (ixj_hookstate(j) & 1) {
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]2083 msleep(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2084 if (ixj_hookstate(j) & 1) {
2085 j->flags.ringing = 0;
2086 return 1;
2087 }
2088 }
2089 set_current_state(TASK_INTERRUPTIBLE);
2090 schedule_timeout(1);
2091 if (signal_pending(current))
2092 break;
2093 }
2094 }
2095 ixj_ring_off(j);
2096 j->flags.ringing = 0;
2097 return 0;
2098}
2099
2100static int ixj_open(struct phone_device *p, struct file *file_p)
2101{
2102 IXJ *j = get_ixj(p->board);
2103 file_p->private_data = j;
2104
2105 if (!j->DSPbase)
2106 return -ENODEV;
2107
2108 if (file_p->f_mode & FMODE_READ) {
2109 if(!j->readers) {
2110 j->readers++;
2111 } else {
2112 return -EBUSY;
2113 }
2114 }
2115
2116 if (file_p->f_mode & FMODE_WRITE) {
2117 if(!j->writers) {
2118 j->writers++;
2119 } else {
2120 if (file_p->f_mode & FMODE_READ){
2121 j->readers--;
2122 }
2123 return -EBUSY;
2124 }
2125 }
2126
2127 if (j->cardtype == QTI_PHONECARD) {
2128 j->pslic.bits.powerdown = 0;
2129 j->psccr.bits.dev = 3;
2130 j->psccr.bits.rw = 0;
2131 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2132 ixj_PCcontrol_wait(j);
2133 }
2134
2135 j->flags.cidplay = 0;
2136 j->flags.cidcw_ack = 0;
2137
2138 if (ixjdebug & 0x0002)
2139 printk(KERN_INFO "Opening board %d\n", p->board);
2140
2141 j->framesread = j->frameswritten = 0;
2142 return 0;
2143}
2144
2145static int ixj_release(struct inode *inode, struct file *file_p)
2146{
2147 IXJ_TONE ti;
2148 int cnt;
2149 IXJ *j = file_p->private_data;
2150 int board = j->p.board;
2151
2152 /*
2153 * Set up locks to ensure that only one process is talking to the DSP at a time.
2154 * This is necessary to keep the DSP from locking up.
2155 */
2156 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
2157 set_current_state(TASK_INTERRUPTIBLE);
2158 schedule_timeout(1);
2159 }
2160 if (ixjdebug & 0x0002)
2161 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2162
2163 if (j->cardtype == QTI_PHONECARD)
2164 ixj_set_port(j, PORT_SPEAKER);
2165 else
2166 ixj_set_port(j, PORT_POTS);
2167
2168 aec_stop(j);
2169 ixj_play_stop(j);
2170 ixj_record_stop(j);
2171 set_play_volume(j, 0x100);
2172 set_rec_volume(j, 0x100);
2173 ixj_ring_off(j);
2174
2175 /* Restore the tone table to default settings. */
2176 ti.tone_index = 10;
2177 ti.gain0 = 1;
2178 ti.freq0 = hz941;
2179 ti.gain1 = 0;
2180 ti.freq1 = hz1209;
2181 ixj_init_tone(j, &ti);
2182 ti.tone_index = 11;
2183 ti.gain0 = 1;
2184 ti.freq0 = hz941;
2185 ti.gain1 = 0;
2186 ti.freq1 = hz1336;
2187 ixj_init_tone(j, &ti);
2188 ti.tone_index = 12;
2189 ti.gain0 = 1;
2190 ti.freq0 = hz941;
2191 ti.gain1 = 0;
2192 ti.freq1 = hz1477;
2193 ixj_init_tone(j, &ti);
2194 ti.tone_index = 13;
2195 ti.gain0 = 1;
2196 ti.freq0 = hz800;
2197 ti.gain1 = 0;
2198 ti.freq1 = 0;
2199 ixj_init_tone(j, &ti);
2200 ti.tone_index = 14;
2201 ti.gain0 = 1;
2202 ti.freq0 = hz1000;
2203 ti.gain1 = 0;
2204 ti.freq1 = 0;
2205 ixj_init_tone(j, &ti);
2206 ti.tone_index = 15;
2207 ti.gain0 = 1;
2208 ti.freq0 = hz1250;
2209 ti.gain1 = 0;
2210 ti.freq1 = 0;
2211 ixj_init_tone(j, &ti);
2212 ti.tone_index = 16;
2213 ti.gain0 = 1;
2214 ti.freq0 = hz950;
2215 ti.gain1 = 0;
2216 ti.freq1 = 0;
2217 ixj_init_tone(j, &ti);
2218 ti.tone_index = 17;
2219 ti.gain0 = 1;
2220 ti.freq0 = hz1100;
2221 ti.gain1 = 0;
2222 ti.freq1 = 0;
2223 ixj_init_tone(j, &ti);
2224 ti.tone_index = 18;
2225 ti.gain0 = 1;
2226 ti.freq0 = hz1400;
2227 ti.gain1 = 0;
2228 ti.freq1 = 0;
2229 ixj_init_tone(j, &ti);
2230 ti.tone_index = 19;
2231 ti.gain0 = 1;
2232 ti.freq0 = hz1500;
2233 ti.gain1 = 0;
2234 ti.freq1 = 0;
2235 ixj_init_tone(j, &ti);
2236 ti.tone_index = 20;
2237 ti.gain0 = 1;
2238 ti.freq0 = hz1600;
2239 ti.gain1 = 0;
2240 ti.freq1 = 0;
2241 ixj_init_tone(j, &ti);
2242 ti.tone_index = 21;
2243 ti.gain0 = 1;
2244 ti.freq0 = hz1800;
2245 ti.gain1 = 0;
2246 ti.freq1 = 0;
2247 ixj_init_tone(j, &ti);
2248 ti.tone_index = 22;
2249 ti.gain0 = 1;
2250 ti.freq0 = hz2100;
2251 ti.gain1 = 0;
2252 ti.freq1 = 0;
2253 ixj_init_tone(j, &ti);
2254 ti.tone_index = 23;
2255 ti.gain0 = 1;
2256 ti.freq0 = hz1300;
2257 ti.gain1 = 0;
2258 ti.freq1 = 0;
2259 ixj_init_tone(j, &ti);
2260 ti.tone_index = 24;
2261 ti.gain0 = 1;
2262 ti.freq0 = hz2450;
2263 ti.gain1 = 0;
2264 ti.freq1 = 0;
2265 ixj_init_tone(j, &ti);
2266 ti.tone_index = 25;
2267 ti.gain0 = 1;
2268 ti.freq0 = hz350;
2269 ti.gain1 = 0;
2270 ti.freq1 = hz440;
2271 ixj_init_tone(j, &ti);
2272 ti.tone_index = 26;
2273 ti.gain0 = 1;
2274 ti.freq0 = hz440;
2275 ti.gain1 = 0;
2276 ti.freq1 = hz480;
2277 ixj_init_tone(j, &ti);
2278 ti.tone_index = 27;
2279 ti.gain0 = 1;
2280 ti.freq0 = hz480;
2281 ti.gain1 = 0;
2282 ti.freq1 = hz620;
2283 ixj_init_tone(j, &ti);
2284
2285 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2286
2287 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2288
2289 j->ex.bits.dtmf_ready = 0;
2290 j->dtmf_state = 0;
2291 j->dtmf_wp = j->dtmf_rp = 0;
2292 j->rec_mode = j->play_mode = -1;
2293 j->flags.ringing = 0;
2294 j->maxrings = MAXRINGS;
2295 j->ring_cadence = USA_RING_CADENCE;
2296 if(j->cadence_f[5].enable) {
2297 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2298 }
2299 j->drybuffer = 0;
2300 j->winktime = 320;
2301 j->flags.dtmf_oob = 0;
2302 for (cnt = 0; cnt < 4; cnt++)
2303 j->cadence_f[cnt].enable = 0;
2304
2305 idle(j);
2306
2307 if(j->cardtype == QTI_PHONECARD) {
2308 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2309 }
2310
2311 if (file_p->f_mode & FMODE_READ)
2312 j->readers--;
2313 if (file_p->f_mode & FMODE_WRITE)
2314 j->writers--;
2315
2316 if (j->read_buffer && !j->readers) {
2317 kfree(j->read_buffer);
2318 j->read_buffer = NULL;
2319 j->read_buffer_size = 0;
2320 }
2321 if (j->write_buffer && !j->writers) {
2322 kfree(j->write_buffer);
2323 j->write_buffer = NULL;
2324 j->write_buffer_size = 0;
2325 }
2326 j->rec_codec = j->play_codec = 0;
2327 j->rec_frame_size = j->play_frame_size = 0;
2328 j->flags.cidsent = j->flags.cidring = 0;
2329 ixj_fasync(-1, file_p, 0); /* remove from list of async notification */
2330
2331 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2332 ixj_set_port(j, PORT_PSTN);
2333 daa_set_mode(j, SOP_PU_SLEEP);
2334 ixj_set_pots(j, 1);
2335 }
2336 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2337
2338 /* Set up the default signals for events */
2339 for (cnt = 0; cnt < 35; cnt++)
2340 j->ixj_signals[cnt] = SIGIO;
2341
2342 /* Set the excetion signal enable flags */
2343 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2344 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 =
2345 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;
2346
2347 file_p->private_data = NULL;
2348 clear_bit(board, &j->busyflags);
2349 return 0;
2350}
2351
2352static int read_filters(IXJ *j)
2353{
2354 unsigned short fc, cnt, trg;
2355 int var;
2356
2357 trg = 0;
2358 if (ixj_WriteDSPCommand(0x5144, j)) {
2359 if(ixjdebug & 0x0001) {
2360 printk(KERN_INFO "Read Frame Counter failed!\n");
2361 }
2362 return -1;
2363 }
2364 fc = j->ssr.high << 8 | j->ssr.low;
2365 if (fc == j->frame_count)
2366 return 1;
2367
2368 j->frame_count = fc;
2369
2370 if (j->dtmf_proc)
2371 return 1;
2372
2373 var = 10;
2374
2375 for (cnt = 0; cnt < 4; cnt++) {
2376 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2377 if(ixjdebug & 0x0001) {
2378 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2379 }
2380 return -1;
2381 }
2382 if (ixj_WriteDSPCommand(0x515C, j)) {
2383 if(ixjdebug & 0x0001) {
2384 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2385 }
2386 return -1;
2387 }
2388 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2389
2390 if (j->cadence_f[cnt].enable) {
2391 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2392 if (j->cadence_f[cnt].state == 0) {
2393 j->cadence_f[cnt].state = 1;
2394 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2395 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2396 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2397 } else if (j->cadence_f[cnt].state == 2 &&
2398 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2399 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2400 if (j->cadence_f[cnt].on2) {
2401 j->cadence_f[cnt].state = 3;
2402 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2403 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2404 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2405 } else {
2406 j->cadence_f[cnt].state = 7;
2407 }
2408 } else if (j->cadence_f[cnt].state == 4 &&
2409 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2410 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2411 if (j->cadence_f[cnt].on3) {
2412 j->cadence_f[cnt].state = 5;
2413 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2414 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2415 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2416 } else {
2417 j->cadence_f[cnt].state = 7;
2418 }
2419 } else {
2420 j->cadence_f[cnt].state = 0;
2421 }
2422 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2423 if (j->cadence_f[cnt].state == 1) {
2424 if(!j->cadence_f[cnt].on1) {
2425 j->cadence_f[cnt].state = 7;
2426 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2427 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2428 if(j->cadence_f[cnt].off1) {
2429 j->cadence_f[cnt].state = 2;
2430 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2431 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2432 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2433 } else {
2434 j->cadence_f[cnt].state = 7;
2435 }
2436 } else {
2437 j->cadence_f[cnt].state = 0;
2438 }
2439 } else if (j->cadence_f[cnt].state == 3) {
2440 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2441 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2442 if(j->cadence_f[cnt].off2) {
2443 j->cadence_f[cnt].state = 4;
2444 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2445 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2446 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2447 } else {
2448 j->cadence_f[cnt].state = 7;
2449 }
2450 } else {
2451 j->cadence_f[cnt].state = 0;
2452 }
2453 } else if (j->cadence_f[cnt].state == 5) {
2454 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2455 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2456 if(j->cadence_f[cnt].off3) {
2457 j->cadence_f[cnt].state = 6;
2458 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2459 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2460 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2461 } else {
2462 j->cadence_f[cnt].state = 7;
2463 }
2464 } else {
2465 j->cadence_f[cnt].state = 0;
2466 }
2467 } else {
2468 j->cadence_f[cnt].state = 0;
2469 }
2470 } else {
2471 switch(j->cadence_f[cnt].state) {
2472 case 1:
2473 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2474 !j->cadence_f[cnt].off1 &&
2475 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2476 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2477 j->cadence_f[cnt].state = 7;
2478 }
2479 break;
2480 case 3:
2481 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2482 !j->cadence_f[cnt].off2 &&
2483 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2484 j->cadence_f[cnt].state = 7;
2485 }
2486 break;
2487 case 5:
2488 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2489 !j->cadence_f[cnt].off3) {
2490 j->cadence_f[cnt].state = 7;
2491 }
2492 break;
2493 }
2494 }
2495
2496 if (ixjdebug & 0x0040) {
2497 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2498 switch(j->cadence_f[cnt].state) {
2499 case 0:
2500 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2501 break;
2502 case 1:
2503 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2504 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2505 break;
2506 case 2:
2507 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2508 j->cadence_f[cnt].off1max);
2509 break;
2510 case 3:
2511 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2512 j->cadence_f[cnt].on2max);
2513 break;
2514 case 4:
2515 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2516 j->cadence_f[cnt].off2max);
2517 break;
2518 case 5:
2519 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2520 j->cadence_f[cnt].on3max);
2521 break;
2522 case 6:
2523 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2524 j->cadence_f[cnt].off3max);
2525 break;
2526 }
2527 }
2528 }
2529 if (j->cadence_f[cnt].state == 7) {
2530 j->cadence_f[cnt].state = 0;
2531 if (j->cadence_f[cnt].enable == 1)
2532 j->cadence_f[cnt].enable = 0;
2533 switch (cnt) {
2534 case 0:
2535 if(ixjdebug & 0x0020) {
2536 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2537 }
2538 j->ex.bits.fc0 = 1;
2539 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2540 break;
2541 case 1:
2542 if(ixjdebug & 0x0020) {
2543 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2544 }
2545 j->ex.bits.fc1 = 1;
2546 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2547 break;
2548 case 2:
2549 if(ixjdebug & 0x0020) {
2550 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2551 }
2552 j->ex.bits.fc2 = 1;
2553 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2554 break;
2555 case 3:
2556 if(ixjdebug & 0x0020) {
2557 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2558 }
2559 j->ex.bits.fc3 = 1;
2560 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2561 break;
2562 }
2563 }
2564 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2565 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2566 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2567 trg = 1;
2568 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2569 trg = 0;
2570 }
2571 switch (cnt) {
2572 case 0:
2573 if(ixjdebug & 0x0020) {
2574 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2575 }
2576 j->ex.bits.f0 = 1;
2577 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2578 break;
2579 case 1:
2580 if(ixjdebug & 0x0020) {
2581 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2582 }
2583 j->ex.bits.f1 = 1;
2584 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2585 break;
2586 case 2:
2587 if(ixjdebug & 0x0020) {
2588 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2589 }
2590 j->ex.bits.f2 = 1;
2591 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2592 break;
2593 case 3:
2594 if(ixjdebug & 0x0020) {
2595 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2596 }
2597 j->ex.bits.f3 = 1;
2598 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2599 break;
2600 }
2601 }
2602 }
2603 return 0;
2604}
2605
2606static int LineMonitor(IXJ *j)
2607{
2608 if (j->dtmf_proc) {
2609 return -1;
2610 }
2611 j->dtmf_proc = 1;
2612
2613 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2614 return -1;
2615
2616 j->dtmf.bytes.high = j->ssr.high;
2617 j->dtmf.bytes.low = j->ssr.low;
2618 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2619 j->dtmf_state = 1;
2620 j->dtmf_current = j->dtmf.bits.digit;
2621 }
2622 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2623 {
2624 if(!j->cidcw_wait) {
2625 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2626 j->dtmf_wp++;
2627 if (j->dtmf_wp == 79)
2628 j->dtmf_wp = 0;
2629 j->ex.bits.dtmf_ready = 1;
2630 if(j->ex_sig.bits.dtmf_ready) {
2631 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2632 }
2633 }
2634 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2635 if(ixjdebug & 0x0020) {
2636 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2637 }
2638 j->flags.cidcw_ack = 1;
2639 }
2640 j->dtmf_state = 0;
2641 }
2642 j->dtmf_proc = 0;
2643
2644 return 0;
2645}
2646
2647/************************************************************************
2648*
2649* Functions to allow alaw <-> ulaw conversions.
2650*
2651************************************************************************/
2652
2653static void ulaw2alaw(unsigned char *buff, unsigned long len)
2654{
2655 static unsigned char table_ulaw2alaw[] =
2656 {
2657 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2658 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2659 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2660 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2661 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2662 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2663 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2664 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2665 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2666 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2667 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2668 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2669 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2670 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2671 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2672 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2673 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2674 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2675 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2676 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2677 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2678 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2679 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2680 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2681 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2682 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2683 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2684 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2685 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2686 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2687 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2688 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2689 };
2690
2691 while (len--)
2692 {
2693 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2694 buff++;
2695 }
2696}
2697
2698static void alaw2ulaw(unsigned char *buff, unsigned long len)
2699{
2700 static unsigned char table_alaw2ulaw[] =
2701 {
2702 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2703 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2704 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2705 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2706 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2707 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2708 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2709 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2710 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2711 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2712 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2713 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2714 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2715 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2716 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2717 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2718 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2719 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2720 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2721 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2722 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2723 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2724 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2725 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2726 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2727 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2728 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2729 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2730 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2731 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2732 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2733 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2734 };
2735
2736 while (len--)
2737 {
2738 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2739 buff++;
2740 }
2741}
2742
2743static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2744{
2745 unsigned long i = *ppos;
2746 IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2747
2748 DECLARE_WAITQUEUE(wait, current);
2749
2750 if (j->flags.inread)
2751 return -EALREADY;
2752
2753 j->flags.inread = 1;
2754
2755 add_wait_queue(&j->read_q, &wait);
2756 set_current_state(TASK_INTERRUPTIBLE);
2757 mb();
2758
2759 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2760 ++j->read_wait;
2761 if (file_p->f_flags & O_NONBLOCK) {
2762 set_current_state(TASK_RUNNING);
2763 remove_wait_queue(&j->read_q, &wait);
2764 j->flags.inread = 0;
2765 return -EAGAIN;
2766 }
2767 if (!ixj_hookstate(j)) {
2768 set_current_state(TASK_RUNNING);
2769 remove_wait_queue(&j->read_q, &wait);
2770 j->flags.inread = 0;
2771 return 0;
2772 }
2773 interruptible_sleep_on(&j->read_q);
2774 if (signal_pending(current)) {
2775 set_current_state(TASK_RUNNING);
2776 remove_wait_queue(&j->read_q, &wait);
2777 j->flags.inread = 0;
2778 return -EINTR;
2779 }
2780 }
2781
2782 remove_wait_queue(&j->read_q, &wait);
2783 set_current_state(TASK_RUNNING);
2784 /* Don't ever copy more than the user asks */
2785 if(j->rec_codec == ALAW)
2786 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2787 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2788 j->read_buffer_ready = 0;
2789 if (i) {
2790 j->flags.inread = 0;
2791 return -EFAULT;
2792 } else {
2793 j->flags.inread = 0;
2794 return min(length, j->read_buffer_size);
2795 }
2796}
2797
2798static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2799 loff_t * ppos)
2800{
2801 int pre_retval;
2802 ssize_t read_retval = 0;
2803 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2804
2805 pre_retval = ixj_PreRead(j, 0L);
2806 switch (pre_retval) {
2807 case NORMAL:
2808 read_retval = ixj_read(file_p, buf, length, ppos);
2809 ixj_PostRead(j, 0L);
2810 break;
2811 case NOPOST:
2812 read_retval = ixj_read(file_p, buf, length, ppos);
2813 break;
2814 case POSTONLY:
2815 ixj_PostRead(j, 0L);
2816 break;
2817 default:
2818 read_retval = pre_retval;
2819 }
2820 return read_retval;
2821}
2822
2823static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2824{
2825 unsigned long i = *ppos;
2826 IXJ *j = file_p->private_data;
2827
2828 DECLARE_WAITQUEUE(wait, current);
2829
2830 if (j->flags.inwrite)
2831 return -EALREADY;
2832
2833 j->flags.inwrite = 1;
2834
2835 add_wait_queue(&j->write_q, &wait);
2836 set_current_state(TASK_INTERRUPTIBLE);
2837 mb();
2838
2839
2840 while (!j->write_buffers_empty) {
2841 ++j->write_wait;
2842 if (file_p->f_flags & O_NONBLOCK) {
2843 set_current_state(TASK_RUNNING);
2844 remove_wait_queue(&j->write_q, &wait);
2845 j->flags.inwrite = 0;
2846 return -EAGAIN;
2847 }
2848 if (!ixj_hookstate(j)) {
2849 set_current_state(TASK_RUNNING);
2850 remove_wait_queue(&j->write_q, &wait);
2851 j->flags.inwrite = 0;
2852 return 0;
2853 }
2854 interruptible_sleep_on(&j->write_q);
2855 if (signal_pending(current)) {
2856 set_current_state(TASK_RUNNING);
2857 remove_wait_queue(&j->write_q, &wait);
2858 j->flags.inwrite = 0;
2859 return -EINTR;
2860 }
2861 }
2862 set_current_state(TASK_RUNNING);
2863 remove_wait_queue(&j->write_q, &wait);
2864 if (j->write_buffer_wp + count >= j->write_buffer_end)
2865 j->write_buffer_wp = j->write_buffer;
2866 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2867 if (i) {
2868 j->flags.inwrite = 0;
2869 return -EFAULT;
2870 }
2871 if(j->play_codec == ALAW)
2872 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2873 j->flags.inwrite = 0;
2874 return min(count, j->write_buffer_size);
2875}
2876
2877static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2878{
2879 int pre_retval;
2880 ssize_t write_retval = 0;
2881
2882 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2883
2884 pre_retval = ixj_PreWrite(j, 0L);
2885 switch (pre_retval) {
2886 case NORMAL:
2887 write_retval = ixj_write(file_p, buf, count, ppos);
2888 if (write_retval > 0) {
2889 ixj_PostWrite(j, 0L);
2890 j->write_buffer_wp += write_retval;
2891 j->write_buffers_empty--;
2892 }
2893 break;
2894 case NOPOST:
2895 write_retval = ixj_write(file_p, buf, count, ppos);
2896 if (write_retval > 0) {
2897 j->write_buffer_wp += write_retval;
2898 j->write_buffers_empty--;
2899 }
2900 break;
2901 case POSTONLY:
2902 ixj_PostWrite(j, 0L);
2903 break;
2904 default:
2905 write_retval = pre_retval;
2906 }
2907 return write_retval;
2908}
2909
2910static void ixj_read_frame(IXJ *j)
2911{
2912 int cnt, dly;
2913
2914 if (j->read_buffer) {
2915 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2916 if (!(cnt % 16) && !IsRxReady(j)) {
2917 dly = 0;
2918 while (!IsRxReady(j)) {
2919 if (dly++ > 5) {
2920 dly = 0;
2921 break;
2922 }
2923 udelay(10);
2924 }
2925 }
2926 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2927 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2928 inb_p(j->DSPbase + 0x0E);
2929 inb_p(j->DSPbase + 0x0F);
2930 }
2931 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2932 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2933 }
2934 ++j->framesread;
2935 if (j->intercom != -1) {
2936 if (IsTxReady(get_ixj(j->intercom))) {
2937 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2938 if (!(cnt % 16) && !IsTxReady(j)) {
2939 dly = 0;
2940 while (!IsTxReady(j)) {
2941 if (dly++ > 5) {
2942 dly = 0;
2943 break;
2944 }
2945 udelay(10);
2946 }
2947 }
2948 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2949 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2950 }
2951 get_ixj(j->intercom)->frameswritten++;
2952 }
2953 } else {
2954 j->read_buffer_ready = 1;
2955 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2956
2957 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2958
2959 if(j->ixj_signals[SIG_READ_READY])
2960 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2961 }
2962 }
2963}
2964
2965static short fsk[][6][20] =
2966{
2967 {
2968 {
2969 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2970 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2971 },
2972 {
2973 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2974 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2975 },
2976 {
2977 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2978 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2979 },
2980 {
2981 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2982 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2983 },
2984 {
2985 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2986 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2987 },
2988 {
2989 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2990 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2991 }
2992 },
2993 {
2994 {
2995 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2996 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2997 },
2998 {
2999 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3000 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3001 },
3002 {
3003 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3004 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3005 },
3006 {
3007 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3008 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3009 },
3010 {
3011 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3012 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3013 },
3014 {
3015 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3016 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3017 }
3018 }
3019};
3020
3021
3022static void ixj_write_cid_bit(IXJ *j, int bit)
3023{
3024 while (j->fskcnt < 20) {
3025 if(j->fskdcnt < (j->fsksize - 1))
3026 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3027
3028 j->fskcnt += 3;
3029 }
3030 j->fskcnt %= 20;
3031
3032 if (!bit)
3033 j->fskz++;
3034 if (j->fskz >= 6)
3035 j->fskz = 0;
3036
3037}
3038
3039static void ixj_write_cid_byte(IXJ *j, char byte)
3040{
3041 IXJ_CBYTE cb;
3042
3043 cb.cbyte = byte;
3044 ixj_write_cid_bit(j, 0);
3045 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3046 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3047 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3048 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3049 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3050 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3051 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3052 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3053 ixj_write_cid_bit(j, 1);
3054}
3055
3056static void ixj_write_cid_seize(IXJ *j)
3057{
3058 int cnt;
3059
3060 for (cnt = 0; cnt < 150; cnt++) {
3061 ixj_write_cid_bit(j, 0);
3062 ixj_write_cid_bit(j, 1);
3063 }
3064 for (cnt = 0; cnt < 180; cnt++) {
3065 ixj_write_cid_bit(j, 1);
3066 }
3067}
3068
3069static void ixj_write_cidcw_seize(IXJ *j)
3070{
3071 int cnt;
3072
3073 for (cnt = 0; cnt < 80; cnt++) {
3074 ixj_write_cid_bit(j, 1);
3075 }
3076}
3077
3078static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3079{
3080 int cnt;
3081
3082 for (cnt = 0; cnt < strlen(s); cnt++) {
3083 ixj_write_cid_byte(j, s[cnt]);
3084 checksum = (checksum + s[cnt]);
3085 }
3086 return checksum;
3087}
3088
3089static void ixj_pad_fsk(IXJ *j, int pad)
3090{
3091 int cnt;
3092
3093 for (cnt = 0; cnt < pad; cnt++) {
3094 if(j->fskdcnt < (j->fsksize - 1))
3095 j->fskdata[j->fskdcnt++] = 0x0000;
3096 }
3097 for (cnt = 0; cnt < 720; cnt++) {
3098 if(j->fskdcnt < (j->fsksize - 1))
3099 j->fskdata[j->fskdcnt++] = 0x0000;
3100 }
3101}
3102
3103static void ixj_pre_cid(IXJ *j)
3104{
3105 j->cid_play_codec = j->play_codec;
3106 j->cid_play_frame_size = j->play_frame_size;
3107 j->cid_play_volume = get_play_volume(j);
3108 j->cid_play_flag = j->flags.playing;
3109
3110 j->cid_rec_codec = j->rec_codec;
3111 j->cid_rec_volume = get_rec_volume(j);
3112 j->cid_rec_flag = j->flags.recording;
3113
3114 j->cid_play_aec_level = j->aec_level;
3115
3116 switch(j->baseframe.low) {
3117 case 0xA0:
3118 j->cid_base_frame_size = 20;
3119 break;
3120 case 0x50:
3121 j->cid_base_frame_size = 10;
3122 break;
3123 case 0xF0:
3124 j->cid_base_frame_size = 30;
3125 break;
3126 }
3127
3128 ixj_play_stop(j);
3129 ixj_cpt_stop(j);
3130
3131 j->flags.cidplay = 1;
3132
3133 set_base_frame(j, 30);
3134 set_play_codec(j, LINEAR16);
3135 set_play_volume(j, 0x1B);
3136 ixj_play_start(j);
3137}
3138
3139static void ixj_post_cid(IXJ *j)
3140{
3141 ixj_play_stop(j);
3142
3143 if(j->cidsize > 5000) {
3144 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3145 }
3146 j->flags.cidplay = 0;
3147 if(ixjdebug & 0x0200) {
3148 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3149 }
3150
3151 ixj_fsk_free(j);
3152
3153 j->fskdcnt = 0;
3154 set_base_frame(j, j->cid_base_frame_size);
3155 set_play_codec(j, j->cid_play_codec);
3156 ixj_aec_start(j, j->cid_play_aec_level);
3157 set_play_volume(j, j->cid_play_volume);
3158
3159 set_rec_codec(j, j->cid_rec_codec);
3160 set_rec_volume(j, j->cid_rec_volume);
3161
3162 if(j->cid_rec_flag)
3163 ixj_record_start(j);
3164
3165 if(j->cid_play_flag)
3166 ixj_play_start(j);
3167
3168 if(j->cid_play_flag) {
3169 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3170 }
3171}
3172
3173static void ixj_write_cid(IXJ *j)
3174{
3175 char sdmf1[50];
3176 char sdmf2[50];
3177 char sdmf3[80];
3178 char mdmflen, len1, len2, len3;
3179 int pad;
3180
3181 int checksum = 0;
3182
3183 if (j->dsp.low == 0x20 || j->flags.cidplay)
3184 return;
3185
3186 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3187 j->cidsize = j->cidcnt = 0;
3188
3189 ixj_fsk_alloc(j);
3190
3191 strcpy(sdmf1, j->cid_send.month);
3192 strcat(sdmf1, j->cid_send.day);
3193 strcat(sdmf1, j->cid_send.hour);
3194 strcat(sdmf1, j->cid_send.min);
3195 strcpy(sdmf2, j->cid_send.number);
3196 strcpy(sdmf3, j->cid_send.name);
3197
3198 len1 = strlen(sdmf1);
3199 len2 = strlen(sdmf2);
3200 len3 = strlen(sdmf3);
3201 mdmflen = len1 + len2 + len3 + 6;
3202
3203 while(1){
3204 ixj_write_cid_seize(j);
3205
3206 ixj_write_cid_byte(j, 0x80);
3207 checksum = 0x80;
3208 ixj_write_cid_byte(j, mdmflen);
3209 checksum = checksum + mdmflen;
3210
3211 ixj_write_cid_byte(j, 0x01);
3212 checksum = checksum + 0x01;
3213 ixj_write_cid_byte(j, len1);
3214 checksum = checksum + len1;
3215 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3216 if(ixj_hookstate(j) & 1)
3217 break;
3218
3219 ixj_write_cid_byte(j, 0x02);
3220 checksum = checksum + 0x02;
3221 ixj_write_cid_byte(j, len2);
3222 checksum = checksum + len2;
3223 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3224 if(ixj_hookstate(j) & 1)
3225 break;
3226
3227 ixj_write_cid_byte(j, 0x07);
3228 checksum = checksum + 0x07;
3229 ixj_write_cid_byte(j, len3);
3230 checksum = checksum + len3;
3231 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3232 if(ixj_hookstate(j) & 1)
3233 break;
3234
3235 checksum %= 256;
3236 checksum ^= 0xFF;
3237 checksum += 1;
3238
3239 ixj_write_cid_byte(j, (char) checksum);
3240
3241 pad = j->fskdcnt % 240;
3242 if (pad) {
3243 pad = 240 - pad;
3244 }
3245 ixj_pad_fsk(j, pad);
3246 break;
3247 }
3248
3249 ixj_write_frame(j);
3250}
3251
3252static void ixj_write_cidcw(IXJ *j)
3253{
3254 IXJ_TONE ti;
3255
3256 char sdmf1[50];
3257 char sdmf2[50];
3258 char sdmf3[80];
3259 char mdmflen, len1, len2, len3;
3260 int pad;
3261
3262 int checksum = 0;
3263
3264 if (j->dsp.low == 0x20 || j->flags.cidplay)
3265 return;
3266
3267 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3268 j->cidsize = j->cidcnt = 0;
3269
3270 ixj_fsk_alloc(j);
3271
3272 j->flags.cidcw_ack = 0;
3273
3274 ti.tone_index = 23;
3275 ti.gain0 = 1;
3276 ti.freq0 = hz440;
3277 ti.gain1 = 0;
3278 ti.freq1 = 0;
3279 ixj_init_tone(j, &ti);
3280
3281 ixj_set_tone_on(1500, j);
3282 ixj_set_tone_off(32, j);
3283 if(ixjdebug & 0x0200) {
3284 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3285 }
3286 ixj_play_tone(j, 23);
3287
3288 clear_bit(j->board, &j->busyflags);
3289 while(j->tone_state) {
3290 set_current_state(TASK_INTERRUPTIBLE);
3291 schedule_timeout(1);
3292 }
3293 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3294 set_current_state(TASK_INTERRUPTIBLE);
3295 schedule_timeout(1);
3296 }
3297 if(ixjdebug & 0x0200) {
3298 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3299 }
3300
3301 ti.tone_index = 24;
3302 ti.gain0 = 1;
3303 ti.freq0 = hz2130;
3304 ti.gain1 = 0;
3305 ti.freq1 = hz2750;
3306 ixj_init_tone(j, &ti);
3307
3308 ixj_set_tone_off(10, j);
3309 ixj_set_tone_on(600, j);
3310 if(ixjdebug & 0x0200) {
3311 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3312 }
3313 ixj_play_tone(j, 24);
3314
3315 clear_bit(j->board, &j->busyflags);
3316 while(j->tone_state) {
3317 set_current_state(TASK_INTERRUPTIBLE);
3318 schedule_timeout(1);
3319 }
3320 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3321 set_current_state(TASK_INTERRUPTIBLE);
3322 schedule_timeout(1);
3323 }
3324 if(ixjdebug & 0x0200) {
3325 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3326 }
3327
3328 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3329
3330 clear_bit(j->board, &j->busyflags);
3331 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait)) {
3332 set_current_state(TASK_INTERRUPTIBLE);
3333 schedule_timeout(1);
3334 }
3335 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3336 set_current_state(TASK_INTERRUPTIBLE);
3337 schedule_timeout(1);
3338 }
3339 j->cidcw_wait = 0;
3340 if(!j->flags.cidcw_ack) {
3341 if(ixjdebug & 0x0200) {
3342 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3343 }
3344 ixj_post_cid(j);
3345 if(j->cid_play_flag) {
3346 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3347 }
3348 return;
3349 } else {
3350 ixj_pre_cid(j);
3351 }
3352 j->flags.cidcw_ack = 0;
3353 strcpy(sdmf1, j->cid_send.month);
3354 strcat(sdmf1, j->cid_send.day);
3355 strcat(sdmf1, j->cid_send.hour);
3356 strcat(sdmf1, j->cid_send.min);
3357 strcpy(sdmf2, j->cid_send.number);
3358 strcpy(sdmf3, j->cid_send.name);
3359
3360 len1 = strlen(sdmf1);
3361 len2 = strlen(sdmf2);
3362 len3 = strlen(sdmf3);
3363 mdmflen = len1 + len2 + len3 + 6;
3364
3365 ixj_write_cidcw_seize(j);
3366
3367 ixj_write_cid_byte(j, 0x80);
3368 checksum = 0x80;
3369 ixj_write_cid_byte(j, mdmflen);
3370 checksum = checksum + mdmflen;
3371
3372 ixj_write_cid_byte(j, 0x01);
3373 checksum = checksum + 0x01;
3374 ixj_write_cid_byte(j, len1);
3375 checksum = checksum + len1;
3376 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3377
3378 ixj_write_cid_byte(j, 0x02);
3379 checksum = checksum + 0x02;
3380 ixj_write_cid_byte(j, len2);
3381 checksum = checksum + len2;
3382 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3383
3384 ixj_write_cid_byte(j, 0x07);
3385 checksum = checksum + 0x07;
3386 ixj_write_cid_byte(j, len3);
3387 checksum = checksum + len3;
3388 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3389
3390 checksum %= 256;
3391 checksum ^= 0xFF;
3392 checksum += 1;
3393
3394 ixj_write_cid_byte(j, (char) checksum);
3395
3396 pad = j->fskdcnt % 240;
3397 if (pad) {
3398 pad = 240 - pad;
3399 }
3400 ixj_pad_fsk(j, pad);
3401 if(ixjdebug & 0x0200) {
3402 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3403 }
3404}
3405
3406static void ixj_write_vmwi(IXJ *j, int msg)
3407{
3408 char mdmflen;
3409 int pad;
3410
3411 int checksum = 0;
3412
3413 if (j->dsp.low == 0x20 || j->flags.cidplay)
3414 return;
3415
3416 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3417 j->cidsize = j->cidcnt = 0;
3418
3419 ixj_fsk_alloc(j);
3420
3421 mdmflen = 3;
3422
3423 if (j->port == PORT_POTS)
3424 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3425
3426 ixj_write_cid_seize(j);
3427
3428 ixj_write_cid_byte(j, 0x82);
3429 checksum = 0x82;
3430 ixj_write_cid_byte(j, mdmflen);
3431 checksum = checksum + mdmflen;
3432
3433 ixj_write_cid_byte(j, 0x0B);
3434 checksum = checksum + 0x0B;
3435 ixj_write_cid_byte(j, 1);
3436 checksum = checksum + 1;
3437
3438 if(msg) {
3439 ixj_write_cid_byte(j, 0xFF);
3440 checksum = checksum + 0xFF;
3441 }
3442 else {
3443 ixj_write_cid_byte(j, 0x00);
3444 checksum = checksum + 0x00;
3445 }
3446
3447 checksum %= 256;
3448 checksum ^= 0xFF;
3449 checksum += 1;
3450
3451 ixj_write_cid_byte(j, (char) checksum);
3452
3453 pad = j->fskdcnt % 240;
3454 if (pad) {
3455 pad = 240 - pad;
3456 }
3457 ixj_pad_fsk(j, pad);
3458}
3459
3460static void ixj_write_frame(IXJ *j)
3461{
3462 int cnt, frame_count, dly;
3463 IXJ_WORD dat;
3464 BYTES blankword;
3465
3466 frame_count = 0;
3467 if(j->flags.cidplay) {
3468 for(cnt = 0; cnt < 480; cnt++) {
3469 if (!(cnt % 16) && !IsTxReady(j)) {
3470 dly = 0;
3471 while (!IsTxReady(j)) {
3472 if (dly++ > 5) {
3473 dly = 0;
3474 break;
3475 }
3476 udelay(10);
3477 }
3478 }
3479 dat.word = j->fskdata[j->cidcnt++];
3480 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3481 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3482 cnt++;
3483 }
3484 if(j->cidcnt >= j->fskdcnt) {
3485 ixj_post_cid(j);
3486 }
3487 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3488 and there is real audio data in the buffer, we need to throw it away because
3489 we just used it's time slot */
3490 if (j->write_buffer_rp > j->write_buffer_wp) {
3491 j->write_buffer_rp += j->cid_play_frame_size * 2;
3492 if (j->write_buffer_rp >= j->write_buffer_end) {
3493 j->write_buffer_rp = j->write_buffer;
3494 }
3495 j->write_buffers_empty++;
3496 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3497
3498 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3499 }
3500 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3501 if (j->write_buffer_wp > j->write_buffer_rp) {
3502 frame_count =
3503 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3504 }
3505 if (j->write_buffer_rp > j->write_buffer_wp) {
3506 frame_count =
3507 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3508 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3509 }
3510 if (frame_count >= 1) {
3511 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3512 switch (j->play_mode) {
3513 case PLAYBACK_MODE_ULAW:
3514 case PLAYBACK_MODE_ALAW:
3515 blankword.low = blankword.high = 0xFF;
3516 break;
3517 case PLAYBACK_MODE_8LINEAR:
3518 case PLAYBACK_MODE_16LINEAR:
3519 blankword.low = blankword.high = 0x00;
3520 break;
3521 case PLAYBACK_MODE_8LINEAR_WSS:
3522 blankword.low = blankword.high = 0x80;
3523 break;
3524 }
3525 for (cnt = 0; cnt < 16; cnt++) {
3526 if (!(cnt % 16) && !IsTxReady(j)) {
3527 dly = 0;
3528 while (!IsTxReady(j)) {
3529 if (dly++ > 5) {
3530 dly = 0;
3531 break;
3532 }
3533 udelay(10);
3534 }
3535 }
3536 outb_p((blankword.low), j->DSPbase + 0x0C);
3537 outb_p((blankword.high), j->DSPbase + 0x0D);
3538 }
3539 j->flags.play_first_frame = 0;
3540 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3541 for (cnt = 0; cnt < 24; cnt++) {
3542 if(cnt == 12) {
3543 blankword.low = 0x02;
3544 blankword.high = 0x00;
3545 }
3546 else {
3547 blankword.low = blankword.high = 0x00;
3548 }
3549 if (!(cnt % 16) && !IsTxReady(j)) {
3550 dly = 0;
3551 while (!IsTxReady(j)) {
3552 if (dly++ > 5) {
3553 dly = 0;
3554 break;
3555 }
3556 udelay(10);
3557 }
3558 }
3559 outb_p((blankword.low), j->DSPbase + 0x0C);
3560 outb_p((blankword.high), j->DSPbase + 0x0D);
3561 }
3562 j->flags.play_first_frame = 0;
3563 }
3564 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3565 if (!(cnt % 16) && !IsTxReady(j)) {
3566 dly = 0;
3567 while (!IsTxReady(j)) {
3568 if (dly++ > 5) {
3569 dly = 0;
3570 break;
3571 }
3572 udelay(10);
3573 }
3574 }
3575 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3576 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3577 if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
3578 j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
3579 j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && 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
3614static 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
3631static 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
3683static 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:
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]3853 kfree(j->read_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3854 j->rec_frame_size = 0;
3855 j->rec_mode = -1;
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]3856 j->read_buffer = NULL;
3857 j->read_buffer_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3858 retval = 1;
3859 break;
3860 }
3861 return retval;
3862}
3863
3864static 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
3973static void ixj_record_stop(IXJ *j)
3974{
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]3975 if (ixjdebug & 0x0002)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3976 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3977
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]3978 kfree(j->read_buffer);
3979 j->read_buffer = NULL;
3980 j->read_buffer_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3981 if (j->rec_mode > -1) {
3982 ixj_WriteDSPCommand(0x5120, j);
3983 j->rec_mode = -1;
3984 }
3985 j->flags.recording = 0;
3986}
3987static 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
3995static 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
4004static void set_dtmf_prescale(IXJ *j, int volume)
4005{
4006 ixj_WriteDSPCommand(0xCF07, j);
4007 ixj_WriteDSPCommand(volume, j);
4008}
4009
4010static int get_dtmf_prescale(IXJ *j)
4011{
4012 ixj_WriteDSPCommand(0xCF05, j);
4013 return j->ssr.high << 8 | j->ssr.low;
4014}
4015
4016static 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
4031static 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
4069static 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
4086static 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
4116static 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
4127static 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 threashold 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 threashold at 3dB */
4239
4240 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4241
4242 break;
4243 }
4244 }
4245}
4246
4247static 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
4261static 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:
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]4431 kfree(j->write_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4432 j->play_frame_size = 0;
4433 j->play_mode = -1;
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]4434 j->write_buffer = NULL;
4435 j->write_buffer_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4436 retval = 1;
4437 break;
4438 }
4439 return retval;
4440}
4441
4442static 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
4556static void ixj_play_stop(IXJ *j)
4557{
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]4558 if (ixjdebug & 0x0002)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4559 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4560
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]4561 kfree(j->write_buffer);
4562 j->write_buffer = NULL;
4563 j->write_buffer_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]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
4572static 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
4583static 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_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
4599static 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
4620static 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
4634static 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
4654static 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
4674static 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
4724static 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
4735static int ixj_get_mixer(long val, IXJ *j)
4736{
4737 int reg = (val & 0x1F00) >> 8;
4738 return j->mix.vol[reg];
4739}
4740
4741static 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
4762static 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
4772static 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
4819static 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
4854static 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 bytes.high = 0xF0 + cr;
4874 break;
4875 }
4876
4877 bytes.low = 0x00;
4878
4879 outb_p(bytes.high, j->XILINXbase + 0x03);
4880 outb_p(bytes.low, j->XILINXbase + 0x02);
4881
4882 if (!SCI_Control(j, SCI_Enable_DAA))
4883 return 0;
4884
4885 bytes.high = inb_p(j->XILINXbase + 0x03);
4886 bytes.low = inb_p(j->XILINXbase + 0x02);
4887 if (bytes.low != ALISDAA_ID_BYTE) {
4888 if (ixjdebug & 0x0001)
4889 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4890 return 0;
4891 }
4892 if (!SCI_Control(j, SCI_Enable_DAA))
4893 return 0;
4894 if (!SCI_Control(j, SCI_End))
4895 return 0;
4896
4897 wdata.word = inw_p(j->XILINXbase + 0x02);
4898
4899 switch(cr){
4900 case 5:
4901 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4902 break;
4903 case 4:
4904 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4905 break;
4906 case 3:
4907 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4908 break;
4909 case 2:
4910 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4911 break;
4912 case 1:
4913 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4914 break;
4915 case 0:
4916 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4917 break;
4918 default:
4919 return 0;
4920 }
4921 return 1;
4922}
4923
4924static int ixj_daa_cid_reset(IXJ *j)
4925{
4926 int i;
4927 BYTES bytes;
4928
4929 if (ixjdebug & 0x0002)
4930 printk("DAA Clearing CID ram\n");
4931
4932 if (!SCI_Prepare(j))
4933 return 0;
4934
4935 bytes.high = 0x58;
4936 bytes.low = 0x00;
4937 outb_p(bytes.high, j->XILINXbase + 0x03);
4938 outb_p(bytes.low, j->XILINXbase + 0x02);
4939
4940 if (!SCI_Control(j, SCI_Enable_DAA))
4941 return 0;
4942
4943 if (!SCI_WaitHighSCI(j))
4944 return 0;
4945
4946 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4947 bytes.high = bytes.low = 0x00;
4948 outb_p(bytes.high, j->XILINXbase + 0x03);
4949
4950 if (i < ALISDAA_CALLERID_SIZE - 1)
4951 outb_p(bytes.low, j->XILINXbase + 0x02);
4952
4953 if (!SCI_Control(j, SCI_Enable_DAA))
4954 return 0;
4955
4956 if (!SCI_WaitHighSCI(j))
4957 return 0;
4958
4959 }
4960
4961 if (!SCI_Control(j, SCI_End))
4962 return 0;
4963
4964 if (ixjdebug & 0x0002)
4965 printk("DAA CID ram cleared\n");
4966
4967 return 1;
4968}
4969
4970static int ixj_daa_cid_read(IXJ *j)
4971{
4972 int i;
4973 BYTES bytes;
4974 char CID[ALISDAA_CALLERID_SIZE], mContinue;
4975 char *pIn, *pOut;
4976
4977 if (!SCI_Prepare(j))
4978 return 0;
4979
4980 bytes.high = 0x78;
4981 bytes.low = 0x00;
4982 outb_p(bytes.high, j->XILINXbase + 0x03);
4983 outb_p(bytes.low, j->XILINXbase + 0x02);
4984
4985 if (!SCI_Control(j, SCI_Enable_DAA))
4986 return 0;
4987
4988 if (!SCI_WaitHighSCI(j))
4989 return 0;
4990
4991 bytes.high = inb_p(j->XILINXbase + 0x03);
4992 bytes.low = inb_p(j->XILINXbase + 0x02);
4993 if (bytes.low != ALISDAA_ID_BYTE) {
4994 if (ixjdebug & 0x0001)
4995 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4996 return 0;
4997 }
4998 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
4999 bytes.high = bytes.low = 0x00;
5000 outb_p(bytes.high, j->XILINXbase + 0x03);
5001 outb_p(bytes.low, j->XILINXbase + 0x02);
5002
5003 if (!SCI_Control(j, SCI_Enable_DAA))
5004 return 0;
5005
5006 if (!SCI_WaitHighSCI(j))
5007 return 0;
5008
5009 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5010 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5011 }
5012
5013 if (!SCI_Control(j, SCI_End))
5014 return 0;
5015
5016 pIn = CID;
5017 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5018 mContinue = 1;
5019 while (mContinue) {
5020 if ((pIn[1] & 0x03) == 0x01) {
5021 pOut[0] = pIn[0];
5022 }
5023 if ((pIn[2] & 0x0c) == 0x04) {
5024 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5025 }
5026 if ((pIn[3] & 0x30) == 0x10) {
5027 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5028 }
5029 if ((pIn[4] & 0xc0) == 0x40) {
5030 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5031 } else {
5032 mContinue = FALSE;
5033 }
5034 pIn += 5, pOut += 4;
5035 }
5036 memset(&j->cid, 0, sizeof(PHONE_CID));
5037 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5038 pOut += 4;
5039 strncpy(j->cid.month, pOut, 2);
5040 pOut += 2;
5041 strncpy(j->cid.day, pOut, 2);
5042 pOut += 2;
5043 strncpy(j->cid.hour, pOut, 2);
5044 pOut += 2;
5045 strncpy(j->cid.min, pOut, 2);
5046 pOut += 3;
5047 j->cid.numlen = *pOut;
5048 pOut += 1;
5049 strncpy(j->cid.number, pOut, j->cid.numlen);
5050 pOut += j->cid.numlen + 1;
5051 j->cid.namelen = *pOut;
5052 pOut += 1;
5053 strncpy(j->cid.name, pOut, j->cid.namelen);
5054
5055 ixj_daa_cid_reset(j);
5056 return 1;
5057}
5058
5059static char daa_get_version(IXJ *j)
5060{
5061 BYTES bytes;
5062
5063 if (!SCI_Prepare(j))
5064 return 0;
5065
5066 bytes.high = 0x35;
5067 bytes.low = 0x00;
5068 outb_p(bytes.high, j->XILINXbase + 0x03);
5069 outb_p(bytes.low, j->XILINXbase + 0x02);
5070
5071 if (!SCI_Control(j, SCI_Enable_DAA))
5072 return 0;
5073
5074 bytes.high = inb_p(j->XILINXbase + 0x03);
5075 bytes.low = inb_p(j->XILINXbase + 0x02);
5076 if (bytes.low != ALISDAA_ID_BYTE) {
5077 if (ixjdebug & 0x0001)
5078 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5079 return 0;
5080 }
5081 if (!SCI_Control(j, SCI_Enable_DAA))
5082 return 0;
5083
5084 if (!SCI_Control(j, SCI_End))
5085 return 0;
5086
5087 bytes.high = inb_p(j->XILINXbase + 0x03);
5088 bytes.low = inb_p(j->XILINXbase + 0x02);
5089 if (ixjdebug & 0x0002)
5090 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5091 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5092 return bytes.high;
5093}
5094
5095static int daa_set_mode(IXJ *j, int mode)
5096{
5097 /* NOTE:
5098 The DAA *MUST* be in the conversation mode if the
5099 PSTN line is to be seized (PSTN line off-hook).
5100 Taking the PSTN line off-hook while the DAA is in
5101 a mode other than conversation mode will cause a
5102 hardware failure of the ALIS-A part.
5103
5104 NOTE:
5105 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5106 if the PSTN line is on-hook. Failure to have the PSTN line
5107 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5108 ALIS-A part.
5109 */
5110
5111 BYTES bytes;
5112
5113 j->flags.pstn_rmr = 0;
5114
5115 if (!SCI_Prepare(j))
5116 return 0;
5117
5118 switch (mode) {
5119 case SOP_PU_RESET:
5120 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5121
5122 outb_p(j->pld_scrw.byte, j->XILINXbase);
5123 j->pld_slicw.bits.rly2 = 0;
5124 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5125 bytes.high = 0x10;
5126 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5127 daa_load(&bytes, j);
5128 if (!SCI_Prepare(j))
5129 return 0;
5130
5131 j->daa_mode = SOP_PU_SLEEP;
5132 break;
5133 case SOP_PU_SLEEP:
5134 if(j->daa_mode == SOP_PU_SLEEP)
5135 {
5136 break;
5137 }
5138 if (ixjdebug & 0x0008)
5139 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5140/* if(j->daa_mode == SOP_PU_CONVERSATION) */
5141 {
5142 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5143
5144 outb_p(j->pld_scrw.byte, j->XILINXbase);
5145 j->pld_slicw.bits.rly2 = 0;
5146 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5147 bytes.high = 0x10;
5148 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5149 daa_load(&bytes, j);
5150 if (!SCI_Prepare(j))
5151 return 0;
5152 }
5153 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5154
5155 outb_p(j->pld_scrw.byte, j->XILINXbase);
5156 j->pld_slicw.bits.rly2 = 0;
5157 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5158 bytes.high = 0x10;
5159 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5160 daa_load(&bytes, j);
5161 if (!SCI_Prepare(j))
5162 return 0;
5163
5164 j->daa_mode = SOP_PU_SLEEP;
5165 j->flags.pstn_ringing = 0;
5166 j->ex.bits.pstn_ring = 0;
5167 j->pstn_sleeptil = jiffies + (hertz / 4);
5168 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5169 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5170 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5171 break;
5172 case SOP_PU_RINGING:
5173 if (ixjdebug & 0x0008)
5174 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5175 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5176
5177 outb_p(j->pld_scrw.byte, j->XILINXbase);
5178 j->pld_slicw.bits.rly2 = 0;
5179 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5180 bytes.high = 0x50;
5181 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5182 daa_load(&bytes, j);
5183 if (!SCI_Prepare(j))
5184 return 0;
5185 j->daa_mode = SOP_PU_RINGING;
5186 break;
5187 case SOP_PU_CONVERSATION:
5188 if (ixjdebug & 0x0008)
5189 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5190 bytes.high = 0x90;
5191 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5192 daa_load(&bytes, j);
5193 if (!SCI_Prepare(j))
5194 return 0;
5195 j->pld_slicw.bits.rly2 = 1;
5196 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5197 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5198
5199 outb_p(j->pld_scrw.byte, j->XILINXbase);
5200 j->daa_mode = SOP_PU_CONVERSATION;
5201 j->flags.pstn_ringing = 0;
5202 j->ex.bits.pstn_ring = 0;
5203 j->pstn_sleeptil = jiffies;
5204 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5205 break;
5206 case SOP_PU_PULSEDIALING:
5207 if (ixjdebug & 0x0008)
5208 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5209 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5210
5211 outb_p(j->pld_scrw.byte, j->XILINXbase);
5212 j->pld_slicw.bits.rly2 = 0;
5213 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5214 bytes.high = 0xD0;
5215 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5216 daa_load(&bytes, j);
5217 if (!SCI_Prepare(j))
5218 return 0;
5219 j->daa_mode = SOP_PU_PULSEDIALING;
5220 break;
5221 default:
5222 break;
5223 }
5224 return 1;
5225}
5226
5227static int ixj_daa_write(IXJ *j)
5228{
5229 BYTES bytes;
5230
5231 j->flags.pstncheck = 1;
5232
5233 daa_set_mode(j, SOP_PU_SLEEP);
5234
5235 if (!SCI_Prepare(j))
5236 return 0;
5237
5238 outb_p(j->pld_scrw.byte, j->XILINXbase);
5239
5240 bytes.high = 0x14;
5241 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5242 if (!daa_load(&bytes, j))
5243 return 0;
5244
5245 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5246 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5247 if (!daa_load(&bytes, j))
5248 return 0;
5249
5250 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5251 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5252 if (!daa_load(&bytes, j))
5253 return 0;
5254
5255 if (!SCI_Prepare(j))
5256 return 0;
5257
5258 bytes.high = 0x1F;
5259 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5260 if (!daa_load(&bytes, j))
5261 return 0;
5262
5263 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5264 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5265 if (!daa_load(&bytes, j))
5266 return 0;
5267
5268 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5269 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5270 if (!daa_load(&bytes, j))
5271 return 0;
5272
5273 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5274 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5275 if (!daa_load(&bytes, j))
5276 return 0;
5277
5278 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5279 bytes.low = 0x00;
5280 if (!daa_load(&bytes, j))
5281 return 0;
5282
5283 if (!SCI_Prepare(j))
5284 return 0;
5285
5286 bytes.high = 0x00;
5287 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5288 if (!daa_load(&bytes, j))
5289 return 0;
5290
5291 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5292 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5293 if (!daa_load(&bytes, j))
5294 return 0;
5295
5296 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5297 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5298 if (!daa_load(&bytes, j))
5299 return 0;
5300
5301 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5302 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5303 if (!daa_load(&bytes, j))
5304 return 0;
5305
5306 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5307 bytes.low = 0x00;
5308 if (!daa_load(&bytes, j))
5309 return 0;
5310
5311 if (!SCI_Control(j, SCI_End))
5312 return 0;
5313 if (!SCI_WaitLowSCI(j))
5314 return 0;
5315
5316 bytes.high = 0x01;
5317 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5318 if (!daa_load(&bytes, j))
5319 return 0;
5320
5321 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5322 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5323 if (!daa_load(&bytes, j))
5324 return 0;
5325
5326 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5327 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5328 if (!daa_load(&bytes, j))
5329 return 0;
5330
5331 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5332 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5333 if (!daa_load(&bytes, j))
5334 return 0;
5335
5336 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5337 bytes.low = 0x00;
5338 if (!daa_load(&bytes, j))
5339 return 0;
5340
5341 if (!SCI_Control(j, SCI_End))
5342 return 0;
5343 if (!SCI_WaitLowSCI(j))
5344 return 0;
5345
5346 bytes.high = 0x02;
5347 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5348 if (!daa_load(&bytes, j))
5349 return 0;
5350
5351 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5352 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5353 if (!daa_load(&bytes, j))
5354 return 0;
5355
5356 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5357 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5358 if (!daa_load(&bytes, j))
5359 return 0;
5360
5361 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5362 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5363 if (!daa_load(&bytes, j))
5364 return 0;
5365
5366 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5367 bytes.low = 0x00;
5368 if (!daa_load(&bytes, j))
5369 return 0;
5370
5371 if (!SCI_Control(j, SCI_End))
5372 return 0;
5373 if (!SCI_WaitLowSCI(j))
5374 return 0;
5375
5376 bytes.high = 0x03;
5377 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5378 if (!daa_load(&bytes, j))
5379 return 0;
5380
5381 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5382 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5383 if (!daa_load(&bytes, j))
5384 return 0;
5385
5386 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5387 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5388 if (!daa_load(&bytes, j))
5389 return 0;
5390
5391 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5392 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5393 if (!daa_load(&bytes, j))
5394 return 0;
5395
5396 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5397 bytes.low = 0x00;
5398 if (!daa_load(&bytes, j))
5399 return 0;
5400
5401 if (!SCI_Control(j, SCI_End))
5402 return 0;
5403 if (!SCI_WaitLowSCI(j))
5404 return 0;
5405
5406 bytes.high = 0x04;
5407 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5408 if (!daa_load(&bytes, j))
5409 return 0;
5410
5411 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5412 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5413 if (!daa_load(&bytes, j))
5414 return 0;
5415
5416 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5417 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5418 if (!daa_load(&bytes, j))
5419 return 0;
5420
5421 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5422 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5423 if (!daa_load(&bytes, j))
5424 return 0;
5425
5426 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5427 bytes.low = 0x00;
5428 if (!daa_load(&bytes, j))
5429 return 0;
5430
5431 if (!SCI_Control(j, SCI_End))
5432 return 0;
5433 if (!SCI_WaitLowSCI(j))
5434 return 0;
5435
5436 bytes.high = 0x05;
5437 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5438 if (!daa_load(&bytes, j))
5439 return 0;
5440
5441 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5442 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5443 if (!daa_load(&bytes, j))
5444 return 0;
5445
5446 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5447 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5448 if (!daa_load(&bytes, j))
5449 return 0;
5450
5451 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5452 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5453 if (!daa_load(&bytes, j))
5454 return 0;
5455
5456 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5457 bytes.low = 0x00;
5458 if (!daa_load(&bytes, j))
5459 return 0;
5460
5461 if (!SCI_Control(j, SCI_End))
5462 return 0;
5463 if (!SCI_WaitLowSCI(j))
5464 return 0;
5465
5466 bytes.high = 0x06;
5467 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5468 if (!daa_load(&bytes, j))
5469 return 0;
5470
5471 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5472 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5473 if (!daa_load(&bytes, j))
5474 return 0;
5475
5476 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5477 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5478 if (!daa_load(&bytes, j))
5479 return 0;
5480
5481 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5482 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5483 if (!daa_load(&bytes, j))
5484 return 0;
5485
5486 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5487 bytes.low = 0x00;
5488 if (!daa_load(&bytes, j))
5489 return 0;
5490
5491 if (!SCI_Control(j, SCI_End))
5492 return 0;
5493 if (!SCI_WaitLowSCI(j))
5494 return 0;
5495
5496 bytes.high = 0x07;
5497 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5498 if (!daa_load(&bytes, j))
5499 return 0;
5500
5501 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5502 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5503 if (!daa_load(&bytes, j))
5504 return 0;
5505
5506 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5507 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5508 if (!daa_load(&bytes, j))
5509 return 0;
5510
5511 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5512 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5513 if (!daa_load(&bytes, j))
5514 return 0;
5515
5516 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5517 bytes.low = 0x00;
5518 if (!daa_load(&bytes, j))
5519 return 0;
5520
5521 if (!SCI_Control(j, SCI_End))
5522 return 0;
5523 if (!SCI_WaitLowSCI(j))
5524 return 0;
5525
5526 bytes.high = 0x08;
5527 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5528 if (!daa_load(&bytes, j))
5529 return 0;
5530
5531 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5532 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5533 if (!daa_load(&bytes, j))
5534 return 0;
5535
5536 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5537 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5538 if (!daa_load(&bytes, j))
5539 return 0;
5540
5541 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5542 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5543 if (!daa_load(&bytes, j))
5544 return 0;
5545
5546 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5547 bytes.low = 0x00;
5548 if (!daa_load(&bytes, j))
5549 return 0;
5550
5551 if (!SCI_Control(j, SCI_End))
5552 return 0;
5553 if (!SCI_WaitLowSCI(j))
5554 return 0;
5555
5556 bytes.high = 0x09;
5557 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5558 if (!daa_load(&bytes, j))
5559 return 0;
5560
5561 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5562 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5563 if (!daa_load(&bytes, j))
5564 return 0;
5565
5566 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5567 bytes.low = 0x00;
5568 if (!daa_load(&bytes, j))
5569 return 0;
5570
5571 if (!SCI_Control(j, SCI_End))
5572 return 0;
5573 if (!SCI_WaitLowSCI(j))
5574 return 0;
5575
5576 bytes.high = 0x0A;
5577 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5578 if (!daa_load(&bytes, j))
5579 return 0;
5580
5581 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5582 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5583 if (!daa_load(&bytes, j))
5584 return 0;
5585
5586 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5587 bytes.low = 0x00;
5588 if (!daa_load(&bytes, j))
5589 return 0;
5590
5591 if (!SCI_Control(j, SCI_End))
5592 return 0;
5593 if (!SCI_WaitLowSCI(j))
5594 return 0;
5595
5596 bytes.high = 0x0B;
5597 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5598 if (!daa_load(&bytes, j))
5599 return 0;
5600
5601 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5602 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5603 if (!daa_load(&bytes, j))
5604 return 0;
5605
5606 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5607 bytes.low = 0x00;
5608 if (!daa_load(&bytes, j))
5609 return 0;
5610
5611 if (!SCI_Control(j, SCI_End))
5612 return 0;
5613 if (!SCI_WaitLowSCI(j))
5614 return 0;
5615
5616 bytes.high = 0x0C;
5617 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5618 if (!daa_load(&bytes, j))
5619 return 0;
5620
5621 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5622 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5623 if (!daa_load(&bytes, j))
5624 return 0;
5625
5626 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5627 bytes.low = 0x00;
5628 if (!daa_load(&bytes, j))
5629 return 0;
5630
5631 if (!SCI_Control(j, SCI_End))
5632 return 0;
5633 if (!SCI_WaitLowSCI(j))
5634 return 0;
5635
5636 bytes.high = 0x0D;
5637 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5638 if (!daa_load(&bytes, j))
5639 return 0;
5640
5641 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5642 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5643 if (!daa_load(&bytes, j))
5644 return 0;
5645
5646 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5647 bytes.low = 0x00;
5648 if (!daa_load(&bytes, j))
5649 return 0;
5650
5651 if (!SCI_Control(j, SCI_End))
5652 return 0;
5653 if (!SCI_WaitLowSCI(j))
5654 return 0;
5655
5656 bytes.high = 0x0E;
5657 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5658 if (!daa_load(&bytes, j))
5659 return 0;
5660
5661 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5662 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5663 if (!daa_load(&bytes, j))
5664 return 0;
5665
5666 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5667 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5668 if (!daa_load(&bytes, j))
5669 return 0;
5670
5671 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5672 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5673 if (!daa_load(&bytes, j))
5674 return 0;
5675
5676 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5677 bytes.low = 0x00;
5678 if (!daa_load(&bytes, j))
5679 return 0;
5680
5681 if (!SCI_Control(j, SCI_End))
5682 return 0;
5683 if (!SCI_WaitLowSCI(j))
5684 return 0;
5685
5686 bytes.high = 0x0F;
5687 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5688 if (!daa_load(&bytes, j))
5689 return 0;
5690
5691 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5692 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5693 if (!daa_load(&bytes, j))
5694 return 0;
5695
5696 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5697 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5698 if (!daa_load(&bytes, j))
5699 return 0;
5700
5701 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5702 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5703 if (!daa_load(&bytes, j))
5704 return 0;
5705
5706 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5707 bytes.low = 0x00;
5708 if (!daa_load(&bytes, j))
5709 return 0;
5710
5711 udelay(32);
5712 j->pld_scrr.byte = inb_p(j->XILINXbase);
5713 if (!SCI_Control(j, SCI_End))
5714 return 0;
5715
5716 outb_p(j->pld_scrw.byte, j->XILINXbase);
5717
5718 if (ixjdebug & 0x0002)
5719 printk("DAA Coefficients Loaded\n");
5720
5721 j->flags.pstncheck = 0;
5722 return 1;
5723}
5724
5725int ixj_set_tone_off(unsigned short arg, IXJ *j)
5726{
5727 j->tone_off_time = arg;
5728 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5729
5730 return -1;
5731 if (ixj_WriteDSPCommand(arg, j))
5732 return -1;
5733 return 0;
5734}
5735
5736static int ixj_get_tone_on(IXJ *j)
5737{
5738 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5739
5740 return -1;
5741 return 0;
5742}
5743
5744static int ixj_get_tone_off(IXJ *j)
5745{
5746 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5747
5748 return -1;
5749 return 0;
5750}
5751
5752static void ixj_busytone(IXJ *j)
5753{
5754 j->flags.ringback = 0;
5755 j->flags.dialtone = 0;
5756 j->flags.busytone = 1;
5757 ixj_set_tone_on(0x07D0, j);
5758 ixj_set_tone_off(0x07D0, j);
5759 ixj_play_tone(j, 27);
5760}
5761
5762static void ixj_dialtone(IXJ *j)
5763{
5764 j->flags.ringback = 0;
5765 j->flags.dialtone = 1;
5766 j->flags.busytone = 0;
5767 if (j->dsp.low == 0x20) {
5768 return;
5769 } else {
5770 ixj_set_tone_on(0xFFFF, j);
5771 ixj_set_tone_off(0x0000, j);
5772 ixj_play_tone(j, 25);
5773 }
5774}
5775
5776static void ixj_cpt_stop(IXJ *j)
5777{
5778 if(j->tone_state || j->tone_cadence_state)
5779 {
5780 j->flags.dialtone = 0;
5781 j->flags.busytone = 0;
5782 j->flags.ringback = 0;
5783 ixj_set_tone_on(0x0001, j);
5784 ixj_set_tone_off(0x0000, j);
5785 ixj_play_tone(j, 0);
5786 j->tone_state = j->tone_cadence_state = 0;
5787 if (j->cadence_t) {
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]5788 kfree(j->cadence_t->ce);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5789 kfree(j->cadence_t);
5790 j->cadence_t = NULL;
5791 }
5792 }
5793 if (j->play_mode == -1 && j->rec_mode == -1)
5794 idle(j);
5795 if (j->play_mode != -1 && j->dsp.low == 0x20)
5796 ixj_play_start(j);
5797 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5798 ixj_record_start(j);
5799}
5800
5801static void ixj_ringback(IXJ *j)
5802{
5803 j->flags.busytone = 0;
5804 j->flags.dialtone = 0;
5805 j->flags.ringback = 1;
5806 ixj_set_tone_on(0x0FA0, j);
5807 ixj_set_tone_off(0x2EE0, j);
5808 ixj_play_tone(j, 26);
5809}
5810
5811static void ixj_testram(IXJ *j)
5812{
5813 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5814}
5815
5816static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5817{
5818 ixj_cadence *lcp;
5819 IXJ_CADENCE_ELEMENT __user *cep;
5820 IXJ_CADENCE_ELEMENT *lcep;
5821 IXJ_TONE ti;
5822 int err;
5823
5824 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5825 if (lcp == NULL)
5826 return -ENOMEM;
5827
5828 err = -EFAULT;
5829 if (copy_from_user(&lcp->elements_used,
5830 &cp->elements_used, sizeof(int)))
5831 goto out;
5832 if (copy_from_user(&lcp->termination,
5833 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5834 goto out;
5835 if (get_user(cep, &cp->ce))
5836 goto out;
5837
5838 err = -EINVAL;
5839 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5840 goto out;
5841
5842 err = -ENOMEM;
5843 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5844 if (!lcep)
5845 goto out;
5846
5847 err = -EFAULT;
5848 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5849 goto out1;
5850
5851 if (j->cadence_t) {
5852 kfree(j->cadence_t->ce);
5853 kfree(j->cadence_t);
5854 }
5855 lcp->ce = (void *) lcep;
5856 j->cadence_t = lcp;
5857 j->tone_cadence_state = 0;
5858 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5859 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5860 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5861 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5862 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5863 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5864 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5865 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5866 ixj_init_tone(j, &ti);
5867 }
5868 ixj_play_tone(j, lcp->ce[0].index);
5869 return 1;
5870out1:
5871 kfree(lcep);
5872out:
5873 kfree(lcp);
5874 return err;
5875}
5876
5877static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5878{
5879 IXJ_FILTER_CADENCE *lcp;
5880 lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5881 if (lcp == NULL) {
5882 if(ixjdebug & 0x0001) {
5883 printk(KERN_INFO "Could not allocate memory for cadence\n");
5884 }
5885 return -ENOMEM;
5886 }
5887 if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5888 if(ixjdebug & 0x0001) {
5889 printk(KERN_INFO "Could not copy cadence to kernel\n");
5890 }
5891 kfree(lcp);
5892 return -EFAULT;
5893 }
5894 if (lcp->filter > 5) {
5895 if(ixjdebug & 0x0001) {
5896 printk(KERN_INFO "Cadence out of range\n");
5897 }
5898 kfree(lcp);
5899 return -1;
5900 }
5901 j->cadence_f[lcp->filter].state = 0;
5902 j->cadence_f[lcp->filter].enable = lcp->enable;
5903 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5904 j->cadence_f[lcp->filter].on1 = lcp->on1;
5905 j->cadence_f[lcp->filter].on1min = 0;
5906 j->cadence_f[lcp->filter].on1max = 0;
5907 j->cadence_f[lcp->filter].off1 = lcp->off1;
5908 j->cadence_f[lcp->filter].off1min = 0;
5909 j->cadence_f[lcp->filter].off1max = 0;
5910 j->cadence_f[lcp->filter].on2 = lcp->on2;
5911 j->cadence_f[lcp->filter].on2min = 0;
5912 j->cadence_f[lcp->filter].on2max = 0;
5913 j->cadence_f[lcp->filter].off2 = lcp->off2;
5914 j->cadence_f[lcp->filter].off2min = 0;
5915 j->cadence_f[lcp->filter].off2max = 0;
5916 j->cadence_f[lcp->filter].on3 = lcp->on3;
5917 j->cadence_f[lcp->filter].on3min = 0;
5918 j->cadence_f[lcp->filter].on3max = 0;
5919 j->cadence_f[lcp->filter].off3 = lcp->off3;
5920 j->cadence_f[lcp->filter].off3min = 0;
5921 j->cadence_f[lcp->filter].off3max = 0;
5922 if(ixjdebug & 0x0002) {
5923 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5924 }
5925 kfree(lcp);
5926 return 0;
5927}
5928
5929static void add_caps(IXJ *j)
5930{
5931 j->caps = 0;
5932 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5933 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5934 j->caplist[j->caps].captype = vendor;
5935 j->caplist[j->caps].handle = j->caps++;
5936 j->caplist[j->caps].captype = device;
5937 switch (j->cardtype) {
5938 case QTI_PHONEJACK:
5939 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5940 break;
5941 case QTI_LINEJACK:
5942 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5943 break;
5944 case QTI_PHONEJACK_LITE:
5945 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5946 break;
5947 case QTI_PHONEJACK_PCI:
5948 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5949 break;
5950 case QTI_PHONECARD:
5951 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5952 break;
5953 }
5954 j->caplist[j->caps].cap = j->cardtype;
5955 j->caplist[j->caps].handle = j->caps++;
5956 strcpy(j->caplist[j->caps].desc, "POTS");
5957 j->caplist[j->caps].captype = port;
5958 j->caplist[j->caps].cap = pots;
5959 j->caplist[j->caps].handle = j->caps++;
5960
5961 /* add devices that can do speaker/mic */
5962 switch (j->cardtype) {
5963 case QTI_PHONEJACK:
5964 case QTI_LINEJACK:
5965 case QTI_PHONEJACK_PCI:
5966 case QTI_PHONECARD:
5967 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5968 j->caplist[j->caps].captype = port;
5969 j->caplist[j->caps].cap = speaker;
5970 j->caplist[j->caps].handle = j->caps++;
5971 default:
5972 break;
5973 }
5974
5975 /* add devices that can do handset */
5976 switch (j->cardtype) {
5977 case QTI_PHONEJACK:
5978 strcpy(j->caplist[j->caps].desc, "HANDSET");
5979 j->caplist[j->caps].captype = port;
5980 j->caplist[j->caps].cap = handset;
5981 j->caplist[j->caps].handle = j->caps++;
5982 break;
5983 default:
5984 break;
5985 }
5986
5987 /* add devices that can do PSTN */
5988 switch (j->cardtype) {
5989 case QTI_LINEJACK:
5990 strcpy(j->caplist[j->caps].desc, "PSTN");
5991 j->caplist[j->caps].captype = port;
5992 j->caplist[j->caps].cap = pstn;
5993 j->caplist[j->caps].handle = j->caps++;
5994 break;
5995 default:
5996 break;
5997 }
5998
5999 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6000 strcpy(j->caplist[j->caps].desc, "ULAW");
6001 j->caplist[j->caps].captype = codec;
6002 j->caplist[j->caps].cap = ULAW;
6003 j->caplist[j->caps].handle = j->caps++;
6004
6005 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6006 j->caplist[j->caps].captype = codec;
6007 j->caplist[j->caps].cap = LINEAR16;
6008 j->caplist[j->caps].handle = j->caps++;
6009
6010 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6011 j->caplist[j->caps].captype = codec;
6012 j->caplist[j->caps].cap = LINEAR8;
6013 j->caplist[j->caps].handle = j->caps++;
6014
6015 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6016 j->caplist[j->caps].captype = codec;
6017 j->caplist[j->caps].cap = WSS;
6018 j->caplist[j->caps].handle = j->caps++;
6019
6020 /* software ALAW codec, made from ULAW */
6021 strcpy(j->caplist[j->caps].desc, "ALAW");
6022 j->caplist[j->caps].captype = codec;
6023 j->caplist[j->caps].cap = ALAW;
6024 j->caplist[j->caps].handle = j->caps++;
6025
6026 /* version 12 of the 8020 does the following codecs in a broken way */
6027 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6028 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6029 j->caplist[j->caps].captype = codec;
6030 j->caplist[j->caps].cap = G723_63;
6031 j->caplist[j->caps].handle = j->caps++;
6032
6033 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6034 j->caplist[j->caps].captype = codec;
6035 j->caplist[j->caps].cap = G723_53;
6036 j->caplist[j->caps].handle = j->caps++;
6037
6038 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6039 j->caplist[j->caps].captype = codec;
6040 j->caplist[j->caps].cap = TS48;
6041 j->caplist[j->caps].handle = j->caps++;
6042
6043 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6044 j->caplist[j->caps].captype = codec;
6045 j->caplist[j->caps].cap = TS41;
6046 j->caplist[j->caps].handle = j->caps++;
6047 }
6048
6049 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6050 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6051 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6052 j->caplist[j->caps].captype = codec;
6053 j->caplist[j->caps].cap = TS85;
6054 j->caplist[j->caps].handle = j->caps++;
6055 }
6056
6057 /* 8021 chips can do G728 */
6058 if (j->dsp.low == 0x21) {
6059 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6060 j->caplist[j->caps].captype = codec;
6061 j->caplist[j->caps].cap = G728;
6062 j->caplist[j->caps].handle = j->caps++;
6063 }
6064
6065 /* 8021/8022 chips can do G729 if loaded */
6066 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6067 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6068 j->caplist[j->caps].captype = codec;
6069 j->caplist[j->caps].cap = G729;
6070 j->caplist[j->caps].handle = j->caps++;
6071 }
6072 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6073 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6074 j->caplist[j->caps].captype = codec;
6075 j->caplist[j->caps].cap = G729B;
6076 j->caplist[j->caps].handle = j->caps++;
6077 }
6078}
6079
6080static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6081{
6082 int cnt;
6083 int retval = 0;
6084 for (cnt = 0; cnt < j->caps; cnt++) {
6085 if (pcreq->captype == j->caplist[cnt].captype
6086 && pcreq->cap == j->caplist[cnt].cap) {
6087 retval = 1;
6088 break;
6089 }
6090 }
6091 return retval;
6092}
6093
6094static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6095{
6096 IXJ_TONE ti;
6097 IXJ_FILTER jf;
6098 IXJ_FILTER_RAW jfr;
6099 void __user *argp = (void __user *)arg;
6100
6101 unsigned int raise, mant;
6102 unsigned int minor = iminor(inode);
6103 int board = NUM(inode);
6104
6105 IXJ *j = get_ixj(NUM(inode));
6106
6107 int retval = 0;
6108
6109 /*
6110 * Set up locks to ensure that only one process is talking to the DSP at a time.
6111 * This is necessary to keep the DSP from locking up.
6112 */
6113 while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
6114 set_current_state(TASK_INTERRUPTIBLE);
6115 schedule_timeout(1);
6116 }
6117 if (ixjdebug & 0x0040)
6118 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6119 if (minor >= IXJMAX) {
6120 clear_bit(board, &j->busyflags);
6121 return -ENODEV;
6122 }
6123 /*
6124 * Check ioctls only root can use.
6125 */
6126 if (!capable(CAP_SYS_ADMIN)) {
6127 switch (cmd) {
6128 case IXJCTL_TESTRAM:
6129 case IXJCTL_HZ:
6130 retval = -EPERM;
6131 }
6132 }
6133 switch (cmd) {
6134 case IXJCTL_TESTRAM:
6135 ixj_testram(j);
6136 retval = (j->ssr.high << 8) + j->ssr.low;
6137 break;
6138 case IXJCTL_CARDTYPE:
6139 retval = j->cardtype;
6140 break;
6141 case IXJCTL_SERIAL:
6142 retval = j->serial;
6143 break;
6144 case IXJCTL_VERSION:
Domen Puncerfba478b2005-05-05 16:16:13 -0700[diff] [blame]6145 {
6146 char arg_str[100];
6147 snprintf(arg_str, sizeof(arg_str),
6148 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6149 IXJ_VER_MINOR, IXJ_BLD_VER);
6150 if (copy_to_user(argp, arg_str, strlen(arg_str)))
6151 retval = -EFAULT;
6152 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6153 break;
6154 case PHONE_RING_CADENCE:
6155 j->ring_cadence = arg;
6156 break;
6157 case IXJCTL_CIDCW:
6158 if(arg) {
6159 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6160 retval = -EFAULT;
6161 break;
6162 }
6163 } else {
6164 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6165 }
6166 ixj_write_cidcw(j);
6167 break;
6168 /* Binary compatbility */
6169 case OLD_PHONE_RING_START:
6170 arg = 0;
6171 /* Fall through */
6172 case PHONE_RING_START:
6173 if(arg) {
6174 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6175 retval = -EFAULT;
6176 break;
6177 }
6178 ixj_write_cid(j);
6179 } else {
6180 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6181 }
6182 ixj_ring_start(j);
6183 break;
6184 case PHONE_RING_STOP:
6185 j->flags.cringing = 0;
6186 if(j->cadence_f[5].enable) {
6187 j->cadence_f[5].state = 0;
6188 }
6189 ixj_ring_off(j);
6190 break;
6191 case PHONE_RING:
6192 retval = ixj_ring(j);
6193 break;
6194 case PHONE_EXCEPTION:
6195 retval = j->ex.bytes;
6196 if(j->ex.bits.flash) {
6197 j->flash_end = 0;
6198 j->ex.bits.flash = 0;
6199 }
6200 j->ex.bits.pstn_ring = 0;
6201 j->ex.bits.caller_id = 0;
6202 j->ex.bits.pstn_wink = 0;
6203 j->ex.bits.f0 = 0;
6204 j->ex.bits.f1 = 0;
6205 j->ex.bits.f2 = 0;
6206 j->ex.bits.f3 = 0;
6207 j->ex.bits.fc0 = 0;
6208 j->ex.bits.fc1 = 0;
6209 j->ex.bits.fc2 = 0;
6210 j->ex.bits.fc3 = 0;
6211 j->ex.bits.reserved = 0;
6212 break;
6213 case PHONE_HOOKSTATE:
6214 j->ex.bits.hookstate = 0;
6215 retval = j->hookstate; //j->r_hook;
6216 break;
6217 case IXJCTL_SET_LED:
6218 LED_SetState(arg, j);
6219 break;
6220 case PHONE_FRAME:
6221 retval = set_base_frame(j, arg);
6222 break;
6223 case PHONE_REC_CODEC:
6224 retval = set_rec_codec(j, arg);
6225 break;
6226 case PHONE_VAD:
6227 ixj_vad(j, arg);
6228 break;
6229 case PHONE_REC_START:
6230 ixj_record_start(j);
6231 break;
6232 case PHONE_REC_STOP:
6233 ixj_record_stop(j);
6234 break;
6235 case PHONE_REC_DEPTH:
6236 set_rec_depth(j, arg);
6237 break;
6238 case PHONE_REC_VOLUME:
6239 if(arg == -1) {
6240 retval = get_rec_volume(j);
6241 }
6242 else {
6243 set_rec_volume(j, arg);
6244 retval = arg;
6245 }
6246 break;
6247 case PHONE_REC_VOLUME_LINEAR:
6248 if(arg == -1) {
6249 retval = get_rec_volume_linear(j);
6250 }
6251 else {
6252 set_rec_volume_linear(j, arg);
6253 retval = arg;
6254 }
6255 break;
6256 case IXJCTL_DTMF_PRESCALE:
6257 if(arg == -1) {
6258 retval = get_dtmf_prescale(j);
6259 }
6260 else {
6261 set_dtmf_prescale(j, arg);
6262 retval = arg;
6263 }
6264 break;
6265 case PHONE_REC_LEVEL:
6266 retval = get_rec_level(j);
6267 break;
6268 case IXJCTL_SC_RXG:
6269 retval = ixj_siadc(j, arg);
6270 break;
6271 case IXJCTL_SC_TXG:
6272 retval = ixj_sidac(j, arg);
6273 break;
6274 case IXJCTL_AEC_START:
6275 ixj_aec_start(j, arg);
6276 break;
6277 case IXJCTL_AEC_STOP:
6278 aec_stop(j);
6279 break;
6280 case IXJCTL_AEC_GET_LEVEL:
6281 retval = j->aec_level;
6282 break;
6283 case PHONE_PLAY_CODEC:
6284 retval = set_play_codec(j, arg);
6285 break;
6286 case PHONE_PLAY_START:
6287 retval = ixj_play_start(j);
6288 break;
6289 case PHONE_PLAY_STOP:
6290 ixj_play_stop(j);
6291 break;
6292 case PHONE_PLAY_DEPTH:
6293 set_play_depth(j, arg);
6294 break;
6295 case PHONE_PLAY_VOLUME:
6296 if(arg == -1) {
6297 retval = get_play_volume(j);
6298 }
6299 else {
6300 set_play_volume(j, arg);
6301 retval = arg;
6302 }
6303 break;
6304 case PHONE_PLAY_VOLUME_LINEAR:
6305 if(arg == -1) {
6306 retval = get_play_volume_linear(j);
6307 }
6308 else {
6309 set_play_volume_linear(j, arg);
6310 retval = arg;
6311 }
6312 break;
6313 case PHONE_PLAY_LEVEL:
6314 retval = get_play_level(j);
6315 break;
6316 case IXJCTL_DSP_TYPE:
6317 retval = (j->dsp.high << 8) + j->dsp.low;
6318 break;
6319 case IXJCTL_DSP_VERSION:
6320 retval = (j->ver.high << 8) + j->ver.low;
6321 break;
6322 case IXJCTL_HZ:
6323 hertz = arg;
6324 break;
6325 case IXJCTL_RATE:
6326 if (arg > hertz)
6327 retval = -1;
6328 else
6329 samplerate = arg;
6330 break;
6331 case IXJCTL_DRYBUFFER_READ:
6332 put_user(j->drybuffer, (unsigned long __user *) argp);
6333 break;
6334 case IXJCTL_DRYBUFFER_CLEAR:
6335 j->drybuffer = 0;
6336 break;
6337 case IXJCTL_FRAMES_READ:
6338 put_user(j->framesread, (unsigned long __user *) argp);
6339 break;
6340 case IXJCTL_FRAMES_WRITTEN:
6341 put_user(j->frameswritten, (unsigned long __user *) argp);
6342 break;
6343 case IXJCTL_READ_WAIT:
6344 put_user(j->read_wait, (unsigned long __user *) argp);
6345 break;
6346 case IXJCTL_WRITE_WAIT:
6347 put_user(j->write_wait, (unsigned long __user *) argp);
6348 break;
6349 case PHONE_MAXRINGS:
6350 j->maxrings = arg;
6351 break;
6352 case PHONE_SET_TONE_ON_TIME:
6353 ixj_set_tone_on(arg, j);
6354 break;
6355 case PHONE_SET_TONE_OFF_TIME:
6356 ixj_set_tone_off(arg, j);
6357 break;
6358 case PHONE_GET_TONE_ON_TIME:
6359 if (ixj_get_tone_on(j)) {
6360 retval = -1;
6361 } else {
6362 retval = (j->ssr.high << 8) + j->ssr.low;
6363 }
6364 break;
6365 case PHONE_GET_TONE_OFF_TIME:
6366 if (ixj_get_tone_off(j)) {
6367 retval = -1;
6368 } else {
6369 retval = (j->ssr.high << 8) + j->ssr.low;
6370 }
6371 break;
6372 case PHONE_PLAY_TONE:
6373 if (!j->tone_state)
6374 retval = ixj_play_tone(j, arg);
6375 else
6376 retval = -1;
6377 break;
6378 case PHONE_GET_TONE_STATE:
6379 retval = j->tone_state;
6380 break;
6381 case PHONE_DTMF_READY:
6382 retval = j->ex.bits.dtmf_ready;
6383 break;
6384 case PHONE_GET_DTMF:
6385 if (ixj_hookstate(j)) {
6386 if (j->dtmf_rp != j->dtmf_wp) {
6387 retval = j->dtmfbuffer[j->dtmf_rp];
6388 j->dtmf_rp++;
6389 if (j->dtmf_rp == 79)
6390 j->dtmf_rp = 0;
6391 if (j->dtmf_rp == j->dtmf_wp) {
6392 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6393 }
6394 }
6395 }
6396 break;
6397 case PHONE_GET_DTMF_ASCII:
6398 if (ixj_hookstate(j)) {
6399 if (j->dtmf_rp != j->dtmf_wp) {
6400 switch (j->dtmfbuffer[j->dtmf_rp]) {
6401 case 10:
6402 retval = 42; /* '*'; */
6403
6404 break;
6405 case 11:
6406 retval = 48; /*'0'; */
6407
6408 break;
6409 case 12:
6410 retval = 35; /*'#'; */
6411
6412 break;
6413 case 28:
6414 retval = 65; /*'A'; */
6415
6416 break;
6417 case 29:
6418 retval = 66; /*'B'; */
6419
6420 break;
6421 case 30:
6422 retval = 67; /*'C'; */
6423
6424 break;
6425 case 31:
6426 retval = 68; /*'D'; */
6427
6428 break;
6429 default:
6430 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6431 break;
6432 }
6433 j->dtmf_rp++;
6434 if (j->dtmf_rp == 79)
6435 j->dtmf_rp = 0;
6436 if(j->dtmf_rp == j->dtmf_wp)
6437 {
6438 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6439 }
6440 }
6441 }
6442 break;
6443 case PHONE_DTMF_OOB:
6444 j->flags.dtmf_oob = arg;
6445 break;
6446 case PHONE_DIALTONE:
6447 ixj_dialtone(j);
6448 break;
6449 case PHONE_BUSY:
6450 ixj_busytone(j);
6451 break;
6452 case PHONE_RINGBACK:
6453 ixj_ringback(j);
6454 break;
6455 case PHONE_WINK:
6456 if(j->cardtype == QTI_PHONEJACK)
6457 retval = -1;
6458 else
6459 retval = ixj_wink(j);
6460 break;
6461 case PHONE_CPT_STOP:
6462 ixj_cpt_stop(j);
6463 break;
6464 case PHONE_QUERY_CODEC:
6465 {
6466 struct phone_codec_data pd;
6467 int val;
6468 int proto_size[] = {
6469 -1,
6470 12, 10, 16, 9, 8, 48, 5,
6471 40, 40, 80, 40, 40, 6
6472 };
6473 if(copy_from_user(&pd, argp, sizeof(pd))) {
6474 retval = -EFAULT;
6475 break;
6476 }
6477 if(pd.type<1 || pd.type>13) {
6478 retval = -EPROTONOSUPPORT;
6479 break;
6480 }
6481 if(pd.type<G729)
6482 val=proto_size[pd.type];
6483 else switch(j->baseframe.low)
6484 {
6485 case 0xA0:val=2*proto_size[pd.type];break;
6486 case 0x50:val=proto_size[pd.type];break;
6487 default:val=proto_size[pd.type]*3;break;
6488 }
6489 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6490 if(copy_to_user(argp, &pd, sizeof(pd)))
6491 retval = -EFAULT;
6492 break;
6493 }
6494 case IXJCTL_DSP_IDLE:
6495 idle(j);
6496 break;
6497 case IXJCTL_MIXER:
6498 if ((arg & 0xff) == 0xff)
6499 retval = ixj_get_mixer(arg, j);
6500 else
6501 ixj_mixer(arg, j);
6502 break;
6503 case IXJCTL_DAA_COEFF_SET:
6504 switch (arg) {
6505 case DAA_US:
6506 DAA_Coeff_US(j);
6507 retval = ixj_daa_write(j);
6508 break;
6509 case DAA_UK:
6510 DAA_Coeff_UK(j);
6511 retval = ixj_daa_write(j);
6512 break;
6513 case DAA_FRANCE:
6514 DAA_Coeff_France(j);
6515 retval = ixj_daa_write(j);
6516 break;
6517 case DAA_GERMANY:
6518 DAA_Coeff_Germany(j);
6519 retval = ixj_daa_write(j);
6520 break;
6521 case DAA_AUSTRALIA:
6522 DAA_Coeff_Australia(j);
6523 retval = ixj_daa_write(j);
6524 break;
6525 case DAA_JAPAN:
6526 DAA_Coeff_Japan(j);
6527 retval = ixj_daa_write(j);
6528 break;
6529 default:
6530 retval = 1;
6531 break;
6532 }
6533 break;
6534 case IXJCTL_DAA_AGAIN:
6535 ixj_daa_cr4(j, arg | 0x02);
6536 break;
6537 case IXJCTL_PSTN_LINETEST:
6538 retval = ixj_linetest(j);
6539 break;
6540 case IXJCTL_VMWI:
6541 ixj_write_vmwi(j, arg);
6542 break;
6543 case IXJCTL_CID:
6544 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6545 retval = -EFAULT;
6546 j->ex.bits.caller_id = 0;
6547 break;
6548 case IXJCTL_WINK_DURATION:
6549 j->winktime = arg;
6550 break;
6551 case IXJCTL_PORT:
6552 if (arg)
6553 retval = ixj_set_port(j, arg);
6554 else
6555 retval = j->port;
6556 break;
6557 case IXJCTL_POTS_PSTN:
6558 retval = ixj_set_pots(j, arg);
6559 break;
6560 case PHONE_CAPABILITIES:
6561 add_caps(j);
6562 retval = j->caps;
6563 break;
6564 case PHONE_CAPABILITIES_LIST:
6565 add_caps(j);
6566 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6567 retval = -EFAULT;
6568 break;
6569 case PHONE_CAPABILITIES_CHECK:
6570 {
6571 struct phone_capability cap;
6572 if (copy_from_user(&cap, argp, sizeof(cap)))
6573 retval = -EFAULT;
6574 else {
6575 add_caps(j);
6576 retval = capabilities_check(j, &cap);
6577 }
6578 }
6579 break;
6580 case PHONE_PSTN_SET_STATE:
6581 daa_set_mode(j, arg);
6582 break;
6583 case PHONE_PSTN_GET_STATE:
6584 retval = j->daa_mode;
6585 j->ex.bits.pstn_ring = 0;
6586 break;
6587 case IXJCTL_SET_FILTER:
6588 if (copy_from_user(&jf, argp, sizeof(jf)))
6589 retval = -EFAULT;
6590 retval = ixj_init_filter(j, &jf);
6591 break;
6592 case IXJCTL_SET_FILTER_RAW:
6593 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6594 retval = -EFAULT;
6595 else
6596 retval = ixj_init_filter_raw(j, &jfr);
6597 break;
6598 case IXJCTL_GET_FILTER_HIST:
6599 if(arg<0||arg>3)
6600 retval = -EINVAL;
6601 else
6602 retval = j->filter_hist[arg];
6603 break;
6604 case IXJCTL_INIT_TONE:
6605 if (copy_from_user(&ti, argp, sizeof(ti)))
6606 retval = -EFAULT;
6607 else
6608 retval = ixj_init_tone(j, &ti);
6609 break;
6610 case IXJCTL_TONE_CADENCE:
6611 retval = ixj_build_cadence(j, argp);
6612 break;
6613 case IXJCTL_FILTER_CADENCE:
6614 retval = ixj_build_filter_cadence(j, argp);
6615 break;
6616 case IXJCTL_SIGCTL:
6617 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6618 retval = -EFAULT;
6619 break;
6620 }
6621 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6622 if(j->sigdef.event < 33) {
6623 raise = 1;
6624 for(mant = 0; mant < j->sigdef.event; mant++){
6625 raise *= 2;
6626 }
6627 if(j->sigdef.signal)
6628 j->ex_sig.bytes |= raise;
6629 else
6630 j->ex_sig.bytes &= (raise^0xffff);
6631 }
6632 break;
6633 case IXJCTL_INTERCOM_STOP:
6634 if(arg < 0 || arg >= IXJMAX)
6635 return -EINVAL;
6636 j->intercom = -1;
6637 ixj_record_stop(j);
6638 ixj_play_stop(j);
6639 idle(j);
6640 get_ixj(arg)->intercom = -1;
6641 ixj_record_stop(get_ixj(arg));
6642 ixj_play_stop(get_ixj(arg));
6643 idle(get_ixj(arg));
6644 break;
6645 case IXJCTL_INTERCOM_START:
6646 if(arg < 0 || arg >= IXJMAX)
6647 return -EINVAL;
6648 j->intercom = arg;
6649 ixj_record_start(j);
6650 ixj_play_start(j);
6651 get_ixj(arg)->intercom = board;
6652 ixj_play_start(get_ixj(arg));
6653 ixj_record_start(get_ixj(arg));
6654 break;
6655 }
6656 if (ixjdebug & 0x0040)
6657 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6658 clear_bit(board, &j->busyflags);
6659 return retval;
6660}
6661
6662static int ixj_fasync(int fd, struct file *file_p, int mode)
6663{
6664 IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6665
6666 return fasync_helper(fd, file_p, mode, &j->async_queue);
6667}
6668
6669static struct file_operations ixj_fops =
6670{
6671 .owner = THIS_MODULE,
6672 .read = ixj_enhanced_read,
6673 .write = ixj_enhanced_write,
6674 .poll = ixj_poll,
6675 .ioctl = ixj_ioctl,
6676 .release = ixj_release,
6677 .fasync = ixj_fasync
6678};
6679
6680static int ixj_linetest(IXJ *j)
6681{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6682 j->flags.pstncheck = 1; /* Testing */
6683 j->flags.pstn_present = 0; /* Assume the line is not there */
6684
6685 daa_int_read(j); /*Clear DAA Interrupt flags */
6686 /* */
6687 /* Hold all relays in the normally de-energized position. */
6688 /* */
6689
6690 j->pld_slicw.bits.rly1 = 0;
6691 j->pld_slicw.bits.rly2 = 0;
6692 j->pld_slicw.bits.rly3 = 0;
6693 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6694 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6695
6696 outb_p(j->pld_scrw.byte, j->XILINXbase);
6697 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6698 if (j->pld_slicr.bits.potspstn) {
6699 j->flags.pots_pstn = 1;
6700 j->flags.pots_correct = 0;
6701 LED_SetState(0x4, j);
6702 } else {
6703 j->flags.pots_pstn = 0;
6704 j->pld_slicw.bits.rly1 = 0;
6705 j->pld_slicw.bits.rly2 = 0;
6706 j->pld_slicw.bits.rly3 = 1;
6707 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6708 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6709
6710 outb_p(j->pld_scrw.byte, j->XILINXbase);
6711 daa_set_mode(j, SOP_PU_CONVERSATION);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6712 msleep(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6713 daa_int_read(j);
6714 daa_set_mode(j, SOP_PU_RESET);
6715 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6716 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6717 LED_SetState(0x4, j);
6718 j->pld_slicw.bits.rly3 = 0;
6719 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6720 } else {
6721 j->flags.pots_correct = 1;
6722 LED_SetState(0x8, j);
6723 j->pld_slicw.bits.rly1 = 1;
6724 j->pld_slicw.bits.rly2 = 0;
6725 j->pld_slicw.bits.rly3 = 0;
6726 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6727 }
6728 }
6729 j->pld_slicw.bits.rly3 = 0;
6730 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6731 daa_set_mode(j, SOP_PU_CONVERSATION);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6732 msleep(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6733 daa_int_read(j);
6734 daa_set_mode(j, SOP_PU_RESET);
6735 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6736 j->pstn_sleeptil = jiffies + (hertz / 4);
6737 j->flags.pstn_present = 1;
6738 } else {
6739 j->flags.pstn_present = 0;
6740 }
6741 if (j->flags.pstn_present) {
6742 if (j->flags.pots_correct) {
6743 LED_SetState(0xA, j);
6744 } else {
6745 LED_SetState(0x6, j);
6746 }
6747 } else {
6748 if (j->flags.pots_correct) {
6749 LED_SetState(0x9, j);
6750 } else {
6751 LED_SetState(0x5, j);
6752 }
6753 }
6754 j->flags.pstncheck = 0; /* Testing */
6755 return j->flags.pstn_present;
6756}
6757
6758static int ixj_selfprobe(IXJ *j)
6759{
6760 unsigned short cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6761 int cnt;
6762 BYTES bytes;
6763
6764 init_waitqueue_head(&j->poll_q);
6765 init_waitqueue_head(&j->read_q);
6766 init_waitqueue_head(&j->write_q);
6767
6768 while(atomic_read(&j->DSPWrite) > 0)
6769 atomic_dec(&j->DSPWrite);
6770 if (ixjdebug & 0x0002)
6771 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6772 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6773
6774 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6775 return -1;
6776/* The read values of the SSR should be 0x00 for the IDLE command */
6777 if (j->ssr.low || j->ssr.high)
6778 return -1;
6779 if (ixjdebug & 0x0002)
6780 printk(KERN_INFO "Get Device ID Code\n");
6781 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6782 return -1;
6783 j->dsp.low = j->ssr.low;
6784 j->dsp.high = j->ssr.high;
6785 if (ixjdebug & 0x0002)
6786 printk(KERN_INFO "Get Device Version Code\n");
6787 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6788 return -1;
6789 j->ver.low = j->ssr.low;
6790 j->ver.high = j->ssr.high;
6791 if (!j->cardtype) {
6792 if (j->dsp.low == 0x21) {
6793 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6794 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6795/* Test for Internet LineJACK or Internet PhoneJACK Lite */
6796 bytes.low = inb_p(j->XILINXbase + 0x02);
6797 if (bytes.low == bytes.high) /* Register is read only on */
6798 /* Internet PhoneJack Lite */
6799 {
6800 j->cardtype = QTI_PHONEJACK_LITE;
6801 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6802 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6803 return -1;
6804 }
6805 j->pld_slicw.pcib.e1 = 1;
6806 outb_p(j->pld_slicw.byte, j->XILINXbase);
6807 } else {
6808 j->cardtype = QTI_LINEJACK;
6809
6810 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6811 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6812 return -1;
6813 }
6814 }
6815 } else if (j->dsp.low == 0x22) {
6816 j->cardtype = QTI_PHONEJACK_PCI;
6817 request_region(j->XILINXbase, 4, "ixj control");
6818 j->pld_slicw.pcib.e1 = 1;
6819 outb_p(j->pld_slicw.byte, j->XILINXbase);
6820 } else
6821 j->cardtype = QTI_PHONEJACK;
6822 } else {
6823 switch (j->cardtype) {
6824 case QTI_PHONEJACK:
6825 if (!j->dsp.low != 0x20) {
6826 j->dsp.high = 0x80;
6827 j->dsp.low = 0x20;
6828 ixj_WriteDSPCommand(0x3800, j);
6829 j->ver.low = j->ssr.low;
6830 j->ver.high = j->ssr.high;
6831 }
6832 break;
6833 case QTI_LINEJACK:
6834 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6835 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6836 return -1;
6837 }
6838 break;
6839 case QTI_PHONEJACK_LITE:
6840 case QTI_PHONEJACK_PCI:
6841 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6842 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6843 return -1;
6844 }
6845 j->pld_slicw.pcib.e1 = 1;
6846 outb_p(j->pld_slicw.byte, j->XILINXbase);
6847 break;
6848 case QTI_PHONECARD:
6849 break;
6850 }
6851 }
6852 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6853 if (ixjdebug & 0x0002)
6854 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6855 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6856 return -1;
6857 if (ixjdebug & 0x0002)
6858 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6859 if (j->cardtype == QTI_PHONEJACK) {
6860 cmd = 0x9FF2;
6861 } else {
6862 cmd = 0x9FF5;
6863 }
6864 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6865 return -1;
6866 } else {
6867 if (set_base_frame(j, 30) != 30)
6868 return -1;
6869 if (ixjdebug & 0x0002)
6870 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6871 if (j->cardtype == QTI_PHONECARD) {
6872 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6873 return -1;
6874 }
6875 if (j->cardtype == QTI_LINEJACK) {
6876 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6877 return -1;
6878 if (ixjdebug & 0x0002)
6879 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6880 j->pld_clock.byte = 0;
6881 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6882 }
6883 }
6884
6885 if (j->dsp.low == 0x20) {
6886 if (ixjdebug & 0x0002)
6887 printk(KERN_INFO "Configure GPIO pins\n");
6888 j->gpio.bytes.high = 0x09;
6889/* bytes.low = 0xEF; 0xF7 */
6890 j->gpio.bits.gpio1 = 1;
6891 j->gpio.bits.gpio2 = 1;
6892 j->gpio.bits.gpio3 = 0;
6893 j->gpio.bits.gpio4 = 1;
6894 j->gpio.bits.gpio5 = 1;
6895 j->gpio.bits.gpio6 = 1;
6896 j->gpio.bits.gpio7 = 1;
6897 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6898 if (ixjdebug & 0x0002)
6899 printk(KERN_INFO "Enable SLIC\n");
6900 j->gpio.bytes.high = 0x0B;
6901 j->gpio.bytes.low = 0x00;
6902 j->gpio.bits.gpio1 = 0;
6903 j->gpio.bits.gpio2 = 1;
6904 j->gpio.bits.gpio5 = 0;
6905 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6906 j->port = PORT_POTS;
6907 } else {
6908 if (j->cardtype == QTI_LINEJACK) {
6909 LED_SetState(0x1, j);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6910 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6911 LED_SetState(0x2, j);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6912 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6913 LED_SetState(0x4, j);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6914 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6915 LED_SetState(0x8, j);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6916 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6917 LED_SetState(0x0, j);
6918 daa_get_version(j);
6919 if (ixjdebug & 0x0002)
6920 printk("Loading DAA Coefficients\n");
6921 DAA_Coeff_US(j);
6922 if (!ixj_daa_write(j)) {
6923 printk("DAA write failed on board %d\n", j->board);
6924 return -1;
6925 }
6926 if(!ixj_daa_cid_reset(j)) {
6927 printk("DAA CID reset failed on board %d\n", j->board);
6928 return -1;
6929 }
6930 j->flags.pots_correct = 0;
6931 j->flags.pstn_present = 0;
6932 ixj_linetest(j);
6933 if (j->flags.pots_correct) {
6934 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6935
6936 outb_p(j->pld_scrw.byte, j->XILINXbase);
6937 j->pld_slicw.bits.rly1 = 1;
6938 j->pld_slicw.bits.spken = 1;
6939 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6940 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6941/* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6942 j->port = PORT_POTS;
6943 }
6944 ixj_set_port(j, PORT_PSTN);
6945 ixj_set_pots(j, 1);
6946 if (ixjdebug & 0x0002)
6947 printk(KERN_INFO "Enable Mixer\n");
6948 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6949 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6950
6951 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6952 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6953
6954 ixj_mixer(0x0480, j); /*FM Left mute */
6955 ixj_mixer(0x0580, j); /*FM Right mute */
6956
6957 ixj_mixer(0x0680, j); /*CD Left mute */
6958 ixj_mixer(0x0780, j); /*CD Right mute */
6959
6960 ixj_mixer(0x0880, j); /*Line Left mute */
6961 ixj_mixer(0x0980, j); /*Line Right mute */
6962
6963 ixj_mixer(0x0A80, j); /*Aux left mute */
6964 ixj_mixer(0x0B80, j); /*Aux right mute */
6965
6966 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6967 ixj_mixer(0x0D80, j); /*Mono2 mute */
6968
6969 ixj_mixer(0x0E80, j); /*Mic mute */
6970
6971 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6972
6973 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6974 ixj_mixer(0x110C, j);
6975
6976
6977 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6978 ixj_mixer(0x1401, j);
6979
6980 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6981 ixj_mixer(0x1501, j);
6982
6983 ixj_mixer(0x1700, j); /*Clock select */
6984
6985 ixj_mixer(0x1800, j); /*ADC input from mixer */
6986
6987 ixj_mixer(0x1901, j); /*Mic gain 30db */
6988
6989 if (ixjdebug & 0x0002)
6990 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6991 j->cadence_f[4].state = 0;
6992 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
6993 j->cadence_f[4].off1 = 0;
6994 j->cadence_f[4].on2 = 0;
6995 j->cadence_f[4].off2 = 0;
6996 j->cadence_f[4].on3 = 0;
6997 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
6998 j->pstn_last_rmr = jiffies;
6999
7000 } else {
7001 if (j->cardtype == QTI_PHONECARD) {
7002 ixj_WriteDSPCommand(0xCF07, j);
7003 ixj_WriteDSPCommand(0x00B0, j);
7004 ixj_set_port(j, PORT_SPEAKER);
7005 } else {
7006 ixj_set_port(j, PORT_POTS);
7007 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7008/* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7009 }
7010 }
7011 }
7012
7013 j->intercom = -1;
7014 j->framesread = j->frameswritten = 0;
7015 j->read_wait = j->write_wait = 0;
7016 j->rxreadycheck = j->txreadycheck = 0;
7017
7018 /* initialise the DTMF prescale to a sensible value */
7019 if (j->cardtype == QTI_LINEJACK) {
7020 set_dtmf_prescale(j, 0x10);
7021 } else {
7022 set_dtmf_prescale(j, 0x40);
7023 }
7024 set_play_volume(j, 0x100);
7025 set_rec_volume(j, 0x100);
7026
7027 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7028 return -1;
7029/* The read values of the SSR should be 0x00 for the IDLE command */
7030 if (j->ssr.low || j->ssr.high)
7031 return -1;
7032
7033 if (ixjdebug & 0x0002)
7034 printk(KERN_INFO "Enable Line Monitor\n");
7035
7036 if (ixjdebug & 0x0002)
7037 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7038
7039 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7040 return -1;
7041
7042 if (ixjdebug & 0x002)
7043 printk(KERN_INFO "Enable DTMF Detectors\n");
7044
7045 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7046 return -1;
7047
7048 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7049 return -1;
7050
7051 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7052
7053 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7054
7055 j->ex.bits.dtmf_ready = 0;
7056 j->dtmf_state = 0;
7057 j->dtmf_wp = j->dtmf_rp = 0;
7058 j->rec_mode = j->play_mode = -1;
7059 j->flags.ringing = 0;
7060 j->maxrings = MAXRINGS;
7061 j->ring_cadence = USA_RING_CADENCE;
7062 j->drybuffer = 0;
7063 j->winktime = 320;
7064 j->flags.dtmf_oob = 0;
7065 for (cnt = 0; cnt < 4; cnt++)
7066 j->cadence_f[cnt].enable = 0;
7067 /* must be a device on the specified address */
7068 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7069
7070 /* Set up the default signals for events */
7071 for (cnt = 0; cnt < 35; cnt++)
7072 j->ixj_signals[cnt] = SIGIO;
7073
7074 /* Set the excetion signal enable flags */
7075 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7076 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 =
7077 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;
7078#ifdef IXJ_DYN_ALLOC
7079 j->fskdata = NULL;
7080#endif
7081 j->fskdcnt = 0;
7082 j->cidcw_wait = 0;
7083
7084 /* Register with the Telephony for Linux subsystem */
7085 j->p.f_op = &ixj_fops;
7086 j->p.open = ixj_open;
7087 j->p.board = j->board;
7088 phone_register_device(&j->p, PHONE_UNIT_ANY);
7089
7090 ixj_init_timer(j);
7091 ixj_add_timer(j);
7092 return 0;
7093}
7094
7095/*
7096 * Exported service for pcmcia card handling
7097 */
7098
7099IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7100{
7101 IXJ *j = ixj_alloc();
7102
7103 j->board = 0;
7104
7105 j->DSPbase = dsp;
7106 j->XILINXbase = xilinx;
7107 j->cardtype = QTI_PHONECARD;
7108 ixj_selfprobe(j);
7109 return j;
7110}
7111
7112EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7113
7114static int ixj_get_status_proc(char *buf)
7115{
7116 int len;
7117 int cnt;
7118 IXJ *j;
7119 len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7120 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7121 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7122 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7123 len += sprintf(buf + len, "\nUsing old telephony API");
7124 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7125
7126 for (cnt = 0; cnt < IXJMAX; cnt++) {
7127 j = get_ixj(cnt);
7128 if(j==NULL)
7129 continue;
7130 if (j->DSPbase) {
7131 len += sprintf(buf + len, "\nCard Num %d", cnt);
7132 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7133 if (j->cardtype != QTI_PHONEJACK)
7134 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7135 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7136 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7137 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7138 switch (j->cardtype) {
7139 case (QTI_PHONEJACK):
7140 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7141 break;
7142 case (QTI_LINEJACK):
7143 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7144 if (j->flags.g729_loaded)
7145 len += sprintf(buf + len, " w/G.729 A/B");
7146 len += sprintf(buf + len, " Country = %d", j->daa_country);
7147 break;
7148 case (QTI_PHONEJACK_LITE):
7149 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7150 if (j->flags.g729_loaded)
7151 len += sprintf(buf + len, " w/G.729 A/B");
7152 break;
7153 case (QTI_PHONEJACK_PCI):
7154 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7155 if (j->flags.g729_loaded)
7156 len += sprintf(buf + len, " w/G.729 A/B");
7157 break;
7158 case (QTI_PHONECARD):
7159 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7160 if (j->flags.g729_loaded)
7161 len += sprintf(buf + len, " w/G.729 A/B");
7162 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7163 if (!j->pccr1.bits.drf)
7164 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7165 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7166 break;
7167 default:
7168 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7169 break;
7170 }
7171 len += sprintf(buf + len, "\nReaders %d", j->readers);
7172 len += sprintf(buf + len, "\nWriters %d", j->writers);
7173 add_caps(j);
7174 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7175 if (j->dsp.low != 0x20)
7176 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7177 if (j->flags.cidsent)
7178 len += sprintf(buf + len, "\nCaller ID data sent");
7179 else
7180 len += sprintf(buf + len, "\nCaller ID data not sent");
7181
7182 len += sprintf(buf + len, "\nPlay CODEC ");
7183 switch (j->play_codec) {
7184 case G723_63:
7185 len += sprintf(buf + len, "G.723.1 6.3");
7186 break;
7187 case G723_53:
7188 len += sprintf(buf + len, "G.723.1 5.3");
7189 break;
7190 case TS85:
7191 len += sprintf(buf + len, "TrueSpeech 8.5");
7192 break;
7193 case TS48:
7194 len += sprintf(buf + len, "TrueSpeech 4.8");
7195 break;
7196 case TS41:
7197 len += sprintf(buf + len, "TrueSpeech 4.1");
7198 break;
7199 case G728:
7200 len += sprintf(buf + len, "G.728");
7201 break;
7202 case G729:
7203 len += sprintf(buf + len, "G.729");
7204 break;
7205 case G729B:
7206 len += sprintf(buf + len, "G.729B");
7207 break;
7208 case ULAW:
7209 len += sprintf(buf + len, "uLaw");
7210 break;
7211 case ALAW:
7212 len += sprintf(buf + len, "aLaw");
7213 break;
7214 case LINEAR16:
7215 len += sprintf(buf + len, "16 bit Linear");
7216 break;
7217 case LINEAR8:
7218 len += sprintf(buf + len, "8 bit Linear");
7219 break;
7220 case WSS:
7221 len += sprintf(buf + len, "Windows Sound System");
7222 break;
7223 default:
7224 len += sprintf(buf + len, "NO CODEC CHOSEN");
7225 break;
7226 }
7227 len += sprintf(buf + len, "\nRecord CODEC ");
7228 switch (j->rec_codec) {
7229 case G723_63:
7230 len += sprintf(buf + len, "G.723.1 6.3");
7231 break;
7232 case G723_53:
7233 len += sprintf(buf + len, "G.723.1 5.3");
7234 break;
7235 case TS85:
7236 len += sprintf(buf + len, "TrueSpeech 8.5");
7237 break;
7238 case TS48:
7239 len += sprintf(buf + len, "TrueSpeech 4.8");
7240 break;
7241 case TS41:
7242 len += sprintf(buf + len, "TrueSpeech 4.1");
7243 break;
7244 case G728:
7245 len += sprintf(buf + len, "G.728");
7246 break;
7247 case G729:
7248 len += sprintf(buf + len, "G.729");
7249 break;
7250 case G729B:
7251 len += sprintf(buf + len, "G.729B");
7252 break;
7253 case ULAW:
7254 len += sprintf(buf + len, "uLaw");
7255 break;
7256 case ALAW:
7257 len += sprintf(buf + len, "aLaw");
7258 break;
7259 case LINEAR16:
7260 len += sprintf(buf + len, "16 bit Linear");
7261 break;
7262 case LINEAR8:
7263 len += sprintf(buf + len, "8 bit Linear");
7264 break;
7265 case WSS:
7266 len += sprintf(buf + len, "Windows Sound System");
7267 break;
7268 default:
7269 len += sprintf(buf + len, "NO CODEC CHOSEN");
7270 break;
7271 }
7272 len += sprintf(buf + len, "\nAEC ");
7273 switch (j->aec_level) {
7274 case AEC_OFF:
7275 len += sprintf(buf + len, "Off");
7276 break;
7277 case AEC_LOW:
7278 len += sprintf(buf + len, "Low");
7279 break;
7280 case AEC_MED:
7281 len += sprintf(buf + len, "Med");
7282 break;
7283 case AEC_HIGH:
7284 len += sprintf(buf + len, "High");
7285 break;
7286 case AEC_AUTO:
7287 len += sprintf(buf + len, "Auto");
7288 break;
7289 case AEC_AGC:
7290 len += sprintf(buf + len, "AEC/AGC");
7291 break;
7292 default:
7293 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7294 break;
7295 }
7296
7297 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7298 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7299 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7300
7301 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7302
7303 if (j->cardtype == QTI_LINEJACK) {
7304 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7305 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7306 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7307 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7308 switch (j->daa_mode) {
7309 case SOP_PU_SLEEP:
7310 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7311 break;
7312 case SOP_PU_RINGING:
7313 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7314 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7315 break;
7316 case SOP_PU_CONVERSATION:
7317 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7318 break;
7319 case SOP_PU_PULSEDIALING:
7320 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7321 break;
7322 }
7323 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7324 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7325 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7326 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7327 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7328 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7329 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7330 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7331 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7332 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7333 }
7334 switch (j->port) {
7335 case PORT_POTS:
7336 len += sprintf(buf + len, "\nPort POTS");
7337 break;
7338 case PORT_PSTN:
7339 len += sprintf(buf + len, "\nPort PSTN");
7340 break;
7341 case PORT_SPEAKER:
7342 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7343 break;
7344 case PORT_HANDSET:
7345 len += sprintf(buf + len, "\nPort HANDSET");
7346 break;
7347 }
7348 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7349 len += sprintf(buf + len, "\nSLIC state ");
7350 switch (SLIC_GetState(j)) {
7351 case PLD_SLIC_STATE_OC:
7352 len += sprintf(buf + len, "OC");
7353 break;
7354 case PLD_SLIC_STATE_RINGING:
7355 len += sprintf(buf + len, "RINGING");
7356 break;
7357 case PLD_SLIC_STATE_ACTIVE:
7358 len += sprintf(buf + len, "ACTIVE");
7359 break;
7360 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7361 len += sprintf(buf + len, "OHT");
7362 break;
7363 case PLD_SLIC_STATE_TIPOPEN:
7364 len += sprintf(buf + len, "TIPOPEN");
7365 break;
7366 case PLD_SLIC_STATE_STANDBY:
7367 len += sprintf(buf + len, "STANDBY");
7368 break;
7369 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7370 len += sprintf(buf + len, "APR");
7371 break;
7372 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7373 len += sprintf(buf + len, "OHTPR");
7374 break;
7375 default:
7376 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7377 break;
7378 }
7379 }
7380 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7381 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7382#ifdef PERFMON_STATS
7383 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7384 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7385 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7386 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7387 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7388 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7389 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7390 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7391 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7392 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7393 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7394 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7395 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7396 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7397
7398#endif
7399 len += sprintf(buf + len, "\n");
7400 }
7401 }
7402 return len;
7403}
7404
7405static int ixj_read_proc(char *page, char **start, off_t off,
7406 int count, int *eof, void *data)
7407{
7408 int len = ixj_get_status_proc(page);
7409 if (len <= off+count) *eof = 1;
7410 *start = page + off;
7411 len -= off;
7412 if (len>count) len = count;
7413 if (len<0) len = 0;
7414 return len;
7415}
7416
7417
7418static void cleanup(void)
7419{
7420 int cnt;
7421 IXJ *j;
7422
7423 for (cnt = 0; cnt < IXJMAX; cnt++) {
7424 j = get_ixj(cnt);
7425 if(j != NULL && j->DSPbase) {
7426 if (ixjdebug & 0x0002)
7427 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7428 del_timer(&j->timer);
7429 if (j->cardtype == QTI_LINEJACK) {
7430 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7431
7432 outb_p(j->pld_scrw.byte, j->XILINXbase);
7433 j->pld_slicw.bits.rly1 = 0;
7434 j->pld_slicw.bits.rly2 = 0;
7435 j->pld_slicw.bits.rly3 = 0;
7436 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7437 LED_SetState(0x0, j);
7438 if (ixjdebug & 0x0002)
7439 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7440 release_region(j->XILINXbase, 8);
7441 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7442 if (ixjdebug & 0x0002)
7443 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7444 release_region(j->XILINXbase, 4);
7445 }
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]7446 kfree(j->read_buffer);
7447 kfree(j->write_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7448 if (j->dev)
7449 pnp_device_detach(j->dev);
7450 if (ixjdebug & 0x0002)
7451 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7452 phone_unregister_device(&j->p);
7453 if (ixjdebug & 0x0002)
7454 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7455 release_region(j->DSPbase, 16);
7456#ifdef IXJ_DYN_ALLOC
7457 if (ixjdebug & 0x0002)
7458 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7459 kfree(j);
7460 ixj[cnt] = NULL;
7461#endif
7462 }
7463 }
7464 if (ixjdebug & 0x0002)
7465 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7466 remove_proc_entry ("ixj", NULL);
7467}
7468
7469/* Typedefs */
7470typedef struct {
7471 BYTE length;
7472 DWORD bits;
7473} DATABLOCK;
7474
7475static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7476{
7477 lastLCC = lastLCC & 0xfb;
7478 lastLCC = lastLCC | (byData ? 4 : 0);
7479 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7480
7481 mdelay(1);
7482 lastLCC = lastLCC | 0x01;
7483 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7484
7485 byData = byData << 1;
7486 lastLCC = lastLCC & 0xfe;
7487 mdelay(1);
7488 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7489
7490}
7491
7492static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7493{
7494 mdelay(1);
7495 lastLCC = lastLCC | 0x01;
7496 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7497
7498 lastLCC = lastLCC & 0xfe;
7499 mdelay(1);
7500 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7501
7502 return ((inb(wEEPROMAddress) >> 3) & 1);
7503}
7504
7505static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7506{
7507 BYTE lastLCC;
7508 WORD wEEPROMAddress = wAddress + 3;
7509 DWORD i;
7510 BYTE byResult;
7511 *pwResult = 0;
7512 lastLCC = inb(wEEPROMAddress);
7513 lastLCC = lastLCC | 0x02;
7514 lastLCC = lastLCC & 0xfe;
7515 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7516
7517 mdelay(1); /* delay */
7518
7519 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7520 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7521 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7522 for (i = 0; i < 8; i++) {
7523 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7524 wLoc <<= 1;
7525 }
7526
7527 for (i = 0; i < 16; i++) {
7528 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7529 *pwResult = (*pwResult << 1) | byResult;
7530 }
7531
7532 mdelay(1); /* another delay */
7533
7534 lastLCC = lastLCC & 0xfd;
7535 outb(lastLCC, wEEPROMAddress); /* negate CS */
7536
7537 return 0;
7538}
7539
7540static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7541{
7542 WORD wLo, wHi;
7543 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7544 return 0;
7545 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7546 return 0;
7547 return (((DWORD) wHi << 16) | wLo);
7548}
7549
7550static int dspio[IXJMAX + 1] =
7551{
7552 0,
7553};
7554static int xio[IXJMAX + 1] =
7555{
7556 0,
7557};
7558
7559module_param_array(dspio, int, NULL, 0);
7560module_param_array(xio, int, NULL, 0);
7561MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7562MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7563MODULE_LICENSE("GPL");
7564
7565static void __exit ixj_exit(void)
7566{
7567 cleanup();
7568}
7569
7570static IXJ *new_ixj(unsigned long port)
7571{
7572 IXJ *res;
7573 if (!request_region(port, 16, "ixj DSP")) {
7574 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7575 return NULL;
7576 }
7577 res = ixj_alloc();
7578 if (!res) {
7579 release_region(port, 16);
7580 printk(KERN_INFO "ixj: out of memory\n");
7581 return NULL;
7582 }
7583 res->DSPbase = port;
7584 return res;
7585}
7586
7587static int __init ixj_probe_isapnp(int *cnt)
7588{
7589 int probe = 0;
7590 int func = 0x110;
7591 struct pnp_dev *dev = NULL, *old_dev = NULL;
7592
7593 while (1) {
7594 do {
7595 IXJ *j;
7596 int result;
7597
7598 old_dev = dev;
7599 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7600 ISAPNP_FUNCTION(func), old_dev);
7601 if (!dev || !dev->card)
7602 break;
7603 result = pnp_device_attach(dev);
7604 if (result < 0) {
7605 printk("pnp attach failed %d \n", result);
7606 break;
7607 }
7608 if (pnp_activate_dev(dev) < 0) {
7609 printk("pnp activate failed (out of resources?)\n");
7610 pnp_device_detach(dev);
7611 return -ENOMEM;
7612 }
7613
7614 if (!pnp_port_valid(dev, 0)) {
7615 pnp_device_detach(dev);
7616 return -ENODEV;
7617 }
7618
7619 j = new_ixj(pnp_port_start(dev, 0));
7620 if (!j)
7621 break;
7622
7623 if (func != 0x110)
7624 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7625
7626 switch (func) {
7627 case (0x110):
7628 j->cardtype = QTI_PHONEJACK;
7629 break;
7630 case (0x310):
7631 j->cardtype = QTI_LINEJACK;
7632 break;
7633 case (0x410):
7634 j->cardtype = QTI_PHONEJACK_LITE;
7635 break;
7636 }
7637 j->board = *cnt;
7638 probe = ixj_selfprobe(j);
7639 if(!probe) {
7640 j->serial = dev->card->serial;
7641 j->dev = dev;
7642 switch (func) {
7643 case 0x110:
7644 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7645 break;
7646 case 0x310:
7647 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7648 break;
7649 case 0x410:
7650 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7651 break;
7652 }
7653 }
7654 ++*cnt;
7655 } while (dev);
7656 if (func == 0x410)
7657 break;
7658 if (func == 0x310)
7659 func = 0x410;
7660 if (func == 0x110)
7661 func = 0x310;
7662 dev = NULL;
7663 }
7664 return probe;
7665}
7666
7667static int __init ixj_probe_isa(int *cnt)
7668{
7669 int i, probe;
7670
7671 /* Use passed parameters for older kernels without PnP */
7672 for (i = 0; i < IXJMAX; i++) {
7673 if (dspio[i]) {
7674 IXJ *j = new_ixj(dspio[i]);
7675
7676 if (!j)
7677 break;
7678
7679 j->XILINXbase = xio[i];
7680 j->cardtype = 0;
7681
7682 j->board = *cnt;
7683 probe = ixj_selfprobe(j);
7684 j->dev = NULL;
7685 ++*cnt;
7686 }
7687 }
7688 return 0;
7689}
7690
7691static int __init ixj_probe_pci(int *cnt)
7692{
7693 struct pci_dev *pci = NULL;
7694 int i, probe = 0;
7695 IXJ *j = NULL;
7696
7697 for (i = 0; i < IXJMAX - *cnt; i++) {
7698 pci = pci_find_device(0x15E2, 0x0500, pci);
7699 if (!pci)
7700 break;
7701
7702 if (pci_enable_device(pci))
7703 break;
7704 j = new_ixj(pci_resource_start(pci, 0));
7705 if (!j)
7706 break;
7707
7708 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7709 j->XILINXbase = j->DSPbase + 0x10;
7710 j->cardtype = QTI_PHONEJACK_PCI;
7711 j->board = *cnt;
7712 probe = ixj_selfprobe(j);
7713 if (!probe)
7714 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7715 ++*cnt;
7716 }
7717 return probe;
7718}
7719
7720static int __init ixj_init(void)
7721{
7722 int cnt = 0;
7723 int probe = 0;
7724
7725 cnt = 0;
7726
7727 /* These might be no-ops, see above. */
7728 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7729 return probe;
7730 }
7731 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7732 return probe;
7733 }
7734 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7735 return probe;
7736 }
Domen Puncerfba478b2005-05-05 16:16:13 -0700[diff] [blame]7737 printk(KERN_INFO "ixj driver initialized.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7738 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7739 return probe;
7740}
7741
7742module_init(ixj_init);
7743module_exit(ixj_exit);
7744
7745static void DAA_Coeff_US(IXJ *j)
7746{
7747 int i;
7748
7749 j->daa_country = DAA_US;
7750 /*----------------------------------------------- */
7751 /* CAO */
7752 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7753 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7754 }
7755
7756/* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7757 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7758 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7759 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7760 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7761 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7762 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7763 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7764 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7765/* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7766 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7767 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7768 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7769 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7770 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7771 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7772 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7773 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7774/* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7775 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7776 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7777 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7778 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7779 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7780 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7781 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7782 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7783/* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7784 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7785 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7786 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7787 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7788 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7789 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7790 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7791 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7792/* Bytes for AX-filter (0A): 16,55,DD,CA */
7793 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7794 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7795 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7796 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7797/* Bytes for AR-filter (09): 52,D3,11,42 */
7798 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7799 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7800 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7801 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7802/* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7803 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7804 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7805 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7806 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7807 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7808 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7809 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7810 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7811/* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7812 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7813 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7814 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7815 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7816 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7817 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7818 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7819 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7820/* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7821 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7822 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7823 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7824 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7825 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7826 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7827 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7828 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7829/* ; (10K, 0.68uF) */
7830 /* */
7831 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7832 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7833 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7834 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7835 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7836 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7837 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7838 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7839 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7840 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7841 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7842 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7843 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7844 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7845 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7846 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7847 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7848 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7849
7850 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7851 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7852 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7853 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7854 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7855
7856 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7857/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7858/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7859/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7860/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7861/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7862/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7863/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7864/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7865 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7866/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7867/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7868/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7869/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7870/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7871/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7872/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7873/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7874/* */
7875 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7876/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7877/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7878/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7879/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7880
7881 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7882 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7883 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7884 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7885 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7886 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7887 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7888 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7889 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7890/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7891 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7892 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7893 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7894 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7895 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7896 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7897 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7898 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7899/* */
7900 /* ;CR Registers */
7901 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7902 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7903/* Config. Reg. 1 (dialing) (cr1):05 */
7904 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7905/* Config. Reg. 2 (caller ID) (cr2):04 */
7906 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7907/* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7908 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7909/* Config. Reg. 4 (analog gain) (cr4):02 */
7910 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7911 /* Config. Reg. 5 (Version) (cr5):02 */
7912 /* Config. Reg. 6 (Reserved) (cr6):00 */
7913 /* Config. Reg. 7 (Reserved) (cr7):00 */
7914 /* */
7915 /* ;xr Registers */
7916 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7917
7918 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7919 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7920
7921 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7922/* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7923 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7924/* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7925 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7926 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7927
7928 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7929/* Ext. Reg. 5 (Ring timer) (xr5):22 */
7930 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7931/* Ext. Reg. 6 (Power State) (xr6):00 */
7932 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7933/* Ext. Reg. 7 (Vdd) (xr7):40 */
7934 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7935 /* */
7936 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7937 /* 12,33,5A,C3 ; 770 Hz */
7938 /* 13,3C,5B,32 ; 852 Hz */
7939 /* 1D,1B,5C,CC ; 941 Hz */
7940
7941 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7942 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7943 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7944 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7945/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7946 /* EC,1D,52,22 ; 1336 Hz */
7947 /* AA,AC,51,D2 ; 1477 Hz */
7948 /* 9B,3B,51,25 ; 1633 Hz */
7949 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7950 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7951 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7952 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7953}
7954
7955static void DAA_Coeff_UK(IXJ *j)
7956{
7957 int i;
7958
7959 j->daa_country = DAA_UK;
7960 /*----------------------------------------------- */
7961 /* CAO */
7962 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7963 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7964 }
7965
7966/* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7967 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7968 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7969 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7970 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7971 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7972 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7973 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7974 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7975/* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7976 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7977 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7978 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7979 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7980 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7981 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7982 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7983 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7984/* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7985 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7986 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7987 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7988 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7989 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7990 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7991 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7992 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7993/* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
7994 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
7995 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
7996 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
7997 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
7998 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
7999 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8000 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8001 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8002/* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8003 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8004 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8005 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8006 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8007/* Bytes for AR-filter (09): E2,27,10,D6 */
8008 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8009 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8010 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8011 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8012/* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8013 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8014 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8015 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8016 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8017 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8018 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8019 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8020 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8021/* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8022 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8023 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8024 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8025 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8026 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8027 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8028 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8029 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8030/* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8031 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8032 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8033 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8034 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8035 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8036 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8037 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8038 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8039/* ; idle */
8040 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8041 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8042 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8043 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8044 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8045 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8046 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8047 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8048 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8049/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8050 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8051 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8052 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8053 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8054 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8055 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8056 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8057 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8058/* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8059 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8060 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8061 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8062 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8063/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8064 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8065 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8066 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8067 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8068 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8069 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8070 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8071 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8072/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8073 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8074 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8075 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8076 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8077 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8078 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8079 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8080 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8081/* ;CR Registers */
8082 /* Config. Reg. 0 (filters) (cr0):FF */
8083 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8084/* Config. Reg. 1 (dialing) (cr1):05 */
8085 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8086/* Config. Reg. 2 (caller ID) (cr2):04 */
8087 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8088/* Config. Reg. 3 (testloops) (cr3):00 ; */
8089 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8090/* Config. Reg. 4 (analog gain) (cr4):02 */
8091 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8092 /* Config. Reg. 5 (Version) (cr5):02 */
8093 /* Config. Reg. 6 (Reserved) (cr6):00 */
8094 /* Config. Reg. 7 (Reserved) (cr7):00 */
8095 /* ;xr Registers */
8096 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8097
8098 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8099 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8100
8101 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8102 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8103
8104 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8105/* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8106 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8107/* Ext. Reg. 4 (Cadence) (xr4):00 */
8108 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8109/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8110 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8111/* Ext. Reg. 6 (Power State) (xr6):00 */
8112 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8113/* Ext. Reg. 7 (Vdd) (xr7):46 */
8114 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8115 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8116 /* 12,33,5A,C3 ; 770 Hz */
8117 /* 13,3C,5B,32 ; 852 Hz */
8118 /* 1D,1B,5C,CC ; 941 Hz */
8119
8120 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8121 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8122 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8123 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8124/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8125 /* EC,1D,52,22 ; 1336 Hz */
8126 /* AA,AC,51,D2 ; 1477 Hz */
8127 /* 9B,3B,51,25 ; 1633 Hz */
8128 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8129 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8130 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8131 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8132}
8133
8134
8135static void DAA_Coeff_France(IXJ *j)
8136{
8137 int i;
8138
8139 j->daa_country = DAA_FRANCE;
8140 /*----------------------------------------------- */
8141 /* CAO */
8142 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8143 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8144 }
8145
8146/* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8147 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8148 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8149 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8150 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8151 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8152 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8153 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8154 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8155/* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8156 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8157 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8158 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8159 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8160 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8161 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8162 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8163 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8164/* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8165 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8166 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8167 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8168 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8169 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8170 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8171 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8172 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8173/* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8174 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8175 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8176 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8177 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8178 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8179 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8180 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8181 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8182/* Bytes for AX-filter (0A): 16,B5,DD,CA */
8183 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8184 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8185 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8186 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8187/* Bytes for AR-filter (09): 52,C7,10,D6 */
8188 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8189 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8190 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8191 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8192/* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8193 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8194 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8195 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8196 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8197 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8198 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8199 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8200 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8201/* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8202 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8203 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8204 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8205 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8206 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8207 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8208 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8209 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8210/* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8211 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8212 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8213 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8214 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8215 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8216 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8217 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8218 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8219/* ; idle */
8220 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8221 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8222 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8223 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8224 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8225 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8226 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8227 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8228 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8229/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8230 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8231 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8232 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8233 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8234 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8235 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8236 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8237 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8238/* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8239 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8240 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8241 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8242 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8243/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8244 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8245 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8246 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8247 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8248 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8249 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8250 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8251 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8252/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8253 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8254 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8255 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8256 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8257 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8258 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8259 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8260 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8261/* ;CR Registers */
8262 /* Config. Reg. 0 (filters) (cr0):FF */
8263 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8264/* Config. Reg. 1 (dialing) (cr1):05 */
8265 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8266/* Config. Reg. 2 (caller ID) (cr2):04 */
8267 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8268/* Config. Reg. 3 (testloops) (cr3):00 ; */
8269 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8270/* Config. Reg. 4 (analog gain) (cr4):02 */
8271 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8272 /* Config. Reg. 5 (Version) (cr5):02 */
8273 /* Config. Reg. 6 (Reserved) (cr6):00 */
8274 /* Config. Reg. 7 (Reserved) (cr7):00 */
8275 /* ;xr Registers */
8276 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8277
8278 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8279 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8280
8281 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8282 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8283
8284 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8285/* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8286 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8287/* Ext. Reg. 4 (Cadence) (xr4):00 */
8288 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8289/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8290 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8291/* Ext. Reg. 6 (Power State) (xr6):00 */
8292 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8293/* Ext. Reg. 7 (Vdd) (xr7):46 */
8294 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8295 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8296 /* 12,33,5A,C3 ; 770 Hz */
8297 /* 13,3C,5B,32 ; 852 Hz */
8298 /* 1D,1B,5C,CC ; 941 Hz */
8299
8300 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8301 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8302 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8303 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8304/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8305 /* EC,1D,52,22 ; 1336 Hz */
8306 /* AA,AC,51,D2 ; 1477 Hz */
8307 /* 9B,3B,51,25 ; 1633 Hz */
8308 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8309 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8310 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8311 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8312}
8313
8314
8315static void DAA_Coeff_Germany(IXJ *j)
8316{
8317 int i;
8318
8319 j->daa_country = DAA_GERMANY;
8320 /*----------------------------------------------- */
8321 /* CAO */
8322 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8323 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8324 }
8325
8326/* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8327 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8328 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8329 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8330 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8331 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8332 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8333 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8334 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8335/* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8336 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8337 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8338 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8339 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8340 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8341 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8342 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8343 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8344/* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8345 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8346 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8347 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8348 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8349 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8350 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8351 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8352 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8353/* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8354 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8355 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8356 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8357 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8358 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8359 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8360 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8361 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8362/* Bytes for AX-filter (0A): 72,D5,DD,CA */
8363 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8364 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8365 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8366 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8367/* Bytes for AR-filter (09): 72,42,13,4B */
8368 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8369 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8370 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8371 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8372/* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8373 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8374 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8375 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8376 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8377 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8378 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8379 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8380 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8381/* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8382 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8383 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8384 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8385 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8386 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8387 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8388 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8389 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8390/* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8391 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8392 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8393 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8394 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8395 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8396 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8397 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8398 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8399/* ; (10K, 0.68uF) */
8400 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8401 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8402 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8403 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8404 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8405 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8406 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8407 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8408 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8409/* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8410 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8411 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8412 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8413 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8414 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8415 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8416 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8417 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8418/* Levelmetering Ringing (0D):B2,45,0F,8E */
8419 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8420 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8421 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8422 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8423/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8424 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8425 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8426 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8427 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8428 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8429 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8430 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8431 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8432/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8433 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8434 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8435 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8436 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8437 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8438 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8439 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8440 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8441/* ;CR Registers */
8442 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8443 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8444/* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8445 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8446/* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8447 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8448/* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8449 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8450/* Config. Reg. 4 (analog gain) (cr4):02 */
8451 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8452 /* Config. Reg. 5 (Version) (cr5):02 */
8453 /* Config. Reg. 6 (Reserved) (cr6):00 */
8454 /* Config. Reg. 7 (Reserved) (cr7):00 */
8455 /* ;xr Registers */
8456 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8457
8458 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8459 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8460
8461 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8462 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8463
8464 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8465/* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8466 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8467/* Ext. Reg. 4 (Cadence) (xr4):00 */
8468 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8469/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8470 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8471/* Ext. Reg. 6 (Power State) (xr6):00 */
8472 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8473/* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8474 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8475 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8476 /* 12,33,5A,C3 ; 770 Hz */
8477 /* 13,3C,5B,32 ; 852 Hz */
8478 /* 1D,1B,5C,CC ; 941 Hz */
8479
8480 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8481 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8482 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8483 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8484/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8485 /* EC,1D,52,22 ; 1336 Hz */
8486 /* AA,AC,51,D2 ; 1477 Hz */
8487 /* 9B,3B,51,25 ; 1633 Hz */
8488 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8489 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8490 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8491 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8492}
8493
8494
8495static void DAA_Coeff_Australia(IXJ *j)
8496{
8497 int i;
8498
8499 j->daa_country = DAA_AUSTRALIA;
8500 /*----------------------------------------------- */
8501 /* CAO */
8502 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8503 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8504 }
8505
8506/* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8507 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8508 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8509 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8510 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8511 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8512 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8513 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8514 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8515/* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8516 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8517 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8518 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8519 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8520 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8521 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8522 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8523 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8524/* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8525 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8526 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8527 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8528 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8529 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8530 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8531 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8532 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8533/* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8534 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8535 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8536 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8537 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8538 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8539 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8540 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8541 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8542/* Bytes for AX-filter (0A): CB,45,DD,CA */
8543 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8544 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8545 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8546 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8547/* Bytes for AR-filter (09): 1B,67,10,D6 */
8548 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8549 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8550 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8551 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8552/* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8553 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8554 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8555 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8556 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8557 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8558 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8559 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8560 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8561/* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8562 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8563 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8564 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8565 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8566 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8567 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8568 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8569 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8570/* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8571 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8572 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8573 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8574 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8575 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8576 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8577 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8578 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8579/* ; idle */
8580 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8581 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8582 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8583 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8584 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8585 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8586 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8587 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8588 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8589/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8590 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8591 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8592 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8593 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8594 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8595 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8596 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8597 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8598/* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8599 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8600 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8601 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8602 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8603/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8604 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8605 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8606 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8607 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8608 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8609 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8610 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8611 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8612/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8613 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8614 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8615 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8616 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8617 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8618 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8619 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8620 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8621/* ;CR Registers */
8622 /* Config. Reg. 0 (filters) (cr0):FF */
8623 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8624/* Config. Reg. 1 (dialing) (cr1):05 */
8625 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8626/* Config. Reg. 2 (caller ID) (cr2):04 */
8627 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8628/* Config. Reg. 3 (testloops) (cr3):00 ; */
8629 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8630/* Config. Reg. 4 (analog gain) (cr4):02 */
8631 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8632 /* Config. Reg. 5 (Version) (cr5):02 */
8633 /* Config. Reg. 6 (Reserved) (cr6):00 */
8634 /* Config. Reg. 7 (Reserved) (cr7):00 */
8635 /* ;xr Registers */
8636 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8637
8638 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8639 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8640
8641 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8642 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8643
8644 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8645/* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8646 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8647/* Ext. Reg. 4 (Cadence) (xr4):00 */
8648 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8649/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8650 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8651/* Ext. Reg. 6 (Power State) (xr6):00 */
8652 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8653/* Ext. Reg. 7 (Vdd) (xr7):40 */
8654 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8655
8656 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8657 /* 12,33,5A,C3 ; 770 Hz */
8658 /* 13,3C,5B,32 ; 852 Hz */
8659 /* 1D,1B,5C,CC ; 941 Hz */
8660 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8661 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8662 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8663 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8664
8665 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8666 /* EC,1D,52,22 ; 1336 Hz */
8667 /* AA,AC,51,D2 ; 1477 Hz */
8668 /* 9B,3B,51,25 ; 1633 Hz */
8669 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8670 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8671 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8672 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8673}
8674
8675static void DAA_Coeff_Japan(IXJ *j)
8676{
8677 int i;
8678
8679 j->daa_country = DAA_JAPAN;
8680 /*----------------------------------------------- */
8681 /* CAO */
8682 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8683 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8684 }
8685
8686/* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8687 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8688 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8689 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8690 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8691 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8692 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8693 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8694 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8695/* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8696 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8697 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8698 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8699 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8700 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8701 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8702 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8703 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8704/* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8705 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8706 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8707 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8708 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8709 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8710 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8711 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8712 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8713/* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8714 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8715 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8716 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8717 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8718 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8719 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8720 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8721 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8722/* Bytes for AX-filter (0A): 51,C5,DD,CA */
8723 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8724 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8725 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8726 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8727/* Bytes for AR-filter (09): 25,A7,10,D6 */
8728 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8729 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8730 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8731 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8732/* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8733 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8734 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8735 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8736 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8737 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8738 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8739 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8740 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8741/* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8742 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8743 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8744 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8745 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8746 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8747 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8748 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8749 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8750/* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8751 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8752 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8753 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8754 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8755 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8756 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8757 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8758 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8759/* ; idle */
8760 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8761 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8762 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8763 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8764 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8765 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8766 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8767 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8768 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8769/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8770 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8771 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8772 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8773 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8774 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8775 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8776 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8777 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8778/* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8779 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8780 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8781 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8782 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8783/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8784 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8785 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8786 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8787 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8788 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8789 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8790 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8791 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8792/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8793 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8794 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8795 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8796 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8797 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8798 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8799 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8800 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8801/* ;CR Registers */
8802 /* Config. Reg. 0 (filters) (cr0):FF */
8803 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8804/* Config. Reg. 1 (dialing) (cr1):05 */
8805 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8806/* Config. Reg. 2 (caller ID) (cr2):04 */
8807 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8808/* Config. Reg. 3 (testloops) (cr3):00 ; */
8809 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8810/* Config. Reg. 4 (analog gain) (cr4):02 */
8811 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8812 /* Config. Reg. 5 (Version) (cr5):02 */
8813 /* Config. Reg. 6 (Reserved) (cr6):00 */
8814 /* Config. Reg. 7 (Reserved) (cr7):00 */
8815 /* ;xr Registers */
8816 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8817
8818 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8819 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8820
8821 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8822 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8823
8824 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8825/* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8826 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8827/* Ext. Reg. 4 (Cadence) (xr4):00 */
8828 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8829/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8830 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8831/* Ext. Reg. 6 (Power State) (xr6):00 */
8832 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8833/* Ext. Reg. 7 (Vdd) (xr7):40 */
8834 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8835 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8836 /* 12,33,5A,C3 ; 770 Hz */
8837 /* 13,3C,5B,32 ; 852 Hz */
8838 /* 1D,1B,5C,CC ; 941 Hz */
8839
8840 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8841 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8842 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8843 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8844/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8845 /* EC,1D,52,22 ; 1336 Hz */
8846 /* AA,AC,51,D2 ; 1477 Hz */
8847 /* 9B,3B,51,25 ; 1633 Hz */
8848 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8849 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8850 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8851 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8852}
8853
8854static s16 tone_table[][19] =
8855{
8856 { /* f20_50[] 11 */
8857 32538, /* A1 = 1.985962 */
8858 -32325, /* A2 = -0.986511 */
8859 -343, /* B2 = -0.010493 */
8860 0, /* B1 = 0 */
8861 343, /* B0 = 0.010493 */
8862 32619, /* A1 = 1.990906 */
8863 -32520, /* A2 = -0.992462 */
8864 19179, /* B2 = 0.585327 */
8865 -19178, /* B1 = -1.170593 */
8866 19179, /* B0 = 0.585327 */
8867 32723, /* A1 = 1.997314 */
8868 -32686, /* A2 = -0.997528 */
8869 9973, /* B2 = 0.304352 */
8870 -9955, /* B1 = -0.607605 */
8871 9973, /* B0 = 0.304352 */
8872 7, /* Internal filter scaling */
8873 159, /* Minimum in-band energy threshold */
8874 21, /* 21/32 in-band to broad-band ratio */
8875 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8876 },
8877 { /* f133_200[] 12 */
8878 32072, /* A1 = 1.95752 */
8879 -31896, /* A2 = -0.973419 */
8880 -435, /* B2 = -0.013294 */
8881 0, /* B1 = 0 */
8882 435, /* B0 = 0.013294 */
8883 32188, /* A1 = 1.9646 */
8884 -32400, /* A2 = -0.98877 */
8885 15139, /* B2 = 0.462036 */
8886 -14882, /* B1 = -0.908356 */
8887 15139, /* B0 = 0.462036 */
8888 32473, /* A1 = 1.981995 */
8889 -32524, /* A2 = -0.992584 */
8890 23200, /* B2 = 0.708008 */
8891 -23113, /* B1 = -1.410706 */
8892 23200, /* B0 = 0.708008 */
8893 7, /* Internal filter scaling */
8894 159, /* Minimum in-band energy threshold */
8895 21, /* 21/32 in-band to broad-band ratio */
8896 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8897 },
8898 { /* f300 13 */
8899 31769, /* A1 = -1.939026 */
8900 -32584, /* A2 = 0.994385 */
8901 -475, /* B2 = -0.014522 */
8902 0, /* B1 = 0.000000 */
8903 475, /* B0 = 0.014522 */
8904 31789, /* A1 = -1.940247 */
8905 -32679, /* A2 = 0.997284 */
8906 17280, /* B2 = 0.527344 */
8907 -16865, /* B1 = -1.029358 */
8908 17280, /* B0 = 0.527344 */
8909 31841, /* A1 = -1.943481 */
8910 -32681, /* A2 = 0.997345 */
8911 543, /* B2 = 0.016579 */
8912 -525, /* B1 = -0.032097 */
8913 543, /* B0 = 0.016579 */
8914 5, /* Internal filter scaling */
8915 159, /* Minimum in-band energy threshold */
8916 21, /* 21/32 in-band to broad-band ratio */
8917 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8918 },
8919 { /* f300_420[] 14 */
8920 30750, /* A1 = 1.876892 */
8921 -31212, /* A2 = -0.952515 */
8922 -804, /* B2 = -0.024541 */
8923 0, /* B1 = 0 */
8924 804, /* B0 = 0.024541 */
8925 30686, /* A1 = 1.872925 */
8926 -32145, /* A2 = -0.980988 */
8927 14747, /* B2 = 0.450043 */
8928 -13703, /* B1 = -0.836395 */
8929 14747, /* B0 = 0.450043 */
8930 31651, /* A1 = 1.931824 */
8931 -32321, /* A2 = -0.986389 */
8932 24425, /* B2 = 0.745422 */
8933 -23914, /* B1 = -1.459595 */
8934 24427, /* B0 = 0.745483 */
8935 7, /* Internal filter scaling */
8936 159, /* Minimum in-band energy threshold */
8937 21, /* 21/32 in-band to broad-band ratio */
8938 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8939 },
8940 { /* f330 15 */
8941 31613, /* A1 = -1.929565 */
8942 -32646, /* A2 = 0.996277 */
8943 -185, /* B2 = -0.005657 */
8944 0, /* B1 = 0.000000 */
8945 185, /* B0 = 0.005657 */
8946 31620, /* A1 = -1.929932 */
8947 -32713, /* A2 = 0.998352 */
8948 19253, /* B2 = 0.587585 */
8949 -18566, /* B1 = -1.133179 */
8950 19253, /* B0 = 0.587585 */
8951 31674, /* A1 = -1.933228 */
8952 -32715, /* A2 = 0.998413 */
8953 2575, /* B2 = 0.078590 */
8954 -2495, /* B1 = -0.152283 */
8955 2575, /* B0 = 0.078590 */
8956 5, /* Internal filter scaling */
8957 159, /* Minimum in-band energy threshold */
8958 21, /* 21/32 in-band to broad-band ratio */
8959 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8960 },
8961 { /* f300_425[] 16 */
8962 30741, /* A1 = 1.876282 */
8963 -31475, /* A2 = -0.960541 */
8964 -703, /* B2 = -0.021484 */
8965 0, /* B1 = 0 */
8966 703, /* B0 = 0.021484 */
8967 30688, /* A1 = 1.873047 */
8968 -32248, /* A2 = -0.984161 */
8969 14542, /* B2 = 0.443787 */
8970 -13523, /* B1 = -0.825439 */
8971 14542, /* B0 = 0.443817 */
8972 31494, /* A1 = 1.922302 */
8973 -32366, /* A2 = -0.987762 */
8974 21577, /* B2 = 0.658508 */
8975 -21013, /* B1 = -1.282532 */
8976 21577, /* B0 = 0.658508 */
8977 7, /* Internal filter scaling */
8978 159, /* Minimum in-band energy threshold */
8979 21, /* 21/32 in-band to broad-band ratio */
8980 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8981 },
8982 { /* f330_440[] 17 */
8983 30627, /* A1 = 1.869324 */
8984 -31338, /* A2 = -0.95636 */
8985 -843, /* B2 = -0.025749 */
8986 0, /* B1 = 0 */
8987 843, /* B0 = 0.025749 */
8988 30550, /* A1 = 1.864685 */
8989 -32221, /* A2 = -0.983337 */
8990 13594, /* B2 = 0.414886 */
8991 -12589, /* B1 = -0.768402 */
8992 13594, /* B0 = 0.414886 */
8993 31488, /* A1 = 1.921936 */
8994 -32358, /* A2 = -0.987518 */
8995 24684, /* B2 = 0.753296 */
8996 -24029, /* B1 = -1.466614 */
8997 24684, /* B0 = 0.753296 */
8998 7, /* Internal filter scaling */
8999 159, /* Minimum in-band energy threshold */
9000 21, /* 21/32 in-band to broad-band ratio */
9001 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9002 },
9003 { /* f340 18 */
9004 31546, /* A1 = -1.925476 */
9005 -32646, /* A2 = 0.996277 */
9006 -445, /* B2 = -0.013588 */
9007 0, /* B1 = 0.000000 */
9008 445, /* B0 = 0.013588 */
9009 31551, /* A1 = -1.925781 */
9010 -32713, /* A2 = 0.998352 */
9011 23884, /* B2 = 0.728882 */
9012 -22979, /* B1 = -1.402527 */
9013 23884, /* B0 = 0.728882 */
9014 31606, /* A1 = -1.929138 */
9015 -32715, /* A2 = 0.998413 */
9016 863, /* B2 = 0.026367 */
9017 -835, /* B1 = -0.050985 */
9018 863, /* B0 = 0.026367 */
9019 5, /* Internal filter scaling */
9020 159, /* Minimum in-band energy threshold */
9021 21, /* 21/32 in-band to broad-band ratio */
9022 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9023 },
9024 { /* f350_400[] 19 */
9025 31006, /* A1 = 1.892517 */
9026 -32029, /* A2 = -0.977448 */
9027 -461, /* B2 = -0.014096 */
9028 0, /* B1 = 0 */
9029 461, /* B0 = 0.014096 */
9030 30999, /* A1 = 1.892029 */
9031 -32487, /* A2 = -0.991455 */
9032 11325, /* B2 = 0.345612 */
9033 -10682, /* B1 = -0.651978 */
9034 11325, /* B0 = 0.345612 */
9035 31441, /* A1 = 1.919067 */
9036 -32526, /* A2 = -0.992615 */
9037 24324, /* B2 = 0.74231 */
9038 -23535, /* B1 = -1.436523 */
9039 24324, /* B0 = 0.74231 */
9040 7, /* Internal filter scaling */
9041 159, /* Minimum in-band energy threshold */
9042 21, /* 21/32 in-band to broad-band ratio */
9043 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9044 },
9045 { /* f350_440[] */
9046 30634, /* A1 = 1.869751 */
9047 -31533, /* A2 = -0.962341 */
9048 -680, /* B2 = -0.020782 */
9049 0, /* B1 = 0 */
9050 680, /* B0 = 0.020782 */
9051 30571, /* A1 = 1.865906 */
9052 -32277, /* A2 = -0.985016 */
9053 12894, /* B2 = 0.393524 */
9054 -11945, /* B1 = -0.729065 */
9055 12894, /* B0 = 0.393524 */
9056 31367, /* A1 = 1.91449 */
9057 -32379, /* A2 = -0.988129 */
9058 23820, /* B2 = 0.726929 */
9059 -23104, /* B1 = -1.410217 */
9060 23820, /* B0 = 0.726929 */
9061 7, /* Internal filter scaling */
9062 159, /* Minimum in-band energy threshold */
9063 21, /* 21/32 in-band to broad-band ratio */
9064 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9065 },
9066 { /* f350_450[] */
9067 30552, /* A1 = 1.864807 */
9068 -31434, /* A2 = -0.95929 */
9069 -690, /* B2 = -0.021066 */
9070 0, /* B1 = 0 */
9071 690, /* B0 = 0.021066 */
9072 30472, /* A1 = 1.859924 */
9073 -32248, /* A2 = -0.984161 */
9074 13385, /* B2 = 0.408478 */
9075 -12357, /* B1 = -0.754242 */
9076 13385, /* B0 = 0.408478 */
9077 31358, /* A1 = 1.914001 */
9078 -32366, /* A2 = -0.987732 */
9079 26488, /* B2 = 0.80835 */
9080 -25692, /* B1 = -1.568176 */
9081 26490, /* B0 = 0.808411 */
9082 7, /* Internal filter scaling */
9083 159, /* Minimum in-band energy threshold */
9084 21, /* 21/32 in-band to broad-band ratio */
9085 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9086 },
9087 { /* f360 */
9088 31397, /* A1 = -1.916321 */
9089 -32623, /* A2 = 0.995605 */
9090 -117, /* B2 = -0.003598 */
9091 0, /* B1 = 0.000000 */
9092 117, /* B0 = 0.003598 */
9093 31403, /* A1 = -1.916687 */
9094 -32700, /* A2 = 0.997925 */
9095 3388, /* B2 = 0.103401 */
9096 -3240, /* B1 = -0.197784 */
9097 3388, /* B0 = 0.103401 */
9098 31463, /* A1 = -1.920410 */
9099 -32702, /* A2 = 0.997986 */
9100 13346, /* B2 = 0.407288 */
9101 -12863, /* B1 = -0.785126 */
9102 13346, /* B0 = 0.407288 */
9103 5, /* Internal filter scaling */
9104 159, /* Minimum in-band energy threshold */
9105 21, /* 21/32 in-band to broad-band ratio */
9106 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9107 },
9108 { /* f380_420[] */
9109 30831, /* A1 = 1.881775 */
9110 -32064, /* A2 = -0.978546 */
9111 -367, /* B2 = -0.01122 */
9112 0, /* B1 = 0 */
9113 367, /* B0 = 0.01122 */
9114 30813, /* A1 = 1.880737 */
9115 -32456, /* A2 = -0.990509 */
9116 11068, /* B2 = 0.337769 */
9117 -10338, /* B1 = -0.631042 */
9118 11068, /* B0 = 0.337769 */
9119 31214, /* A1 = 1.905212 */
9120 -32491, /* A2 = -0.991577 */
9121 16374, /* B2 = 0.499695 */
9122 -15781, /* B1 = -0.963196 */
9123 16374, /* B0 = 0.499695 */
9124 7, /* Internal filter scaling */
9125 159, /* Minimum in-band energy threshold */
9126 21, /* 21/32 in-band to broad-band ratio */
9127 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9128 },
9129 { /* f392 */
9130 31152, /* A1 = -1.901428 */
9131 -32613, /* A2 = 0.995300 */
9132 -314, /* B2 = -0.009605 */
9133 0, /* B1 = 0.000000 */
9134 314, /* B0 = 0.009605 */
9135 31156, /* A1 = -1.901672 */
9136 -32694, /* A2 = 0.997742 */
9137 28847, /* B2 = 0.880371 */
9138 -2734, /* B1 = -0.166901 */
9139 28847, /* B0 = 0.880371 */
9140 31225, /* A1 = -1.905823 */
9141 -32696, /* A2 = 0.997803 */
9142 462, /* B2 = 0.014108 */
9143 -442, /* B1 = -0.027019 */
9144 462, /* B0 = 0.014108 */
9145 5, /* Internal filter scaling */
9146 159, /* Minimum in-band energy threshold */
9147 21, /* 21/32 in-band to broad-band ratio */
9148 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9149 },
9150 { /* f400_425[] */
9151 30836, /* A1 = 1.882141 */
9152 -32296, /* A2 = -0.985596 */
9153 -324, /* B2 = -0.009903 */
9154 0, /* B1 = 0 */
9155 324, /* B0 = 0.009903 */
9156 30825, /* A1 = 1.881409 */
9157 -32570, /* A2 = -0.993958 */
9158 16847, /* B2 = 0.51416 */
9159 -15792, /* B1 = -0.963898 */
9160 16847, /* B0 = 0.51416 */
9161 31106, /* A1 = 1.89856 */
9162 -32584, /* A2 = -0.994415 */
9163 9579, /* B2 = 0.292328 */
9164 -9164, /* B1 = -0.559357 */
9165 9579, /* B0 = 0.292328 */
9166 7, /* Internal filter scaling */
9167 159, /* Minimum in-band energy threshold */
9168 21, /* 21/32 in-band to broad-band ratio */
9169 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9170 },
9171 { /* f400_440[] */
9172 30702, /* A1 = 1.873962 */
9173 -32134, /* A2 = -0.980682 */
9174 -517, /* B2 = -0.015793 */
9175 0, /* B1 = 0 */
9176 517, /* B0 = 0.015793 */
9177 30676, /* A1 = 1.872375 */
9178 -32520, /* A2 = -0.992462 */
9179 8144, /* B2 = 0.24855 */
9180 -7596, /* B1 = -0.463684 */
9181 8144, /* B0 = 0.24855 */
9182 31084, /* A1 = 1.897217 */
9183 -32547, /* A2 = -0.993256 */
9184 22713, /* B2 = 0.693176 */
9185 -21734, /* B1 = -1.326599 */
9186 22713, /* B0 = 0.693176 */
9187 7, /* Internal filter scaling */
9188 159, /* Minimum in-band energy threshold */
9189 21, /* 21/32 in-band to broad-band ratio */
9190 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9191 },
9192 { /* f400_450[] */
9193 30613, /* A1 = 1.86853 */
9194 -32031, /* A2 = -0.977509 */
9195 -618, /* B2 = -0.018866 */
9196 0, /* B1 = 0 */
9197 618, /* B0 = 0.018866 */
9198 30577, /* A1 = 1.866272 */
9199 -32491, /* A2 = -0.991577 */
9200 9612, /* B2 = 0.293335 */
9201 -8935, /* B1 = -0.54541 */
9202 9612, /* B0 = 0.293335 */
9203 31071, /* A1 = 1.896484 */
9204 -32524, /* A2 = -0.992584 */
9205 21596, /* B2 = 0.659058 */
9206 -20667, /* B1 = -1.261414 */
9207 21596, /* B0 = 0.659058 */
9208 7, /* Internal filter scaling */
9209 159, /* Minimum in-band energy threshold */
9210 21, /* 21/32 in-band to broad-band ratio */
9211 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9212 },
9213 { /* f420 */
9214 30914, /* A1 = -1.886841 */
9215 -32584, /* A2 = 0.994385 */
9216 -426, /* B2 = -0.013020 */
9217 0, /* B1 = 0.000000 */
9218 426, /* B0 = 0.013020 */
9219 30914, /* A1 = -1.886841 */
9220 -32679, /* A2 = 0.997314 */
9221 17520, /* B2 = 0.534668 */
9222 -16471, /* B1 = -1.005310 */
9223 17520, /* B0 = 0.534668 */
9224 31004, /* A1 = -1.892334 */
9225 -32683, /* A2 = 0.997406 */
9226 819, /* B2 = 0.025023 */
9227 -780, /* B1 = -0.047619 */
9228 819, /* B0 = 0.025023 */
9229 5, /* Internal filter scaling */
9230 159, /* Minimum in-band energy threshold */
9231 21, /* 21/32 in-band to broad-band ratio */
9232 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9233 },
9234#if 0
9235 { /* f425 */
9236 30881, /* A1 = -1.884827 */
9237 -32603, /* A2 = 0.994965 */
9238 -496, /* B2 = -0.015144 */
9239 0, /* B1 = 0.000000 */
9240 496, /* B0 = 0.015144 */
9241 30880, /* A1 = -1.884766 */
9242 -32692, /* A2 = 0.997711 */
9243 24767, /* B2 = 0.755859 */
9244 -23290, /* B1 = -1.421509 */
9245 24767, /* B0 = 0.755859 */
9246 30967, /* A1 = -1.890076 */
9247 -32694, /* A2 = 0.997772 */
9248 728, /* B2 = 0.022232 */
9249 -691, /* B1 = -0.042194 */
9250 728, /* B0 = 0.022232 */
9251 5, /* Internal filter scaling */
9252 159, /* Minimum in-band energy threshold */
9253 21, /* 21/32 in-band to broad-band ratio */
9254 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9255 },
9256#else
9257 {
9258 30850,
9259 -32534,
9260 -504,
9261 0,
9262 504,
9263 30831,
9264 -32669,
9265 24303,
9266 -22080,
9267 24303,
9268 30994,
9269 -32673,
9270 1905,
9271 -1811,
9272 1905,
9273 5,
9274 129,
9275 17,
9276 0xff5
9277 },
9278#endif
9279 { /* f425_450[] */
9280 30646, /* A1 = 1.870544 */
9281 -32327, /* A2 = -0.986572 */
9282 -287, /* B2 = -0.008769 */
9283 0, /* B1 = 0 */
9284 287, /* B0 = 0.008769 */
9285 30627, /* A1 = 1.869324 */
9286 -32607, /* A2 = -0.995087 */
9287 13269, /* B2 = 0.404968 */
9288 -12376, /* B1 = -0.755432 */
9289 13269, /* B0 = 0.404968 */
9290 30924, /* A1 = 1.887512 */
9291 -32619, /* A2 = -0.995453 */
9292 19950, /* B2 = 0.608826 */
9293 -18940, /* B1 = -1.156006 */
9294 19950, /* B0 = 0.608826 */
9295 7, /* Internal filter scaling */
9296 159, /* Minimum in-band energy threshold */
9297 21, /* 21/32 in-band to broad-band ratio */
9298 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9299 },
9300 { /* f425_475[] */
9301 30396, /* A1 = 1.855225 */
9302 -32014, /* A2 = -0.97699 */
9303 -395, /* B2 = -0.012055 */
9304 0, /* B1 = 0 */
9305 395, /* B0 = 0.012055 */
9306 30343, /* A1 = 1.85199 */
9307 -32482, /* A2 = -0.991302 */
9308 17823, /* B2 = 0.543945 */
9309 -16431, /* B1 = -1.002869 */
9310 17823, /* B0 = 0.543945 */
9311 30872, /* A1 = 1.884338 */
9312 -32516, /* A2 = -0.99231 */
9313 18124, /* B2 = 0.553101 */
9314 -17246, /* B1 = -1.052673 */
9315 18124, /* B0 = 0.553101 */
9316 7, /* Internal filter scaling */
9317 159, /* Minimum in-band energy threshold */
9318 21, /* 21/32 in-band to broad-band ratio */
9319 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9320 },
9321 { /* f435 */
9322 30796, /* A1 = -1.879639 */
9323 -32603, /* A2 = 0.994965 */
9324 -254, /* B2 = -0.007762 */
9325 0, /* B1 = 0.000000 */
9326 254, /* B0 = 0.007762 */
9327 30793, /* A1 = -1.879456 */
9328 -32692, /* A2 = 0.997711 */
9329 18934, /* B2 = 0.577820 */
9330 -17751, /* B1 = -1.083496 */
9331 18934, /* B0 = 0.577820 */
9332 30882, /* A1 = -1.884888 */
9333 -32694, /* A2 = 0.997772 */
9334 1858, /* B2 = 0.056713 */
9335 -1758, /* B1 = -0.107357 */
9336 1858, /* B0 = 0.056713 */
9337 5, /* Internal filter scaling */
9338 159, /* Minimum in-band energy threshold */
9339 21, /* 21/32 in-band to broad-band ratio */
9340 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9341 },
9342 { /* f440_450[] */
9343 30641, /* A1 = 1.870239 */
9344 -32458, /* A2 = -0.99057 */
9345 -155, /* B2 = -0.004735 */
9346 0, /* B1 = 0 */
9347 155, /* B0 = 0.004735 */
9348 30631, /* A1 = 1.869568 */
9349 -32630, /* A2 = -0.995789 */
9350 11453, /* B2 = 0.349548 */
9351 -10666, /* B1 = -0.651001 */
9352 11453, /* B0 = 0.349548 */
9353 30810, /* A1 = 1.880554 */
9354 -32634, /* A2 = -0.995941 */
9355 12237, /* B2 = 0.373474 */
9356 -11588, /* B1 = -0.707336 */
9357 12237, /* B0 = 0.373474 */
9358 7, /* Internal filter scaling */
9359 159, /* Minimum in-band energy threshold */
9360 21, /* 21/32 in-band to broad-band ratio */
9361 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9362 },
9363 { /* f440_480[] */
9364 30367, /* A1 = 1.853455 */
9365 -32147, /* A2 = -0.981079 */
9366 -495, /* B2 = -0.015113 */
9367 0, /* B1 = 0 */
9368 495, /* B0 = 0.015113 */
9369 30322, /* A1 = 1.850769 */
9370 -32543, /* A2 = -0.993134 */
9371 10031, /* B2 = 0.306152 */
9372 -9252, /* B1 = -0.564728 */
9373 10031, /* B0 = 0.306152 */
9374 30770, /* A1 = 1.878052 */
9375 -32563, /* A2 = -0.993774 */
9376 22674, /* B2 = 0.691956 */
9377 -21465, /* B1 = -1.31012 */
9378 22674, /* B0 = 0.691956 */
9379 7, /* Internal filter scaling */
9380 159, /* Minimum in-band energy threshold */
9381 21, /* 21/32 in-band to broad-band ratio */
9382 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9383 },
9384 { /* f445 */
9385 30709, /* A1 = -1.874329 */
9386 -32603, /* A2 = 0.994965 */
9387 -83, /* B2 = -0.002545 */
9388 0, /* B1 = 0.000000 */
9389 83, /* B0 = 0.002545 */
9390 30704, /* A1 = -1.874084 */
9391 -32692, /* A2 = 0.997711 */
9392 10641, /* B2 = 0.324738 */
9393 -9947, /* B1 = -0.607147 */
9394 10641, /* B0 = 0.324738 */
9395 30796, /* A1 = -1.879639 */
9396 -32694, /* A2 = 0.997772 */
9397 10079, /* B2 = 0.307587 */
9398 9513, /* B1 = 0.580688 */
9399 10079, /* B0 = 0.307587 */
9400 5, /* Internal filter scaling */
9401 159, /* Minimum in-band energy threshold */
9402 21, /* 21/32 in-band to broad-band ratio */
9403 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9404 },
9405 { /* f450 */
9406 30664, /* A1 = -1.871643 */
9407 -32603, /* A2 = 0.994965 */
9408 -164, /* B2 = -0.005029 */
9409 0, /* B1 = 0.000000 */
9410 164, /* B0 = 0.005029 */
9411 30661, /* A1 = -1.871399 */
9412 -32692, /* A2 = 0.997711 */
9413 15294, /* B2 = 0.466736 */
9414 -14275, /* B1 = -0.871307 */
9415 15294, /* B0 = 0.466736 */
9416 30751, /* A1 = -1.876953 */
9417 -32694, /* A2 = 0.997772 */
9418 3548, /* B2 = 0.108284 */
9419 -3344, /* B1 = -0.204155 */
9420 3548, /* B0 = 0.108284 */
9421 5, /* Internal filter scaling */
9422 159, /* Minimum in-band energy threshold */
9423 21, /* 21/32 in-band to broad-band ratio */
9424 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9425 },
9426 { /* f452 */
9427 30653, /* A1 = -1.870911 */
9428 -32615, /* A2 = 0.995361 */
9429 -209, /* B2 = -0.006382 */
9430 0, /* B1 = 0.000000 */
9431 209, /* B0 = 0.006382 */
9432 30647, /* A1 = -1.870605 */
9433 -32702, /* A2 = 0.997986 */
9434 18971, /* B2 = 0.578979 */
9435 -17716, /* B1 = -1.081299 */
9436 18971, /* B0 = 0.578979 */
9437 30738, /* A1 = -1.876099 */
9438 -32702, /* A2 = 0.998016 */
9439 2967, /* B2 = 0.090561 */
9440 -2793, /* B1 = -0.170502 */
9441 2967, /* B0 = 0.090561 */
9442 5, /* Internal filter scaling */
9443 159, /* Minimum in-band energy threshold */
9444 21, /* 21/32 in-band to broad-band ratio */
9445 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9446 },
9447 { /* f475 */
9448 30437, /* A1 = -1.857727 */
9449 -32603, /* A2 = 0.994965 */
9450 -264, /* B2 = -0.008062 */
9451 0, /* B1 = 0.000000 */
9452 264, /* B0 = 0.008062 */
9453 30430, /* A1 = -1.857300 */
9454 -32692, /* A2 = 0.997711 */
9455 21681, /* B2 = 0.661682 */
9456 -20082, /* B1 = -1.225708 */
9457 21681, /* B0 = 0.661682 */
9458 30526, /* A1 = -1.863220 */
9459 -32694, /* A2 = 0.997742 */
9460 1559, /* B2 = 0.047600 */
9461 -1459, /* B1 = -0.089096 */
9462 1559, /* B0 = 0.047600 */
9463 5, /* Internal filter scaling */
9464 159, /* Minimum in-band energy threshold */
9465 21, /* 21/32 in-band to broad-band ratio */
9466 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9467 },
9468 { /* f480_620[] */
9469 28975, /* A1 = 1.768494 */
9470 -30955, /* A2 = -0.944672 */
9471 -1026, /* B2 = -0.03133 */
9472 0, /* B1 = 0 */
9473 1026, /* B0 = 0.03133 */
9474 28613, /* A1 = 1.746399 */
9475 -32089, /* A2 = -0.979309 */
9476 14214, /* B2 = 0.433807 */
9477 -12202, /* B1 = -0.744812 */
9478 14214, /* B0 = 0.433807 */
9479 30243, /* A1 = 1.845947 */
9480 -32238, /* A2 = -0.983856 */
9481 24825, /* B2 = 0.757629 */
9482 -23402, /* B1 = -1.428345 */
9483 24825, /* B0 = 0.757629 */
9484 7, /* Internal filter scaling */
9485 159, /* Minimum in-band energy threshold */
9486 21, /* 21/32 in-band to broad-band ratio */
9487 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9488 },
9489 { /* f494 */
9490 30257, /* A1 = -1.846741 */
9491 -32605, /* A2 = 0.995056 */
9492 -249, /* B2 = -0.007625 */
9493 0, /* B1 = 0.000000 */
9494 249, /* B0 = 0.007625 */
9495 30247, /* A1 = -1.846191 */
9496 -32694, /* A2 = 0.997772 */
9497 18088, /* B2 = 0.552002 */
9498 -16652, /* B1 = -1.016418 */
9499 18088, /* B0 = 0.552002 */
9500 30348, /* A1 = -1.852295 */
9501 -32696, /* A2 = 0.997803 */
9502 2099, /* B2 = 0.064064 */
9503 -1953, /* B1 = -0.119202 */
9504 2099, /* B0 = 0.064064 */
9505 5, /* Internal filter scaling */
9506 159, /* Minimum in-band energy threshold */
9507 21, /* 21/32 in-band to broad-band ratio */
9508 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9509 },
9510 { /* f500 */
9511 30202, /* A1 = -1.843431 */
9512 -32624, /* A2 = 0.995622 */
9513 -413, /* B2 = -0.012622 */
9514 0, /* B1 = 0.000000 */
9515 413, /* B0 = 0.012622 */
9516 30191, /* A1 = -1.842721 */
9517 -32714, /* A2 = 0.998364 */
9518 25954, /* B2 = 0.792057 */
9519 -23890, /* B1 = -1.458131 */
9520 25954, /* B0 = 0.792057 */
9521 30296, /* A1 = -1.849172 */
9522 -32715, /* A2 = 0.998397 */
9523 2007, /* B2 = 0.061264 */
9524 -1860, /* B1 = -0.113568 */
9525 2007, /* B0 = 0.061264 */
9526 5, /* Internal filter scaling */
9527 159, /* Minimum in-band energy threshold */
9528 21, /* 21/32 in-band to broad-band ratio */
9529 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9530 },
9531 { /* f520 */
9532 30001, /* A1 = -1.831116 */
9533 -32613, /* A2 = 0.995270 */
9534 -155, /* B2 = -0.004750 */
9535 0, /* B1 = 0.000000 */
9536 155, /* B0 = 0.004750 */
9537 29985, /* A1 = -1.830200 */
9538 -32710, /* A2 = 0.998260 */
9539 6584, /* B2 = 0.200928 */
9540 -6018, /* B1 = -0.367355 */
9541 6584, /* B0 = 0.200928 */
9542 30105, /* A1 = -1.837524 */
9543 -32712, /* A2 = 0.998291 */
9544 23812, /* B2 = 0.726685 */
9545 -21936, /* B1 = -1.338928 */
9546 23812, /* B0 = 0.726685 */
9547 5, /* Internal filter scaling */
9548 159, /* Minimum in-band energy threshold */
9549 21, /* 21/32 in-band to broad-band ratio */
9550 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9551 },
9552 { /* f523 */
9553 29964, /* A1 = -1.828918 */
9554 -32601, /* A2 = 0.994904 */
9555 -101, /* B2 = -0.003110 */
9556 0, /* B1 = 0.000000 */
9557 101, /* B0 = 0.003110 */
9558 29949, /* A1 = -1.827942 */
9559 -32700, /* A2 = 0.997925 */
9560 11041, /* B2 = 0.336975 */
9561 -10075, /* B1 = -0.614960 */
9562 11041, /* B0 = 0.336975 */
9563 30070, /* A1 = -1.835388 */
9564 -32702, /* A2 = 0.997986 */
9565 16762, /* B2 = 0.511536 */
9566 -15437, /* B1 = -0.942230 */
9567 16762, /* B0 = 0.511536 */
9568 5, /* Internal filter scaling */
9569 159, /* Minimum in-band energy threshold */
9570 21, /* 21/32 in-band to broad-band ratio */
9571 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9572 },
9573 { /* f525 */
9574 29936, /* A1 = -1.827209 */
9575 -32584, /* A2 = 0.994415 */
9576 -91, /* B2 = -0.002806 */
9577 0, /* B1 = 0.000000 */
9578 91, /* B0 = 0.002806 */
9579 29921, /* A1 = -1.826233 */
9580 -32688, /* A2 = 0.997559 */
9581 11449, /* B2 = 0.349396 */
9582 -10426, /* B1 = -0.636383 */
9583 11449, /* B0 = 0.349396 */
9584 30045, /* A1 = -1.833862 */
9585 -32688, /* A2 = 0.997589 */
9586 13055, /* B2 = 0.398407 */
9587 -12028, /* B1 = -0.734161 */
9588 13055, /* B0 = 0.398407 */
9589 5, /* Internal filter scaling */
9590 159, /* Minimum in-band energy threshold */
9591 21, /* 21/32 in-band to broad-band ratio */
9592 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9593 },
9594 { /* f540_660[] */
9595 28499, /* A1 = 1.739441 */
9596 -31129, /* A2 = -0.949982 */
9597 -849, /* B2 = -0.025922 */
9598 0, /* B1 = 0 */
9599 849, /* B0 = 0.025922 */
9600 28128, /* A1 = 1.716797 */
9601 -32130, /* A2 = -0.98056 */
9602 14556, /* B2 = 0.444214 */
9603 -12251, /* B1 = -0.747772 */
9604 14556, /* B0 = 0.444244 */
9605 29667, /* A1 = 1.81073 */
9606 -32244, /* A2 = -0.984039 */
9607 23038, /* B2 = 0.703064 */
9608 -21358, /* B1 = -1.303589 */
9609 23040, /* B0 = 0.703125 */
9610 7, /* Internal filter scaling */
9611 159, /* Minimum in-band energy threshold */
9612 21, /* 21/32 in-band to broad-band ratio */
9613 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9614 },
9615 { /* f587 */
9616 29271, /* A1 = -1.786560 */
9617 -32599, /* A2 = 0.994873 */
9618 -490, /* B2 = -0.014957 */
9619 0, /* B1 = 0.000000 */
9620 490, /* B0 = 0.014957 */
9621 29246, /* A1 = -1.785095 */
9622 -32700, /* A2 = 0.997925 */
9623 28961, /* B2 = 0.883850 */
9624 -25796, /* B1 = -1.574463 */
9625 28961, /* B0 = 0.883850 */
9626 29383, /* A1 = -1.793396 */
9627 -32700, /* A2 = 0.997955 */
9628 1299, /* B2 = 0.039650 */
9629 -1169, /* B1 = -0.071396 */
9630 1299, /* B0 = 0.039650 */
9631 5, /* Internal filter scaling */
9632 159, /* Minimum in-band energy threshold */
9633 21, /* 21/32 in-band to broad-band ratio */
9634 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9635 },
9636 { /* f590 */
9637 29230, /* A1 = -1.784058 */
9638 -32584, /* A2 = 0.994415 */
9639 -418, /* B2 = -0.012757 */
9640 0, /* B1 = 0.000000 */
9641 418, /* B0 = 0.012757 */
9642 29206, /* A1 = -1.782593 */
9643 -32688, /* A2 = 0.997559 */
9644 36556, /* B2 = 1.115601 */
9645 -32478, /* B1 = -1.982300 */
9646 36556, /* B0 = 1.115601 */
9647 29345, /* A1 = -1.791077 */
9648 -32688, /* A2 = 0.997589 */
9649 897, /* B2 = 0.027397 */
9650 -808, /* B1 = -0.049334 */
9651 897, /* B0 = 0.027397 */
9652 5, /* Internal filter scaling */
9653 159, /* Minimum in-band energy threshold */
9654 21, /* 21/32 in-band to broad-band ratio */
9655 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9656 },
9657 { /* f600 */
9658 29116, /* A1 = -1.777100 */
9659 -32603, /* A2 = 0.994965 */
9660 -165, /* B2 = -0.005039 */
9661 0, /* B1 = 0.000000 */
9662 165, /* B0 = 0.005039 */
9663 29089, /* A1 = -1.775452 */
9664 -32708, /* A2 = 0.998199 */
9665 6963, /* B2 = 0.212494 */
9666 -6172, /* B1 = -0.376770 */
9667 6963, /* B0 = 0.212494 */
9668 29237, /* A1 = -1.784485 */
9669 -32710, /* A2 = 0.998230 */
9670 24197, /* B2 = 0.738464 */
9671 -21657, /* B1 = -1.321899 */
9672 24197, /* B0 = 0.738464 */
9673 5, /* Internal filter scaling */
9674 159, /* Minimum in-band energy threshold */
9675 21, /* 21/32 in-band to broad-band ratio */
9676 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9677 },
9678 { /* f660 */
9679 28376, /* A1 = -1.731934 */
9680 -32567, /* A2 = 0.993896 */
9681 -363, /* B2 = -0.011102 */
9682 0, /* B1 = 0.000000 */
9683 363, /* B0 = 0.011102 */
9684 28337, /* A1 = -1.729614 */
9685 -32683, /* A2 = 0.997434 */
9686 21766, /* B2 = 0.664246 */
9687 -18761, /* B1 = -1.145081 */
9688 21766, /* B0 = 0.664246 */
9689 28513, /* A1 = -1.740356 */
9690 -32686, /* A2 = 0.997498 */
9691 2509, /* B2 = 0.076584 */
9692 -2196, /* B1 = -0.134041 */
9693 2509, /* B0 = 0.076584 */
9694 5, /* Internal filter scaling */
9695 159, /* Minimum in-band energy threshold */
9696 21, /* 21/32 in-band to broad-band ratio */
9697 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9698 },
9699 { /* f700 */
9700 27844, /* A1 = -1.699463 */
9701 -32563, /* A2 = 0.993744 */
9702 -366, /* B2 = -0.011187 */
9703 0, /* B1 = 0.000000 */
9704 366, /* B0 = 0.011187 */
9705 27797, /* A1 = -1.696655 */
9706 -32686, /* A2 = 0.997498 */
9707 22748, /* B2 = 0.694214 */
9708 -19235, /* B1 = -1.174072 */
9709 22748, /* B0 = 0.694214 */
9710 27995, /* A1 = -1.708740 */
9711 -32688, /* A2 = 0.997559 */
9712 2964, /* B2 = 0.090477 */
9713 -2546, /* B1 = -0.155449 */
9714 2964, /* B0 = 0.090477 */
9715 5, /* Internal filter scaling */
9716 159, /* Minimum in-band energy threshold */
9717 21, /* 21/32 in-band to broad-band ratio */
9718 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9719 },
9720 { /* f740 */
9721 27297, /* A1 = -1.666077 */
9722 -32551, /* A2 = 0.993408 */
9723 -345, /* B2 = -0.010540 */
9724 0, /* B1 = 0.000000 */
9725 345, /* B0 = 0.010540 */
9726 27240, /* A1 = -1.662598 */
9727 -32683, /* A2 = 0.997406 */
9728 22560, /* B2 = 0.688477 */
9729 -18688, /* B1 = -1.140625 */
9730 22560, /* B0 = 0.688477 */
9731 27461, /* A1 = -1.676147 */
9732 -32684, /* A2 = 0.997467 */
9733 3541, /* B2 = 0.108086 */
9734 -2985, /* B1 = -0.182220 */
9735 3541, /* B0 = 0.108086 */
9736 5, /* Internal filter scaling */
9737 159, /* Minimum in-band energy threshold */
9738 21, /* 21/32 in-band to broad-band ratio */
9739 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9740 },
9741 { /* f750 */
9742 27155, /* A1 = -1.657410 */
9743 -32551, /* A2 = 0.993408 */
9744 -462, /* B2 = -0.014117 */
9745 0, /* B1 = 0.000000 */
9746 462, /* B0 = 0.014117 */
9747 27097, /* A1 = -1.653870 */
9748 -32683, /* A2 = 0.997406 */
9749 32495, /* B2 = 0.991699 */
9750 -26776, /* B1 = -1.634338 */
9751 32495, /* B0 = 0.991699 */
9752 27321, /* A1 = -1.667542 */
9753 -32684, /* A2 = 0.997467 */
9754 1835, /* B2 = 0.056007 */
9755 -1539, /* B1 = -0.093948 */
9756 1835, /* B0 = 0.056007 */
9757 5, /* Internal filter scaling */
9758 159, /* Minimum in-band energy threshold */
9759 21, /* 21/32 in-band to broad-band ratio */
9760 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9761 },
9762 { /* f750_1450[] */
9763 19298, /* A1 = 1.177917 */
9764 -24471, /* A2 = -0.746796 */
9765 -4152, /* B2 = -0.126709 */
9766 0, /* B1 = 0 */
9767 4152, /* B0 = 0.126709 */
9768 12902, /* A1 = 0.787476 */
9769 -29091, /* A2 = -0.887817 */
9770 12491, /* B2 = 0.38121 */
9771 -1794, /* B1 = -0.109528 */
9772 12494, /* B0 = 0.381317 */
9773 26291, /* A1 = 1.604736 */
9774 -30470, /* A2 = -0.929901 */
9775 28859, /* B2 = 0.880737 */
9776 -26084, /* B1 = -1.592102 */
9777 28861, /* B0 = 0.880798 */
9778 7, /* Internal filter scaling */
9779 159, /* Minimum in-band energy threshold */
9780 21, /* 21/32 in-band to broad-band ratio */
9781 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9782 },
9783 { /* f770 */
9784 26867, /* A1 = -1.639832 */
9785 -32551, /* A2 = 0.993408 */
9786 -123, /* B2 = -0.003755 */
9787 0, /* B1 = 0.000000 */
9788 123, /* B0 = 0.003755 */
9789 26805, /* A1 = -1.636108 */
9790 -32683, /* A2 = 0.997406 */
9791 17297, /* B2 = 0.527863 */
9792 -14096, /* B1 = -0.860382 */
9793 17297, /* B0 = 0.527863 */
9794 27034, /* A1 = -1.650085 */
9795 -32684, /* A2 = 0.997467 */
9796 12958, /* B2 = 0.395477 */
9797 -10756, /* B1 = -0.656525 */
9798 12958, /* B0 = 0.395477 */
9799 5, /* Internal filter scaling */
9800 159, /* Minimum in-band energy threshold */
9801 21, /* 21/32 in-band to broad-band ratio */
9802 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9803 },
9804 { /* f800 */
9805 26413, /* A1 = -1.612122 */
9806 -32547, /* A2 = 0.993286 */
9807 -223, /* B2 = -0.006825 */
9808 0, /* B1 = 0.000000 */
9809 223, /* B0 = 0.006825 */
9810 26342, /* A1 = -1.607849 */
9811 -32686, /* A2 = 0.997498 */
9812 6391, /* B2 = 0.195053 */
9813 -5120, /* B1 = -0.312531 */
9814 6391, /* B0 = 0.195053 */
9815 26593, /* A1 = -1.623108 */
9816 -32688, /* A2 = 0.997559 */
9817 23681, /* B2 = 0.722717 */
9818 -19328, /* B1 = -1.179688 */
9819 23681, /* B0 = 0.722717 */
9820 5, /* Internal filter scaling */
9821 159, /* Minimum in-band energy threshold */
9822 21, /* 21/32 in-band to broad-band ratio */
9823 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9824 },
9825 { /* f816 */
9826 26168, /* A1 = -1.597209 */
9827 -32528, /* A2 = 0.992706 */
9828 -235, /* B2 = -0.007182 */
9829 0, /* B1 = 0.000000 */
9830 235, /* B0 = 0.007182 */
9831 26092, /* A1 = -1.592590 */
9832 -32675, /* A2 = 0.997192 */
9833 20823, /* B2 = 0.635498 */
9834 -16510, /* B1 = -1.007751 */
9835 20823, /* B0 = 0.635498 */
9836 26363, /* A1 = -1.609070 */
9837 -32677, /* A2 = 0.997253 */
9838 6739, /* B2 = 0.205688 */
9839 -5459, /* B1 = -0.333206 */
9840 6739, /* B0 = 0.205688 */
9841 5, /* Internal filter scaling */
9842 159, /* Minimum in-band energy threshold */
9843 21, /* 21/32 in-band to broad-band ratio */
9844 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9845 },
9846 { /* f850 */
9847 25641, /* A1 = -1.565063 */
9848 -32536, /* A2 = 0.992950 */
9849 -121, /* B2 = -0.003707 */
9850 0, /* B1 = 0.000000 */
9851 121, /* B0 = 0.003707 */
9852 25560, /* A1 = -1.560059 */
9853 -32684, /* A2 = 0.997437 */
9854 18341, /* B2 = 0.559753 */
9855 -14252, /* B1 = -0.869904 */
9856 18341, /* B0 = 0.559753 */
9857 25837, /* A1 = -1.577026 */
9858 -32684, /* A2 = 0.997467 */
9859 16679, /* B2 = 0.509003 */
9860 -13232, /* B1 = -0.807648 */
9861 16679, /* B0 = 0.509003 */
9862 5, /* Internal filter scaling */
9863 159, /* Minimum in-band energy threshold */
9864 21, /* 21/32 in-band to broad-band ratio */
9865 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9866 },
9867 { /* f857_1645[] */
9868 16415, /* A1 = 1.001953 */
9869 -23669, /* A2 = -0.722321 */
9870 -4549, /* B2 = -0.138847 */
9871 0, /* B1 = 0 */
9872 4549, /* B0 = 0.138847 */
9873 8456, /* A1 = 0.516174 */
9874 -28996, /* A2 = -0.884918 */
9875 13753, /* B2 = 0.419724 */
9876 -12, /* B1 = -0.000763 */
9877 13757, /* B0 = 0.419846 */
9878 24632, /* A1 = 1.503418 */
9879 -30271, /* A2 = -0.923828 */
9880 29070, /* B2 = 0.887146 */
9881 -25265, /* B1 = -1.542114 */
9882 29073, /* B0 = 0.887268 */
9883 7, /* Internal filter scaling */
9884 159, /* Minimum in-band energy threshold */
9885 21, /* 21/32 in-band to broad-band ratio */
9886 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9887 },
9888 { /* f900 */
9889 24806, /* A1 = -1.514099 */
9890 -32501, /* A2 = 0.991852 */
9891 -326, /* B2 = -0.009969 */
9892 0, /* B1 = 0.000000 */
9893 326, /* B0 = 0.009969 */
9894 24709, /* A1 = -1.508118 */
9895 -32659, /* A2 = 0.996674 */
9896 20277, /* B2 = 0.618835 */
9897 -15182, /* B1 = -0.926636 */
9898 20277, /* B0 = 0.618835 */
9899 25022, /* A1 = -1.527222 */
9900 -32661, /* A2 = 0.996735 */
9901 4320, /* B2 = 0.131836 */
9902 -3331, /* B1 = -0.203339 */
9903 4320, /* B0 = 0.131836 */
9904 5, /* Internal filter scaling */
9905 159, /* Minimum in-band energy threshold */
9906 21, /* 21/32 in-band to broad-band ratio */
9907 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9908 },
9909 { /* f900_1300[] */
9910 19776, /* A1 = 1.207092 */
9911 -27437, /* A2 = -0.837341 */
9912 -2666, /* B2 = -0.081371 */
9913 0, /* B1 = 0 */
9914 2666, /* B0 = 0.081371 */
9915 16302, /* A1 = 0.995026 */
9916 -30354, /* A2 = -0.926361 */
9917 10389, /* B2 = 0.317062 */
9918 -3327, /* B1 = -0.203064 */
9919 10389, /* B0 = 0.317062 */
9920 24299, /* A1 = 1.483154 */
9921 -30930, /* A2 = -0.943909 */
9922 25016, /* B2 = 0.763428 */
9923 -21171, /* B1 = -1.292236 */
9924 25016, /* B0 = 0.763428 */
9925 7, /* Internal filter scaling */
9926 159, /* Minimum in-band energy threshold */
9927 21, /* 21/32 in-band to broad-band ratio */
9928 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9929 },
9930 { /* f935_1215[] */
9931 20554, /* A1 = 1.254517 */
9932 -28764, /* A2 = -0.877838 */
9933 -2048, /* B2 = -0.062515 */
9934 0, /* B1 = 0 */
9935 2048, /* B0 = 0.062515 */
9936 18209, /* A1 = 1.11145 */
9937 -30951, /* A2 = -0.94458 */
9938 9390, /* B2 = 0.286575 */
9939 -3955, /* B1 = -0.241455 */
9940 9390, /* B0 = 0.286575 */
9941 23902, /* A1 = 1.458923 */
9942 -31286, /* A2 = -0.954803 */
9943 23252, /* B2 = 0.709595 */
9944 -19132, /* B1 = -1.167725 */
9945 23252, /* B0 = 0.709595 */
9946 7, /* Internal filter scaling */
9947 159, /* Minimum in-band energy threshold */
9948 21, /* 21/32 in-band to broad-band ratio */
9949 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9950 },
9951 { /* f941_1477[] */
9952 17543, /* A1 = 1.07074 */
9953 -26220, /* A2 = -0.800201 */
9954 -3298, /* B2 = -0.100647 */
9955 0, /* B1 = 0 */
9956 3298, /* B0 = 0.100647 */
9957 12423, /* A1 = 0.75827 */
9958 -30036, /* A2 = -0.916626 */
9959 12651, /* B2 = 0.386078 */
9960 -2444, /* B1 = -0.14917 */
9961 12653, /* B0 = 0.386154 */
9962 23518, /* A1 = 1.435425 */
9963 -30745, /* A2 = -0.938293 */
9964 27282, /* B2 = 0.832581 */
9965 -22529, /* B1 = -1.375122 */
9966 27286, /* B0 = 0.832703 */
9967 7, /* Internal filter scaling */
9968 159, /* Minimum in-band energy threshold */
9969 21, /* 21/32 in-band to broad-band ratio */
9970 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9971 },
9972 { /* f942 */
9973 24104, /* A1 = -1.471252 */
9974 -32507, /* A2 = 0.992065 */
9975 -351, /* B2 = -0.010722 */
9976 0, /* B1 = 0.000000 */
9977 351, /* B0 = 0.010722 */
9978 23996, /* A1 = -1.464600 */
9979 -32671, /* A2 = 0.997040 */
9980 22848, /* B2 = 0.697266 */
9981 -16639, /* B1 = -1.015564 */
9982 22848, /* B0 = 0.697266 */
9983 24332, /* A1 = -1.485168 */
9984 -32673, /* A2 = 0.997101 */
9985 4906, /* B2 = 0.149727 */
9986 -3672, /* B1 = -0.224174 */
9987 4906, /* B0 = 0.149727 */
9988 5, /* Internal filter scaling */
9989 159, /* Minimum in-band energy threshold */
9990 21, /* 21/32 in-band to broad-band ratio */
9991 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9992 },
9993 { /* f950 */
9994 23967, /* A1 = -1.462830 */
9995 -32507, /* A2 = 0.992065 */
9996 -518, /* B2 = -0.015821 */
9997 0, /* B1 = 0.000000 */
9998 518, /* B0 = 0.015821 */
9999 23856, /* A1 = -1.456055 */
10000 -32671, /* A2 = 0.997040 */
10001 26287, /* B2 = 0.802246 */
10002 -19031, /* B1 = -1.161560 */
10003 26287, /* B0 = 0.802246 */
10004 24195, /* A1 = -1.476746 */
10005 -32673, /* A2 = 0.997101 */
10006 2890, /* B2 = 0.088196 */
10007 -2151, /* B1 = -0.131317 */
10008 2890, /* B0 = 0.088196 */
10009 5, /* Internal filter scaling */
10010 159, /* Minimum in-band energy threshold */
10011 21, /* 21/32 in-band to broad-band ratio */
10012 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10013 },
10014 { /* f950_1400[] */
10015 18294, /* A1 = 1.116638 */
10016 -26962, /* A2 = -0.822845 */
10017 -2914, /* B2 = -0.088936 */
10018 0, /* B1 = 0 */
10019 2914, /* B0 = 0.088936 */
10020 14119, /* A1 = 0.861786 */
10021 -30227, /* A2 = -0.922455 */
10022 11466, /* B2 = 0.349945 */
10023 -2833, /* B1 = -0.172943 */
10024 11466, /* B0 = 0.349945 */
10025 23431, /* A1 = 1.430115 */
10026 -30828, /* A2 = -0.940796 */
10027 25331, /* B2 = 0.773071 */
10028 -20911, /* B1 = -1.276367 */
10029 25331, /* B0 = 0.773071 */
10030 7, /* Internal filter scaling */
10031 159, /* Minimum in-band energy threshold */
10032 21, /* 21/32 in-band to broad-band ratio */
10033 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10034 },
10035 { /* f975 */
10036 23521, /* A1 = -1.435608 */
10037 -32489, /* A2 = 0.991516 */
10038 -193, /* B2 = -0.005915 */
10039 0, /* B1 = 0.000000 */
10040 193, /* B0 = 0.005915 */
10041 23404, /* A1 = -1.428467 */
10042 -32655, /* A2 = 0.996582 */
10043 17740, /* B2 = 0.541412 */
10044 -12567, /* B1 = -0.767029 */
10045 17740, /* B0 = 0.541412 */
10046 23753, /* A1 = -1.449829 */
10047 -32657, /* A2 = 0.996613 */
10048 9090, /* B2 = 0.277405 */
10049 -6662, /* B1 = -0.406647 */
10050 9090, /* B0 = 0.277405 */
10051 5, /* Internal filter scaling */
10052 159, /* Minimum in-band energy threshold */
10053 21, /* 21/32 in-band to broad-band ratio */
10054 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10055 },
10056 { /* f1000 */
10057 23071, /* A1 = -1.408203 */
10058 -32489, /* A2 = 0.991516 */
10059 -293, /* B2 = -0.008965 */
10060 0, /* B1 = 0.000000 */
10061 293, /* B0 = 0.008965 */
10062 22951, /* A1 = -1.400818 */
10063 -32655, /* A2 = 0.996582 */
10064 5689, /* B2 = 0.173645 */
10065 -3951, /* B1 = -0.241150 */
10066 5689, /* B0 = 0.173645 */
10067 23307, /* A1 = -1.422607 */
10068 -32657, /* A2 = 0.996613 */
10069 18692, /* B2 = 0.570435 */
10070 -13447, /* B1 = -0.820770 */
10071 18692, /* B0 = 0.570435 */
10072 5, /* Internal filter scaling */
10073 159, /* Minimum in-band energy threshold */
10074 21, /* 21/32 in-band to broad-band ratio */
10075 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10076 },
10077 { /* f1020 */
10078 22701, /* A1 = -1.385620 */
10079 -32474, /* A2 = 0.991058 */
10080 -292, /* B2 = -0.008933 */
10081 0, /*163840 , B1 = 10.000000 */
10082 292, /* B0 = 0.008933 */
10083 22564, /* A1 = -1.377258 */
10084 -32655, /* A2 = 0.996552 */
10085 20756, /* B2 = 0.633423 */
10086 -14176, /* B1 = -0.865295 */
10087 20756, /* B0 = 0.633423 */
10088 22960, /* A1 = -1.401428 */
10089 -32657, /* A2 = 0.996613 */
10090 6520, /* B2 = 0.198990 */
10091 -4619, /* B1 = -0.281937 */
10092 6520, /* B0 = 0.198990 */
10093 5, /* Internal filter scaling */
10094 159, /* Minimum in-band energy threshold */
10095 21, /* 21/32 in-band to broad-band ratio */
10096 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10097 },
10098 { /* f1050 */
10099 22142, /* A1 = -1.351501 */
10100 -32474, /* A2 = 0.991058 */
10101 -147, /* B2 = -0.004493 */
10102 0, /* B1 = 0.000000 */
10103 147, /* B0 = 0.004493 */
10104 22000, /* A1 = -1.342834 */
10105 -32655, /* A2 = 0.996552 */
10106 15379, /* B2 = 0.469360 */
10107 -10237, /* B1 = -0.624847 */
10108 15379, /* B0 = 0.469360 */
10109 22406, /* A1 = -1.367554 */
10110 -32657, /* A2 = 0.996613 */
10111 17491, /* B2 = 0.533783 */
10112 -12096, /* B1 = -0.738312 */
10113 17491, /* B0 = 0.533783 */
10114 5, /* Internal filter scaling */
10115 159, /* Minimum in-band energy threshold */
10116 21, /* 21/32 in-band to broad-band ratio */
10117 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10118 },
10119 { /* f1100_1750[] */
10120 12973, /* A1 = 0.79184 */
10121 -24916, /* A2 = -0.760376 */
10122 6655, /* B2 = 0.203102 */
10123 367, /* B1 = 0.0224 */
10124 6657, /* B0 = 0.203171 */
10125 5915, /* A1 = 0.361053 */
10126 -29560, /* A2 = -0.90213 */
10127 -7777, /* B2 = -0.23735 */
10128 0, /* B1 = 0 */
10129 7777, /* B0 = 0.23735 */
10130 20510, /* A1 = 1.251892 */
10131 -30260, /* A2 = -0.923462 */
10132 26662, /* B2 = 0.81366 */
10133 -20573, /* B1 = -1.255737 */
10134 26668, /* B0 = 0.813843 */
10135 7, /* Internal filter scaling */
10136 159, /* Minimum in-band energy threshold */
10137 21, /* 21/32 in-band to broad-band ratio */
10138 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10139 },
10140 { /* f1140 */
10141 20392, /* A1 = -1.244629 */
10142 -32460, /* A2 = 0.990601 */
10143 -270, /* B2 = -0.008240 */
10144 0, /* B1 = 0.000000 */
10145 270, /* B0 = 0.008240 */
10146 20218, /* A1 = -1.234009 */
10147 -32655, /* A2 = 0.996582 */
10148 21337, /* B2 = 0.651154 */
10149 -13044, /* B1 = -0.796143 */
10150 21337, /* B0 = 0.651154 */
10151 20684, /* A1 = -1.262512 */
10152 -32657, /* A2 = 0.996643 */
10153 8572, /* B2 = 0.261612 */
10154 -5476, /* B1 = -0.334244 */
10155 8572, /* B0 = 0.261612 */
10156 5, /* Internal filter scaling */
10157 159, /* Minimum in-band energy threshold */
10158 21, /* 21/32 in-band to broad-band ratio */
10159 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10160 },
10161 { /* f1200 */
10162 19159, /* A1 = -1.169373 */
10163 -32456, /* A2 = 0.990509 */
10164 -335, /* B2 = -0.010252 */
10165 0, /* B1 = 0.000000 */
10166 335, /* B0 = 0.010252 */
10167 18966, /* A1 = -1.157593 */
10168 -32661, /* A2 = 0.996735 */
10169 6802, /* B2 = 0.207588 */
10170 -3900, /* B1 = -0.238098 */
10171 6802, /* B0 = 0.207588 */
10172 19467, /* A1 = -1.188232 */
10173 -32661, /* A2 = 0.996765 */
10174 25035, /* B2 = 0.764008 */
10175 -15049, /* B1 = -0.918579 */
10176 25035, /* B0 = 0.764008 */
10177 5, /* Internal filter scaling */
10178 159, /* Minimum in-band energy threshold */
10179 21, /* 21/32 in-band to broad-band ratio */
10180 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10181 },
10182 { /* f1209 */
10183 18976, /* A1 = -1.158264 */
10184 -32439, /* A2 = 0.989990 */
10185 -183, /* B2 = -0.005588 */
10186 0, /* B1 = 0.000000 */
10187 183, /* B0 = 0.005588 */
10188 18774, /* A1 = -1.145874 */
10189 -32650, /* A2 = 0.996429 */
10190 15468, /* B2 = 0.472076 */
10191 -8768, /* B1 = -0.535217 */
10192 15468, /* B0 = 0.472076 */
10193 19300, /* A1 = -1.177979 */
10194 -32652, /* A2 = 0.996490 */
10195 19840, /* B2 = 0.605499 */
10196 -11842, /* B1 = -0.722809 */
10197 19840, /* B0 = 0.605499 */
10198 5, /* Internal filter scaling */
10199 159, /* Minimum in-band energy threshold */
10200 21, /* 21/32 in-band to broad-band ratio */
10201 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10202 },
10203 { /* f1330 */
10204 16357, /* A1 = -0.998413 */
10205 -32368, /* A2 = 0.987793 */
10206 -217, /* B2 = -0.006652 */
10207 0, /* B1 = 0.000000 */
10208 217, /* B0 = 0.006652 */
10209 16107, /* A1 = -0.983126 */
10210 -32601, /* A2 = 0.994904 */
10211 11602, /* B2 = 0.354065 */
10212 -5555, /* B1 = -0.339111 */
10213 11602, /* B0 = 0.354065 */
10214 16722, /* A1 = -1.020630 */
10215 -32603, /* A2 = 0.994965 */
10216 15574, /* B2 = 0.475311 */
10217 -8176, /* B1 = -0.499069 */
10218 15574, /* B0 = 0.475311 */
10219 5, /* Internal filter scaling */
10220 159, /* Minimum in-band energy threshold */
10221 21, /* 21/32 in-band to broad-band ratio */
10222 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10223 },
10224 { /* f1336 */
10225 16234, /* A1 = -0.990875 */
10226 32404, /* A2 = -0.988922 */
10227 -193, /* B2 = -0.005908 */
10228 0, /* B1 = 0.000000 */
10229 193, /* B0 = 0.005908 */
10230 15986, /* A1 = -0.975769 */
10231 -32632, /* A2 = 0.995880 */
10232 18051, /* B2 = 0.550903 */
10233 -8658, /* B1 = -0.528473 */
10234 18051, /* B0 = 0.550903 */
10235 16591, /* A1 = -1.012695 */
10236 -32634, /* A2 = 0.995941 */
10237 15736, /* B2 = 0.480240 */
10238 -8125, /* B1 = -0.495926 */
10239 15736, /* B0 = 0.480240 */
10240 5, /* Internal filter scaling */
10241 159, /* Minimum in-band energy threshold */
10242 21, /* 21/32 in-band to broad-band ratio */
10243 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10244 },
10245 { /* f1366 */
10246 15564, /* A1 = -0.949982 */
10247 -32404, /* A2 = 0.988922 */
10248 -269, /* B2 = -0.008216 */
10249 0, /* B1 = 0.000000 */
10250 269, /* B0 = 0.008216 */
10251 15310, /* A1 = -0.934479 */
10252 -32632, /* A2 = 0.995880 */
10253 10815, /* B2 = 0.330063 */
10254 -4962, /* B1 = -0.302887 */
10255 10815, /* B0 = 0.330063 */
10256 15924, /* A1 = -0.971924 */
10257 -32634, /* A2 = 0.995941 */
10258 18880, /* B2 = 0.576172 */
10259 -9364, /* B1 = -0.571594 */
10260 18880, /* B0 = 0.576172 */
10261 5, /* Internal filter scaling */
10262 159, /* Minimum in-band energy threshold */
10263 21, /* 21/32 in-band to broad-band ratio */
10264 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10265 },
10266 { /* f1380 */
10267 15247, /* A1 = -0.930603 */
10268 -32397, /* A2 = 0.988708 */
10269 -244, /* B2 = -0.007451 */
10270 0, /* B1 = 0.000000 */
10271 244, /* B0 = 0.007451 */
10272 14989, /* A1 = -0.914886 */
10273 -32627, /* A2 = 0.995697 */
10274 18961, /* B2 = 0.578644 */
10275 -8498, /* B1 = -0.518707 */
10276 18961, /* B0 = 0.578644 */
10277 15608, /* A1 = -0.952667 */
10278 -32628, /* A2 = 0.995758 */
10279 11145, /* B2 = 0.340134 */
10280 -5430, /* B1 = -0.331467 */
10281 11145, /* B0 = 0.340134 */
10282 5, /* Internal filter scaling */
10283 159, /* Minimum in-band energy threshold */
10284 21, /* 21/32 in-band to broad-band ratio */
10285 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10286 },
10287 { /* f1400 */
10288 14780, /* A1 = -0.902130 */
10289 -32393, /* A2 = 0.988586 */
10290 -396, /* B2 = -0.012086 */
10291 0, /* B1 = 0.000000 */
10292 396, /* B0 = 0.012086 */
10293 14510, /* A1 = -0.885651 */
10294 -32630, /* A2 = 0.995819 */
10295 6326, /* B2 = 0.193069 */
10296 -2747, /* B1 = -0.167671 */
10297 6326, /* B0 = 0.193069 */
10298 15154, /* A1 = -0.924957 */
10299 -32632, /* A2 = 0.995850 */
10300 23235, /* B2 = 0.709076 */
10301 -10983, /* B1 = -0.670380 */
10302 23235, /* B0 = 0.709076 */
10303 5, /* Internal filter scaling */
10304 159, /* Minimum in-band energy threshold */
10305 21, /* 21/32 in-band to broad-band ratio */
10306 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10307 },
10308 { /* f1477 */
10309 13005, /* A1 = -0.793793 */
10310 -32368, /* A2 = 0.987823 */
10311 -500, /* B2 = -0.015265 */
10312 0, /* B1 = 0.000000 */
10313 500, /* B0 = 0.015265 */
10314 12708, /* A1 = -0.775665 */
10315 -32615, /* A2 = 0.995331 */
10316 11420, /* B2 = 0.348526 */
10317 -4306, /* B1 = -0.262833 */
10318 11420, /* B0 = 0.348526 */
10319 13397, /* A1 = -0.817688 */
10320 -32615, /* A2 = 0.995361 */
10321 9454, /* B2 = 0.288528 */
10322 -3981, /* B1 = -0.243027 */
10323 9454, /* B0 = 0.288528 */
10324 5, /* Internal filter scaling */
10325 159, /* Minimum in-band energy threshold */
10326 21, /* 21/32 in-band to broad-band ratio */
10327 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10328 },
10329 { /* f1600 */
10330 10046, /* A1 = -0.613190 */
10331 -32331, /* A2 = 0.986694 */
10332 -455, /* B2 = -0.013915 */
10333 0, /* B1 = 0.000000 */
10334 455, /* B0 = 0.013915 */
10335 9694, /* A1 = -0.591705 */
10336 -32601, /* A2 = 0.994934 */
10337 6023, /* B2 = 0.183815 */
10338 -1708, /* B1 = -0.104279 */
10339 6023, /* B0 = 0.183815 */
10340 10478, /* A1 = -0.639587 */
10341 -32603, /* A2 = 0.994965 */
10342 22031, /* B2 = 0.672333 */
10343 -7342, /* B1 = -0.448151 */
10344 22031, /* B0 = 0.672333 */
10345 5, /* Internal filter scaling */
10346 159, /* Minimum in-band energy threshold */
10347 21, /* 21/32 in-band to broad-band ratio */
10348 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10349 },
10350 { /* f1633_1638[] */
10351 9181, /* A1 = 0.560394 */
10352 -32256, /* A2 = -0.984375 */
10353 -556, /* B2 = -0.016975 */
10354 0, /* B1 = 0 */
10355 556, /* B0 = 0.016975 */
10356 8757, /* A1 = 0.534515 */
10357 -32574, /* A2 = -0.99408 */
10358 8443, /* B2 = 0.25769 */
10359 -2135, /* B1 = -0.130341 */
10360 8443, /* B0 = 0.25769 */
10361 9691, /* A1 = 0.591522 */
10362 -32574, /* A2 = -0.99411 */
10363 15446, /* B2 = 0.471375 */
10364 -4809, /* B1 = -0.293579 */
10365 15446, /* B0 = 0.471375 */
10366 7, /* Internal filter scaling */
10367 159, /* Minimum in-band energy threshold */
10368 21, /* 21/32 in-band to broad-band ratio */
10369 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10370 },
10371 { /* f1800 */
10372 5076, /* A1 = -0.309875 */
10373 -32304, /* A2 = 0.985840 */
10374 -508, /* B2 = -0.015503 */
10375 0, /* B1 = 0.000000 */
10376 508, /* B0 = 0.015503 */
10377 4646, /* A1 = -0.283600 */
10378 -32605, /* A2 = 0.995026 */
10379 6742, /* B2 = 0.205780 */
10380 -878, /* B1 = -0.053635 */
10381 6742, /* B0 = 0.205780 */
10382 5552, /* A1 = -0.338928 */
10383 -32605, /* A2 = 0.995056 */
10384 23667, /* B2 = 0.722260 */
10385 -4297, /* B1 = -0.262329 */
10386 23667, /* B0 = 0.722260 */
10387 5, /* Internal filter scaling */
10388 159, /* Minimum in-band energy threshold */
10389 21, /* 21/32 in-band to broad-band ratio */
10390 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10391 },
10392 { /* f1860 */
10393 3569, /* A1 = -0.217865 */
10394 -32292, /* A2 = 0.985504 */
10395 -239, /* B2 = -0.007322 */
10396 0, /* B1 = 0.000000 */
10397 239, /* B0 = 0.007322 */
10398 3117, /* A1 = -0.190277 */
10399 -32603, /* A2 = 0.994965 */
10400 18658, /* B2 = 0.569427 */
10401 -1557, /* B1 = -0.095032 */
10402 18658, /* B0 = 0.569427 */
10403 4054, /* A1 = -0.247437 */
10404 -32603, /* A2 = 0.994965 */
10405 18886, /* B2 = 0.576385 */
10406 -2566, /* B1 = -0.156647 */
10407 18886, /* B0 = 0.576385 */
10408 5, /* Internal filter scaling */
10409 159, /* Minimum in-band energy threshold */
10410 21, /* 21/32 in-band to broad-band ratio */
10411 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10412 },
10413};
10414static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10415{
10416 unsigned short cmd;
10417 int cnt, max;
10418
10419 if (jf->filter > 3) {
10420 return -1;
10421 }
10422 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10423
10424 return -1;
10425 if (!jf->enable) {
10426 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10427
10428 return -1;
10429 else
10430 return 0;
10431 } else {
10432 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10433
10434 return -1;
10435 /* Select the filter (f0 - f3) to use. */
10436 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10437 return -1;
10438 }
10439 if (jf->freq < 12 && jf->freq > 3) {
10440 /* Select the frequency for the selected filter. */
10441 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10442 return -1;
10443 } else if (jf->freq > 11) {
10444 /* We need to load a programmable filter set for undefined */
10445 /* frequencies. So we will point the filter to a programmable set. */
10446 /* Since there are only 4 filters and 4 programmable sets, we will */
10447 /* just point the filter to the same number set and program it for the */
10448 /* frequency we want. */
10449 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10450 return -1;
10451 if (j->ver.low != 0x12) {
10452 cmd = 0x515B;
10453 max = 19;
10454 } else {
10455 cmd = 0x515E;
10456 max = 15;
10457 }
10458 if (ixj_WriteDSPCommand(cmd, j))
10459 return -1;
10460 for (cnt = 0; cnt < max; cnt++) {
10461 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10462 return -1;
10463 }
10464 }
10465 j->filter_en[jf->filter] = jf->enable;
10466 return 0;
10467}
10468
10469static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10470{
10471 unsigned short cmd;
10472 int cnt, max;
10473 if (jfr->filter > 3) {
10474 return -1;
10475 }
10476 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10477 return -1;
10478
10479 if (!jfr->enable) {
10480 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10481 return -1;
10482 else
10483 return 0;
10484 } else {
10485 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10486 return -1;
10487 /* Select the filter (f0 - f3) to use. */
10488 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10489 return -1;
10490 }
10491 /* We need to load a programmable filter set for undefined */
10492 /* frequencies. So we will point the filter to a programmable set. */
10493 /* Since there are only 4 filters and 4 programmable sets, we will */
10494 /* just point the filter to the same number set and program it for the */
10495 /* frequency we want. */
10496 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10497 return -1;
10498 if (j->ver.low != 0x12) {
10499 cmd = 0x515B;
10500 max = 19;
10501 } else {
10502 cmd = 0x515E;
10503 max = 15;
10504 }
10505 if (ixj_WriteDSPCommand(cmd, j))
10506 return -1;
10507 for (cnt = 0; cnt < max; cnt++) {
10508 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10509 return -1;
10510 }
10511 j->filter_en[jfr->filter] = jfr->enable;
10512 return 0;
10513}
10514
10515static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10516{
10517 int freq0, freq1;
10518 unsigned short data;
10519 if (ti->freq0) {
10520 freq0 = ti->freq0;
10521 } else {
10522 freq0 = 0x7FFF;
10523 }
10524
10525 if (ti->freq1) {
10526 freq1 = ti->freq1;
10527 } else {
10528 freq1 = 0x7FFF;
10529 }
10530
10531 if(ti->tone_index > 12 && ti->tone_index < 28)
10532 {
10533 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10534 return -1;
10535 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10536 return -1;
10537 data = freq0;
10538 if (ixj_WriteDSPCommand(data, j))
10539 return -1;
10540 data = freq1;
10541 if (ixj_WriteDSPCommand(data, j))
10542 return -1;
10543 }
10544 return freq0;
10545}
10546