Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm / b0438a1b71955c425c304a2a483765ef24841766 / . / drivers / telephony / ixj.c
blob: 2d1280a7a52b791c0fa8b1048142132575331ef1 [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/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]45 * Revision 4.8 2003/07/09 19:39:00 Daniele Bellucci
46 * Audit some copy_*_user and minor cleanup.
47 *
48 * Revision 4.7 2001/08/13 06:19:33 craigs
49 * Added additional changes from Alan Cox and John Anderson for
50 * 2.2 to 2.4 cleanup and bounds checking
51 *
52 * Revision 4.6 2001/08/13 01:05:05 craigs
53 * Really fixed PHONE_QUERY_CODEC problem this time
54 *
55 * Revision 4.5 2001/08/13 00:11:03 craigs
56 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
57 *
58 * Revision 4.4 2001/08/07 07:58:12 craigs
59 * Changed back to three digit version numbers
60 * Added tagbuild target to allow automatic and easy tagging of versions
61 *
62 * Revision 4.3 2001/08/07 07:24:47 craigs
63 * Added ixj-ver.h to allow easy configuration management of driver
64 * Added display of version number in /prox/ixj
65 *
66 * Revision 4.2 2001/08/06 07:07:19 craigs
67 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
68 * behaviour of returning int rather than short *
69 *
70 * Revision 4.1 2001/08/05 00:17:37 craigs
71 * More changes for correct PCMCIA installation
72 * Start of changes for backward Linux compatibility
73 *
74 * Revision 4.0 2001/08/04 12:33:12 craigs
75 * New version using GNU autoconf
76 *
77 * Revision 3.105 2001/07/20 23:14:32 eokerson
78 * More work on CallerID generation when using ring cadences.
79 *
80 * Revision 3.104 2001/07/06 01:33:55 eokerson
81 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
82 *
83 * Revision 3.103 2001/07/05 19:20:16 eokerson
84 * Updated HOWTO
85 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
86 *
87 * Revision 3.102 2001/07/03 23:51:21 eokerson
88 * Un-mute mic on Internet LineJACK when in speakerphone mode.
89 *
90 * Revision 3.101 2001/07/02 19:26:56 eokerson
91 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
92 *
93 * Revision 3.100 2001/07/02 19:18:27 eokerson
94 * Changed driver to make dynamic allocation possible. We now pass IXJ * between functions instead of array indexes.
95 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
96 * Fixed speaker mode on Internet LineJACK.
97 *
98 * Revision 3.99 2001/05/09 14:11:16 eokerson
99 * Fixed kmalloc error in ixj_build_filter_cadence. Thanks David Chan <cat@waulogy.stanford.edu>.
100 *
101 * Revision 3.98 2001/05/08 19:55:33 eokerson
102 * Fixed POTS hookstate detection while it is connected to PSTN port.
103 *
104 * Revision 3.97 2001/05/08 00:01:04 eokerson
105 * Fixed kernel oops when sending caller ID data.
106 *
107 * Revision 3.96 2001/05/04 23:09:30 eokerson
108 * Now uses one kernel timer for each card, instead of one for the entire driver.
109 *
110 * Revision 3.95 2001/04/25 22:06:47 eokerson
111 * Fixed squawking at beginning of some G.723.1 calls.
112 *
113 * Revision 3.94 2001/04/03 23:42:00 eokerson
114 * Added linear volume ioctls
115 * Added raw filter load ioctl
116 *
117 * Revision 3.93 2001/02/27 01:00:06 eokerson
118 * Fixed blocking in CallerID.
119 * Reduced size of ixj structure for smaller driver footprint.
120 *
121 * Revision 3.92 2001/02/20 22:02:59 eokerson
122 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
123 * Improved PSTN ring detection.
124 * Fixed wink generation on POTS ports.
125 *
126 * Revision 3.91 2001/02/13 00:55:44 eokerson
127 * Turn AEC back on after changing frame sizes.
128 *
129 * Revision 3.90 2001/02/12 16:42:00 eokerson
130 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
131 *
132 * Revision 3.89 2001/02/12 15:41:16 eokerson
133 * Fix from Artis Kugevics - Tone gains were not being set correctly.
134 *
135 * Revision 3.88 2001/02/05 23:25:42 eokerson
136 * Fixed lockup bugs with deregister.
137 *
138 * Revision 3.87 2001/01/29 21:00:39 eokerson
139 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
140 * Updated copyright date.
141 *
142 * Revision 3.86 2001/01/23 23:53:46 eokerson
143 * Fixes to G.729 compatibility.
144 *
145 * Revision 3.85 2001/01/23 21:30:36 eokerson
146 * Added verbage about cards supported.
147 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
148 *
149 * Revision 3.84 2001/01/22 23:32:10 eokerson
150 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
151 *
152 * Revision 3.83 2001/01/19 14:51:41 eokerson
153 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
154 *
155 * Revision 3.82 2001/01/19 00:34:49 eokerson
156 * Added verbosity to write overlap errors.
157 *
158 * Revision 3.81 2001/01/18 23:56:54 eokerson
159 * Fixed PSTN line test functions.
160 *
161 * Revision 3.80 2001/01/18 22:29:27 eokerson
162 * Updated AEC/AGC values for different cards.
163 *
164 * Revision 3.79 2001/01/17 02:58:54 eokerson
165 * Fixed AEC reset after Caller ID.
166 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
167 *
168 * Revision 3.78 2001/01/16 19:43:09 eokerson
169 * Added support for Linux 2.4.x kernels.
170 *
171 * Revision 3.77 2001/01/09 04:00:52 eokerson
172 * Linetest will now test the line, even if it has previously succeded.
173 *
174 * Revision 3.76 2001/01/08 19:27:00 eokerson
175 * Fixed problem with standard cable on Internet PhoneCARD.
176 *
177 * Revision 3.75 2000/12/22 16:52:14 eokerson
178 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
179 *
180 * Revision 3.74 2000/12/08 22:41:50 eokerson
181 * Added capability for G729B.
182 *
183 * Revision 3.73 2000/12/07 23:35:16 eokerson
184 * Added capability to have different ring pattern before CallerID data.
185 * Added hookstate checks in CallerID routines to stop FSK.
186 *
187 * Revision 3.72 2000/12/06 19:31:31 eokerson
188 * Modified signal behavior to only send one signal per event.
189 *
190 * Revision 3.71 2000/12/06 03:23:08 eokerson
191 * Fixed CallerID on Call Waiting.
192 *
193 * Revision 3.70 2000/12/04 21:29:37 eokerson
194 * Added checking to Smart Cable gain functions.
195 *
196 * Revision 3.69 2000/12/04 21:05:20 eokerson
197 * Changed ixjdebug levels.
198 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
199 *
200 * Revision 3.68 2000/12/04 00:17:21 craigs
201 * Changed mixer voice gain to +6dB rather than 0dB
202 *
203 * Revision 3.67 2000/11/30 21:25:51 eokerson
204 * Fixed write signal errors.
205 *
206 * Revision 3.66 2000/11/29 22:42:44 eokerson
207 * Fixed PSTN ring detect problems.
208 *
209 * Revision 3.65 2000/11/29 07:31:55 craigs
210 * Added new 425Hz filter co-efficients
211 * Added card-specific DTMF prescaler initialisation
212 *
213 * Revision 3.64 2000/11/28 14:03:32 craigs
214 * Changed certain mixer initialisations to be 0dB rather than 12dB
215 * Added additional information to /proc/ixj
216 *
217 * Revision 3.63 2000/11/28 11:38:41 craigs
218 * Added display of AEC modes in AUTO and AGC mode
219 *
220 * Revision 3.62 2000/11/28 04:05:44 eokerson
221 * Improved PSTN ring detection routine.
222 *
223 * Revision 3.61 2000/11/27 21:53:12 eokerson
224 * Fixed flash detection.
225 *
226 * Revision 3.60 2000/11/27 15:57:29 eokerson
227 * More work on G.729 load routines.
228 *
229 * Revision 3.59 2000/11/25 21:55:12 eokerson
230 * Fixed errors in G.729 load routine.
231 *
232 * Revision 3.58 2000/11/25 04:08:29 eokerson
233 * Added board locks around G.729 and TS85 load routines.
234 *
235 * Revision 3.57 2000/11/24 05:35:17 craigs
236 * Added ability to retrieve mixer values on LineJACK
237 * Added complete initialisation of all mixer values at startup
238 * Fixed spelling mistake
239 *
240 * Revision 3.56 2000/11/23 02:52:11 robertj
241 * Added cvs change log keyword.
242 * Fixed bug in capabilities list when using G.729 module.
243 *
244 */
245
246#include "ixj-ver.h"
247
248#define PERFMON_STATS
249#define IXJDEBUG 0
250#define MAXRINGS 5
251
252#include <linux/module.h>
253
254#include <linux/init.h>
255#include <linux/sched.h>
256#include <linux/kernel.h> /* printk() */
257#include <linux/fs.h> /* everything... */
258#include <linux/errno.h> /* error codes */
259#include <linux/slab.h>
Arnd Bergmann613655f2010-06-02 14:28:52 +0200[diff] [blame]260#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]261#include <linux/mm.h>
262#include <linux/ioport.h>
263#include <linux/interrupt.h>
264#include <linux/proc_fs.h>
265#include <linux/poll.h>
266#include <linux/timer.h>
267#include <linux/delay.h>
268#include <linux/pci.h>
269
270#include <asm/io.h>
271#include <asm/uaccess.h>
272
273#include <linux/isapnp.h>
274
275#include "ixj.h"
276
277#define TYPE(inode) (iminor(inode) >> 4)
278#define NUM(inode) (iminor(inode) & 0xf)
279
Arnd Bergmann613655f2010-06-02 14:28:52 +0200[diff] [blame]280static DEFINE_MUTEX(ixj_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]281static int ixjdebug;
282static int hertz = HZ;
283static int samplerate = 100;
284
285module_param(ixjdebug, int, 0);
286
Ben Collinsd77f09e2006-10-18 08:45:30 -0400[diff] [blame]287static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
288 { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
289 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
290 { }
291};
292
293MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
294
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]295/************************************************************************
296*
297* ixjdebug meanings are now bit mapped instead of level based
298* Values can be or'ed together to turn on multiple messages
299*
300* bit 0 (0x0001) = any failure
301* bit 1 (0x0002) = general messages
302* bit 2 (0x0004) = POTS ringing related
303* bit 3 (0x0008) = PSTN events
304* bit 4 (0x0010) = PSTN Cadence state details
305* bit 5 (0x0020) = Tone detection triggers
306* bit 6 (0x0040) = Tone detection cadence details
307* bit 7 (0x0080) = ioctl tracking
308* bit 8 (0x0100) = signal tracking
309* bit 9 (0x0200) = CallerID generation details
310*
311************************************************************************/
312
313#ifdef IXJ_DYN_ALLOC
314
315static IXJ *ixj[IXJMAX];
316#define get_ixj(b) ixj[(b)]
317
318/*
319 * Allocate a free IXJ device
320 */
321
322static IXJ *ixj_alloc()
323{
324 for(cnt=0; cnt<IXJMAX; cnt++)
325 {
326 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
327 {
328 j = kmalloc(sizeof(IXJ), GFP_KERNEL);
329 if (j == NULL)
330 return NULL;
331 ixj[cnt] = j;
332 return j;
333 }
334 }
335 return NULL;
336}
337
338static void ixj_fsk_free(IXJ *j)
339{
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]340 kfree(j->fskdata);
341 j->fskdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]342}
343
344static void ixj_fsk_alloc(IXJ *j)
345{
346 if(!j->fskdata) {
347 j->fskdata = kmalloc(8000, GFP_KERNEL);
348 if (!j->fskdata) {
349 if(ixjdebug & 0x0200) {
350 printk("IXJ phone%d - allocate failed\n", j->board);
351 }
352 return;
353 } else {
354 j->fsksize = 8000;
355 if(ixjdebug & 0x0200) {
356 printk("IXJ phone%d - allocate succeded\n", j->board);
357 }
358 }
359 }
360}
361
362#else
363
364static IXJ ixj[IXJMAX];
365#define get_ixj(b) (&ixj[(b)])
366
367/*
368 * Allocate a free IXJ device
369 */
370
371static IXJ *ixj_alloc(void)
372{
373 int cnt;
374 for(cnt=0; cnt<IXJMAX; cnt++) {
375 if(!ixj[cnt].DSPbase)
376 return &ixj[cnt];
377 }
378 return NULL;
379}
380
381static inline void ixj_fsk_free(IXJ *j) {;}
382
383static inline void ixj_fsk_alloc(IXJ *j)
384{
385 j->fsksize = 8000;
386}
387
388#endif
389
390#ifdef PERFMON_STATS
391#define ixj_perfmon(x) ((x)++)
392#else
393#define ixj_perfmon(x) do { } while(0)
394#endif
395
396static int ixj_convert_loaded;
397
398static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
399
400/************************************************************************
401*
402* These are function definitions to allow external modules to register
403* enhanced functionality call backs.
404*
405************************************************************************/
406
407static int Stub(IXJ * J, unsigned long arg)
408{
409 return 0;
410}
411
412static IXJ_REGFUNC ixj_PreRead = &Stub;
413static IXJ_REGFUNC ixj_PostRead = &Stub;
414static IXJ_REGFUNC ixj_PreWrite = &Stub;
415static IXJ_REGFUNC ixj_PostWrite = &Stub;
416
417static void ixj_read_frame(IXJ *j);
418static void ixj_write_frame(IXJ *j);
419static void ixj_init_timer(IXJ *j);
420static void ixj_add_timer(IXJ * j);
421static void ixj_timeout(unsigned long ptr);
422static int read_filters(IXJ *j);
423static int LineMonitor(IXJ *j);
424static int ixj_fasync(int fd, struct file *, int mode);
425static int ixj_set_port(IXJ *j, int arg);
426static int ixj_set_pots(IXJ *j, int arg);
427static int ixj_hookstate(IXJ *j);
428static int ixj_record_start(IXJ *j);
429static void ixj_record_stop(IXJ *j);
430static void set_rec_volume(IXJ *j, int volume);
431static int get_rec_volume(IXJ *j);
432static int set_rec_codec(IXJ *j, int rate);
433static void ixj_vad(IXJ *j, int arg);
434static int ixj_play_start(IXJ *j);
435static void ixj_play_stop(IXJ *j);
436static int ixj_set_tone_on(unsigned short arg, IXJ *j);
437static int ixj_set_tone_off(unsigned short, IXJ *j);
438static int ixj_play_tone(IXJ *j, char tone);
439static void ixj_aec_start(IXJ *j, int level);
440static int idle(IXJ *j);
441static void ixj_ring_on(IXJ *j);
442static void ixj_ring_off(IXJ *j);
443static void aec_stop(IXJ *j);
444static void ixj_ringback(IXJ *j);
445static void ixj_busytone(IXJ *j);
446static void ixj_dialtone(IXJ *j);
447static void ixj_cpt_stop(IXJ *j);
448static char daa_int_read(IXJ *j);
449static char daa_CR_read(IXJ *j, int cr);
450static int daa_set_mode(IXJ *j, int mode);
451static int ixj_linetest(IXJ *j);
452static int ixj_daa_write(IXJ *j);
453static int ixj_daa_cid_read(IXJ *j);
454static void DAA_Coeff_US(IXJ *j);
455static void DAA_Coeff_UK(IXJ *j);
456static void DAA_Coeff_France(IXJ *j);
457static void DAA_Coeff_Germany(IXJ *j);
458static void DAA_Coeff_Australia(IXJ *j);
459static void DAA_Coeff_Japan(IXJ *j);
460static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
461static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
462static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
463static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
464static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
465/* Serial Control Interface funtions */
466static int SCI_Control(IXJ *j, int control);
467static int SCI_Prepare(IXJ *j);
468static int SCI_WaitHighSCI(IXJ *j);
469static int SCI_WaitLowSCI(IXJ *j);
470static DWORD PCIEE_GetSerialNumber(WORD wAddress);
471static int ixj_PCcontrol_wait(IXJ *j);
472static void ixj_pre_cid(IXJ *j);
473static void ixj_write_cid(IXJ *j);
474static void ixj_write_cid_bit(IXJ *j, int bit);
475static int set_base_frame(IXJ *j, int size);
476static int set_play_codec(IXJ *j, int rate);
477static void set_rec_depth(IXJ *j, int depth);
478static int ixj_mixer(long val, IXJ *j);
479
480/************************************************************************
481CT8020/CT8021 Host Programmers Model
482Host address Function Access
483DSPbase +
4840-1 Aux Software Status Register (reserved) Read Only
4852-3 Software Status Register Read Only
4864-5 Aux Software Control Register (reserved) Read Write
4876-7 Software Control Register Read Write
4888-9 Hardware Status Register Read Only
489A-B Hardware Control Register Read Write
490C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
491E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
492************************************************************************/
493
494static inline void ixj_read_HSR(IXJ *j)
495{
496 j->hsr.bytes.low = inb_p(j->DSPbase + 8);
497 j->hsr.bytes.high = inb_p(j->DSPbase + 9);
498}
499
500static inline int IsControlReady(IXJ *j)
501{
502 ixj_read_HSR(j);
503 return j->hsr.bits.controlrdy ? 1 : 0;
504}
505
506static inline int IsPCControlReady(IXJ *j)
507{
508 j->pccr1.byte = inb_p(j->XILINXbase + 3);
509 return j->pccr1.bits.crr ? 1 : 0;
510}
511
512static inline int IsStatusReady(IXJ *j)
513{
514 ixj_read_HSR(j);
515 return j->hsr.bits.statusrdy ? 1 : 0;
516}
517
518static inline int IsRxReady(IXJ *j)
519{
520 ixj_read_HSR(j);
521 ixj_perfmon(j->rxreadycheck);
522 return j->hsr.bits.rxrdy ? 1 : 0;
523}
524
525static inline int IsTxReady(IXJ *j)
526{
527 ixj_read_HSR(j);
528 ixj_perfmon(j->txreadycheck);
529 return j->hsr.bits.txrdy ? 1 : 0;
530}
531
532static inline void set_play_volume(IXJ *j, int volume)
533{
534 if (ixjdebug & 0x0002)
535 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
536 ixj_WriteDSPCommand(0xCF02, j);
537 ixj_WriteDSPCommand(volume, j);
538}
539
540static int set_play_volume_linear(IXJ *j, int volume)
541{
542 int newvolume, dspplaymax;
543
544 if (ixjdebug & 0x0002)
545 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
546 if(volume > 100 || volume < 0) {
547 return -1;
548 }
549
550 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
551 switch (j->cardtype) {
552 case QTI_PHONEJACK:
553 dspplaymax = 0x380;
554 break;
555 case QTI_LINEJACK:
556 if(j->port == PORT_PSTN) {
557 dspplaymax = 0x48;
558 } else {
559 dspplaymax = 0x100;
560 }
561 break;
562 case QTI_PHONEJACK_LITE:
563 dspplaymax = 0x380;
564 break;
565 case QTI_PHONEJACK_PCI:
566 dspplaymax = 0x6C;
567 break;
568 case QTI_PHONECARD:
569 dspplaymax = 0x50;
570 break;
571 default:
572 return -1;
573 }
574 newvolume = (dspplaymax * volume) / 100;
575 set_play_volume(j, newvolume);
576 return 0;
577}
578
579static inline void set_play_depth(IXJ *j, int depth)
580{
581 if (depth > 60)
582 depth = 60;
583 if (depth < 0)
584 depth = 0;
585 ixj_WriteDSPCommand(0x5280 + depth, j);
586}
587
588static inline int get_play_volume(IXJ *j)
589{
590 ixj_WriteDSPCommand(0xCF00, j);
591 return j->ssr.high << 8 | j->ssr.low;
592}
593
594static int get_play_volume_linear(IXJ *j)
595{
596 int volume, newvolume, dspplaymax;
597
598 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
599 switch (j->cardtype) {
600 case QTI_PHONEJACK:
601 dspplaymax = 0x380;
602 break;
603 case QTI_LINEJACK:
604 if(j->port == PORT_PSTN) {
605 dspplaymax = 0x48;
606 } else {
607 dspplaymax = 0x100;
608 }
609 break;
610 case QTI_PHONEJACK_LITE:
611 dspplaymax = 0x380;
612 break;
613 case QTI_PHONEJACK_PCI:
614 dspplaymax = 0x6C;
615 break;
616 case QTI_PHONECARD:
617 dspplaymax = 100;
618 break;
619 default:
620 return -1;
621 }
622 volume = get_play_volume(j);
623 newvolume = (volume * 100) / dspplaymax;
624 if(newvolume > 100)
625 newvolume = 100;
626 return newvolume;
627}
628
629static inline BYTE SLIC_GetState(IXJ *j)
630{
631 if (j->cardtype == QTI_PHONECARD) {
632 j->pccr1.byte = 0;
633 j->psccr.bits.dev = 3;
634 j->psccr.bits.rw = 1;
635 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
636 ixj_PCcontrol_wait(j);
637 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
638 ixj_PCcontrol_wait(j);
639 if (j->pslic.bits.powerdown)
640 return PLD_SLIC_STATE_OC;
641 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
642 return PLD_SLIC_STATE_ACTIVE;
643 else
644 return PLD_SLIC_STATE_RINGING;
645 } else {
646 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
647 }
648 return j->pld_slicr.bits.state;
649}
650
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]651static bool SLIC_SetState(BYTE byState, IXJ *j)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]652{
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]653 bool fRetVal = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]654
655 if (j->cardtype == QTI_PHONECARD) {
656 if (j->flags.pcmciasct) {
657 switch (byState) {
658 case PLD_SLIC_STATE_TIPOPEN:
659 case PLD_SLIC_STATE_OC:
660 j->pslic.bits.powerdown = 1;
661 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]662 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]663 break;
664 case PLD_SLIC_STATE_RINGING:
665 if (j->readers || j->writers) {
666 j->pslic.bits.powerdown = 0;
667 j->pslic.bits.ring0 = 1;
668 j->pslic.bits.ring1 = 0;
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]669 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]670 }
671 break;
672 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
673
674 case PLD_SLIC_STATE_STANDBY:
675 case PLD_SLIC_STATE_ACTIVE:
676 if (j->readers || j->writers) {
677 j->pslic.bits.powerdown = 0;
678 } else {
679 j->pslic.bits.powerdown = 1;
680 }
681 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]682 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]683 break;
684 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
685
686 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
687
688 default:
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]689 fRetVal = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]690 break;
691 }
692 j->psccr.bits.dev = 3;
693 j->psccr.bits.rw = 0;
694 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
695 ixj_PCcontrol_wait(j);
696 }
697 } else {
698 /* Set the C1, C2, C3 & B2EN signals. */
699 switch (byState) {
700 case PLD_SLIC_STATE_OC:
701 j->pld_slicw.bits.c1 = 0;
702 j->pld_slicw.bits.c2 = 0;
703 j->pld_slicw.bits.c3 = 0;
704 j->pld_slicw.bits.b2en = 0;
705 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]706 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]707 break;
708 case PLD_SLIC_STATE_RINGING:
709 j->pld_slicw.bits.c1 = 1;
710 j->pld_slicw.bits.c2 = 0;
711 j->pld_slicw.bits.c3 = 0;
712 j->pld_slicw.bits.b2en = 1;
713 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]714 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]715 break;
716 case PLD_SLIC_STATE_ACTIVE:
717 j->pld_slicw.bits.c1 = 0;
718 j->pld_slicw.bits.c2 = 1;
719 j->pld_slicw.bits.c3 = 0;
720 j->pld_slicw.bits.b2en = 0;
721 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]722 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]723 break;
724 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
725
726 j->pld_slicw.bits.c1 = 1;
727 j->pld_slicw.bits.c2 = 1;
728 j->pld_slicw.bits.c3 = 0;
729 j->pld_slicw.bits.b2en = 0;
730 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]731 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]732 break;
733 case PLD_SLIC_STATE_TIPOPEN:
734 j->pld_slicw.bits.c1 = 0;
735 j->pld_slicw.bits.c2 = 0;
736 j->pld_slicw.bits.c3 = 1;
737 j->pld_slicw.bits.b2en = 0;
738 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]739 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]740 break;
741 case PLD_SLIC_STATE_STANDBY:
742 j->pld_slicw.bits.c1 = 1;
743 j->pld_slicw.bits.c2 = 0;
744 j->pld_slicw.bits.c3 = 1;
745 j->pld_slicw.bits.b2en = 1;
746 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]747 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]748 break;
749 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
750
751 j->pld_slicw.bits.c1 = 0;
752 j->pld_slicw.bits.c2 = 1;
753 j->pld_slicw.bits.c3 = 1;
754 j->pld_slicw.bits.b2en = 0;
755 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]756 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]757 break;
758 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
759
760 j->pld_slicw.bits.c1 = 1;
761 j->pld_slicw.bits.c2 = 1;
762 j->pld_slicw.bits.c3 = 1;
763 j->pld_slicw.bits.b2en = 0;
764 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]765 fRetVal = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]766 break;
767 default:
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]768 fRetVal = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]769 break;
770 }
771 }
772
773 return fRetVal;
774}
775
776static int ixj_wink(IXJ *j)
777{
778 BYTE slicnow;
779
780 slicnow = SLIC_GetState(j);
781
782 j->pots_winkstart = jiffies;
783 SLIC_SetState(PLD_SLIC_STATE_OC, j);
784
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]785 msleep(jiffies_to_msecs(j->winktime));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]786
787 SLIC_SetState(slicnow, j);
788 return 0;
789}
790
791static void ixj_init_timer(IXJ *j)
792{
793 init_timer(&j->timer);
794 j->timer.function = ixj_timeout;
795 j->timer.data = (unsigned long)j;
796}
797
798static void ixj_add_timer(IXJ *j)
799{
800 j->timer.expires = jiffies + (hertz / samplerate);
801 add_timer(&j->timer);
802}
803
804static void ixj_tone_timeout(IXJ *j)
805{
806 IXJ_TONE ti;
807
808 j->tone_state++;
809 if (j->tone_state == 3) {
810 j->tone_state = 0;
811 if (j->cadence_t) {
812 j->tone_cadence_state++;
813 if (j->tone_cadence_state >= j->cadence_t->elements_used) {
814 switch (j->cadence_t->termination) {
815 case PLAY_ONCE:
816 ixj_cpt_stop(j);
817 break;
818 case REPEAT_LAST_ELEMENT:
819 j->tone_cadence_state--;
820 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
821 break;
822 case REPEAT_ALL:
823 j->tone_cadence_state = 0;
824 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
825 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
826 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
827 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
828 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
829 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
830 ixj_init_tone(j, &ti);
831 }
832 ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
833 ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
834 ixj_play_tone(j, j->cadence_t->ce[0].index);
835 break;
836 }
837 } else {
838 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
839 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
840 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
841 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
842 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
843 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
844 ixj_init_tone(j, &ti);
845 }
846 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
847 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
848 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
849 }
850 }
851 }
852}
853
854static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
855{
856 if(j->ixj_signals[event]) {
857 if(ixjdebug & 0x0100)
858 printk("Sending signal for event %d\n", event);
859 /* Send apps notice of change */
860 /* see config.h for macro definition */
861 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
862 }
863}
864
865static void ixj_pstn_state(IXJ *j)
866{
867 int var;
868 union XOPXR0 XR0, daaint;
869
870 var = 10;
871
872 XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
873 daaint.reg = 0;
874 XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
875
876 j->pld_scrr.byte = inb_p(j->XILINXbase);
877 if (j->pld_scrr.bits.daaflag) {
878 daa_int_read(j);
879 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
880 if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
881 daaint.bitreg.RING = 1;
882 if(ixjdebug & 0x0008) {
883 printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
884 }
885 } else {
886 daa_set_mode(j, SOP_PU_RESET);
887 }
888 }
889 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
890 daaint.bitreg.Caller_ID = 1;
891 j->pstn_cid_intr = 1;
892 j->pstn_cid_received = jiffies;
893 if(ixjdebug & 0x0008) {
894 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
895 }
896 }
897 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
898 daaint.bitreg.Cadence = 1;
899 if(ixjdebug & 0x0008) {
900 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
901 }
902 }
903 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
904 daaint.bitreg.VDD_OK = 1;
905 daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
906 }
907 }
908 daa_CR_read(j, 1);
909 if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
910 daaint.bitreg.RMR = 1;
911 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
912 if(ixjdebug & 0x0008) {
913 printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
914 }
915 j->pstn_prev_rmr = j->pstn_last_rmr;
916 j->pstn_last_rmr = jiffies;
917 }
918 switch(j->daa_mode) {
919 case SOP_PU_SLEEP:
920 if (daaint.bitreg.RING) {
921 if (!j->flags.pstn_ringing) {
922 if (j->daa_mode != SOP_PU_RINGING) {
923 j->pstn_ring_int = jiffies;
924 daa_set_mode(j, SOP_PU_RINGING);
925 }
926 }
927 }
928 break;
929 case SOP_PU_RINGING:
930 if (daaint.bitreg.RMR) {
931 if (ixjdebug & 0x0008) {
932 printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
933 }
934 if (daaint.bitreg.SI_1) { /* Rising edge of RMR */
935 j->flags.pstn_rmr = 1;
936 j->pstn_ring_start = jiffies;
937 j->pstn_ring_stop = 0;
938 j->ex.bits.pstn_ring = 0;
939 if (j->cadence_f[4].state == 0) {
940 j->cadence_f[4].state = 1;
941 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
942 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
943 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
944 } else if (j->cadence_f[4].state == 2) {
945 if((time_after(jiffies, j->cadence_f[4].off1min) &&
946 time_before(jiffies, j->cadence_f[4].off1max))) {
947 if (j->cadence_f[4].on2) {
948 j->cadence_f[4].state = 3;
949 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
950 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
951 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
952 } else {
953 j->cadence_f[4].state = 7;
954 }
955 } else {
956 if (ixjdebug & 0x0008) {
957 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
958 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
959 j->cadence_f[4].off1);
960 }
961 j->cadence_f[4].state = 0;
962 }
963 } else if (j->cadence_f[4].state == 4) {
964 if((time_after(jiffies, j->cadence_f[4].off2min) &&
965 time_before(jiffies, j->cadence_f[4].off2max))) {
966 if (j->cadence_f[4].on3) {
967 j->cadence_f[4].state = 5;
968 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
969 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
970 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
971 } else {
972 j->cadence_f[4].state = 7;
973 }
974 } else {
975 if (ixjdebug & 0x0008) {
976 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
977 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
978 j->cadence_f[4].off2);
979 }
980 j->cadence_f[4].state = 0;
981 }
982 } else if (j->cadence_f[4].state == 6) {
983 if((time_after(jiffies, j->cadence_f[4].off3min) &&
984 time_before(jiffies, j->cadence_f[4].off3max))) {
985 j->cadence_f[4].state = 7;
986 } else {
987 if (ixjdebug & 0x0008) {
988 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
989 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
990 j->cadence_f[4].off3);
991 }
992 j->cadence_f[4].state = 0;
993 }
994 } else {
995 j->cadence_f[4].state = 0;
996 }
997 } else { /* Falling edge of RMR */
998 j->pstn_ring_start = 0;
999 j->pstn_ring_stop = jiffies;
1000 if (j->cadence_f[4].state == 1) {
1001 if(!j->cadence_f[4].on1) {
1002 j->cadence_f[4].state = 7;
1003 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1004 time_before(jiffies, j->cadence_f[4].on1max))) {
1005 if (j->cadence_f[4].off1) {
1006 j->cadence_f[4].state = 2;
1007 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1008 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1009 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1010 } else {
1011 j->cadence_f[4].state = 7;
1012 }
1013 } else {
1014 if (ixjdebug & 0x0008) {
1015 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1016 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1017 j->cadence_f[4].on1);
1018 }
1019 j->cadence_f[4].state = 0;
1020 }
1021 } else if (j->cadence_f[4].state == 3) {
1022 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1023 time_before(jiffies, j->cadence_f[4].on2max))) {
1024 if (j->cadence_f[4].off2) {
1025 j->cadence_f[4].state = 4;
1026 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1027 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1028 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1029 } else {
1030 j->cadence_f[4].state = 7;
1031 }
1032 } else {
1033 if (ixjdebug & 0x0008) {
1034 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1035 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1036 j->cadence_f[4].on2);
1037 }
1038 j->cadence_f[4].state = 0;
1039 }
1040 } else if (j->cadence_f[4].state == 5) {
1041 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1042 time_before(jiffies, j->cadence_f[4].on3max))) {
1043 if (j->cadence_f[4].off3) {
1044 j->cadence_f[4].state = 6;
1045 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1046 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1047 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1048 } else {
1049 j->cadence_f[4].state = 7;
1050 }
1051 } else {
1052 j->cadence_f[4].state = 0;
1053 }
1054 } else {
1055 if (ixjdebug & 0x0008) {
1056 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1057 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1058 j->cadence_f[4].on3);
1059 }
1060 j->cadence_f[4].state = 0;
1061 }
1062 }
1063 if (ixjdebug & 0x0010) {
1064 printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1065 }
1066 if (ixjdebug & 0x0010) {
1067 switch(j->cadence_f[4].state) {
1068 case 1:
1069 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1070 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1071 break;
1072 case 2:
1073 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1074 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1075 break;
1076 case 3:
1077 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1078 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1079 break;
1080 case 4:
1081 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1082 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1083 break;
1084 case 5:
1085 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1086 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1087 break;
1088 case 6:
1089 printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1090 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1091 break;
1092 }
1093 }
1094 }
1095 if (j->cadence_f[4].state == 7) {
1096 j->cadence_f[4].state = 0;
1097 j->pstn_ring_stop = jiffies;
1098 j->ex.bits.pstn_ring = 1;
1099 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1100 if(ixjdebug & 0x0008) {
1101 printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1102 }
1103 }
1104 if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1105 (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1106 if(ixjdebug & 0x0008) {
1107 printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1108 printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1109 printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1110 }
1111 j->pstn_ring_stop = j->pstn_ring_int = 0;
1112 daa_set_mode(j, SOP_PU_SLEEP);
1113 }
1114 outb_p(j->pld_scrw.byte, j->XILINXbase);
1115 if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1116 ixj_daa_cid_read(j);
1117 j->ex.bits.caller_id = 1;
1118 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1119 j->pstn_cid_intr = 0;
1120 }
1121 if (daaint.bitreg.Cadence) {
1122 if(ixjdebug & 0x0008) {
1123 printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1124 }
1125 daa_set_mode(j, SOP_PU_SLEEP);
1126 j->ex.bits.pstn_ring = 0;
1127 }
1128 break;
1129 case SOP_PU_CONVERSATION:
1130 if (daaint.bitreg.VDD_OK) {
1131 if(!daaint.bitreg.SI_0) {
1132 if (!j->pstn_winkstart) {
1133 if(ixjdebug & 0x0008) {
1134 printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1135 }
1136 j->pstn_winkstart = jiffies;
1137 }
1138 } else {
1139 if (j->pstn_winkstart) {
1140 if(ixjdebug & 0x0008) {
1141 printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1142 }
1143 j->pstn_winkstart = 0;
1144 }
1145 }
1146 }
1147 if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1148 if(ixjdebug & 0x0008) {
1149 printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1150 }
1151 daa_set_mode(j, SOP_PU_SLEEP);
1152 j->pstn_winkstart = 0;
1153 j->ex.bits.pstn_wink = 1;
1154 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1155 }
1156 break;
1157 }
1158}
1159
1160static void ixj_timeout(unsigned long ptr)
1161{
1162 int board;
1163 unsigned long jifon;
1164 IXJ *j = (IXJ *)ptr;
1165 board = j->board;
1166
1167 if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1168 ixj_perfmon(j->timerchecks);
1169 j->hookstate = ixj_hookstate(j);
1170 if (j->tone_state) {
1171 if (!(j->hookstate)) {
1172 ixj_cpt_stop(j);
1173 if (j->m_hook) {
1174 j->m_hook = 0;
1175 j->ex.bits.hookstate = 1;
1176 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1177 }
1178 clear_bit(board, &j->busyflags);
1179 ixj_add_timer(j);
1180 return;
1181 }
1182 if (j->tone_state == 1)
1183 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1184 else
1185 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1186 if (time_before(jiffies, j->tone_start_jif + jifon)) {
1187 if (j->tone_state == 1) {
1188 ixj_play_tone(j, j->tone_index);
1189 if (j->dsp.low == 0x20) {
1190 clear_bit(board, &j->busyflags);
1191 ixj_add_timer(j);
1192 return;
1193 }
1194 } else {
1195 ixj_play_tone(j, 0);
1196 if (j->dsp.low == 0x20) {
1197 clear_bit(board, &j->busyflags);
1198 ixj_add_timer(j);
1199 return;
1200 }
1201 }
1202 } else {
1203 ixj_tone_timeout(j);
1204 if (j->flags.dialtone) {
1205 ixj_dialtone(j);
1206 }
1207 if (j->flags.busytone) {
1208 ixj_busytone(j);
1209 if (j->dsp.low == 0x20) {
1210 clear_bit(board, &j->busyflags);
1211 ixj_add_timer(j);
1212 return;
1213 }
1214 }
1215 if (j->flags.ringback) {
1216 ixj_ringback(j);
1217 if (j->dsp.low == 0x20) {
1218 clear_bit(board, &j->busyflags);
1219 ixj_add_timer(j);
1220 return;
1221 }
1222 }
1223 if (!j->tone_state) {
1224 ixj_cpt_stop(j);
1225 }
1226 }
1227 }
1228 if (!(j->tone_state && j->dsp.low == 0x20)) {
1229 if (IsRxReady(j)) {
1230 ixj_read_frame(j);
1231 }
1232 if (IsTxReady(j)) {
1233 ixj_write_frame(j);
1234 }
1235 }
1236 if (j->flags.cringing) {
1237 if (j->hookstate & 1) {
1238 j->flags.cringing = 0;
1239 ixj_ring_off(j);
1240 } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1241 switch(j->cadence_f[5].state) {
1242 case 0:
1243 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1244 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1245 if(ixjdebug & 0x0004) {
1246 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1247 }
1248 ixj_ring_on(j);
1249 }
1250 j->cadence_f[5].state = 1;
1251 break;
1252 case 1:
1253 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1254 j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1255 if(ixjdebug & 0x0004) {
1256 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1257 }
1258 ixj_ring_off(j);
1259 j->cadence_f[5].state = 2;
1260 }
1261 break;
1262 case 2:
1263 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1264 if(ixjdebug & 0x0004) {
1265 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1266 }
1267 ixj_ring_on(j);
1268 if (j->cadence_f[5].on2) {
1269 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1270 j->cadence_f[5].state = 3;
1271 } else {
1272 j->cadence_f[5].state = 7;
1273 }
1274 }
1275 break;
1276 case 3:
1277 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1278 if(ixjdebug & 0x0004) {
1279 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1280 }
1281 ixj_ring_off(j);
1282 if (j->cadence_f[5].off2) {
1283 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1284 j->cadence_f[5].state = 4;
1285 } else {
1286 j->cadence_f[5].state = 7;
1287 }
1288 }
1289 break;
1290 case 4:
1291 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1292 if(ixjdebug & 0x0004) {
1293 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1294 }
1295 ixj_ring_on(j);
1296 if (j->cadence_f[5].on3) {
1297 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1298 j->cadence_f[5].state = 5;
1299 } else {
1300 j->cadence_f[5].state = 7;
1301 }
1302 }
1303 break;
1304 case 5:
1305 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1306 if(ixjdebug & 0x0004) {
1307 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1308 }
1309 ixj_ring_off(j);
1310 if (j->cadence_f[5].off3) {
1311 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1312 j->cadence_f[5].state = 6;
1313 } else {
1314 j->cadence_f[5].state = 7;
1315 }
1316 }
1317 break;
1318 case 6:
1319 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1320 if(ixjdebug & 0x0004) {
1321 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1322 }
1323 j->cadence_f[5].state = 7;
1324 }
1325 break;
1326 case 7:
1327 if(ixjdebug & 0x0004) {
1328 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1329 }
1330 j->flags.cidring = 1;
1331 j->cadence_f[5].state = 0;
1332 break;
1333 }
1334 if (j->flags.cidring && !j->flags.cidsent) {
1335 j->flags.cidsent = 1;
1336 if(j->fskdcnt) {
1337 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1338 ixj_pre_cid(j);
1339 }
1340 j->flags.cidring = 0;
1341 }
1342 clear_bit(board, &j->busyflags);
1343 ixj_add_timer(j);
1344 return;
1345 } else {
1346 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1347 if (j->flags.cidring && !j->flags.cidsent) {
1348 j->flags.cidsent = 1;
1349 if(j->fskdcnt) {
1350 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1351 ixj_pre_cid(j);
1352 }
1353 j->flags.cidring = 0;
1354 }
1355 j->ring_cadence_t--;
1356 if (j->ring_cadence_t == -1)
1357 j->ring_cadence_t = 15;
1358 j->ring_cadence_jif = jiffies;
1359
1360 if (j->ring_cadence & 1 << j->ring_cadence_t) {
1361 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1362 j->flags.firstring = 1;
1363 else
1364 ixj_ring_on(j);
1365 } else {
1366 ixj_ring_off(j);
1367 if(!j->flags.cidsent)
1368 j->flags.cidring = 1;
1369 }
1370 }
1371 clear_bit(board, &j->busyflags);
1372 ixj_add_timer(j);
1373 return;
1374 }
1375 }
1376 if (!j->flags.ringing) {
1377 if (j->hookstate) { /* & 1) { */
1378 if (j->dsp.low != 0x20 &&
1379 SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1380 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1381 }
1382 LineMonitor(j);
1383 read_filters(j);
1384 ixj_WriteDSPCommand(0x511B, j);
1385 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1386 if (!j->m_hook && (j->hookstate & 1)) {
1387 j->m_hook = j->ex.bits.hookstate = 1;
1388 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1389 }
1390 } else {
1391 if (j->ex.bits.dtmf_ready) {
1392 j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1393 }
1394 if (j->m_hook) {
1395 j->m_hook = 0;
1396 j->ex.bits.hookstate = 1;
1397 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1398 }
1399 }
1400 }
1401 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1402 ixj_pstn_state(j);
1403 }
1404 if (j->ex.bytes) {
1405 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
1406 }
1407 clear_bit(board, &j->busyflags);
1408 }
1409 ixj_add_timer(j);
1410}
1411
1412static int ixj_status_wait(IXJ *j)
1413{
1414 unsigned long jif;
1415
1416 jif = jiffies + ((60 * hertz) / 100);
1417 while (!IsStatusReady(j)) {
1418 ixj_perfmon(j->statuswait);
1419 if (time_after(jiffies, jif)) {
1420 ixj_perfmon(j->statuswaitfail);
1421 return -1;
1422 }
1423 }
1424 return 0;
1425}
1426
1427static int ixj_PCcontrol_wait(IXJ *j)
1428{
1429 unsigned long jif;
1430
1431 jif = jiffies + ((60 * hertz) / 100);
1432 while (!IsPCControlReady(j)) {
1433 ixj_perfmon(j->pcontrolwait);
1434 if (time_after(jiffies, jif)) {
1435 ixj_perfmon(j->pcontrolwaitfail);
1436 return -1;
1437 }
1438 }
1439 return 0;
1440}
1441
1442static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1443{
1444 BYTES bytes;
1445 unsigned long jif;
1446
1447 atomic_inc(&j->DSPWrite);
1448 if(atomic_read(&j->DSPWrite) > 1) {
1449 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1450 return -1;
1451 }
1452 bytes.high = (cmd & 0xFF00) >> 8;
1453 bytes.low = cmd & 0x00FF;
1454 jif = jiffies + ((60 * hertz) / 100);
1455 while (!IsControlReady(j)) {
1456 ixj_perfmon(j->iscontrolready);
1457 if (time_after(jiffies, jif)) {
1458 ixj_perfmon(j->iscontrolreadyfail);
1459 atomic_dec(&j->DSPWrite);
1460 if(atomic_read(&j->DSPWrite) > 0) {
1461 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1462 while(atomic_read(&j->DSPWrite) > 0) {
1463 atomic_dec(&j->DSPWrite);
1464 }
1465 }
1466 return -1;
1467 }
1468 }
1469 outb(bytes.low, j->DSPbase + 6);
1470 outb(bytes.high, j->DSPbase + 7);
1471
1472 if (ixj_status_wait(j)) {
1473 j->ssr.low = 0xFF;
1474 j->ssr.high = 0xFF;
1475 atomic_dec(&j->DSPWrite);
1476 if(atomic_read(&j->DSPWrite) > 0) {
1477 printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1478 while(atomic_read(&j->DSPWrite) > 0) {
1479 atomic_dec(&j->DSPWrite);
1480 }
1481 }
1482 return -1;
1483 }
1484/* Read Software Status Register */
1485 j->ssr.low = inb_p(j->DSPbase + 2);
1486 j->ssr.high = inb_p(j->DSPbase + 3);
1487 atomic_dec(&j->DSPWrite);
1488 if(atomic_read(&j->DSPWrite) > 0) {
1489 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1490 while(atomic_read(&j->DSPWrite) > 0) {
1491 atomic_dec(&j->DSPWrite);
1492 }
1493 }
1494 return 0;
1495}
1496
1497/***************************************************************************
1498*
1499* General Purpose IO Register read routine
1500*
1501***************************************************************************/
1502static inline int ixj_gpio_read(IXJ *j)
1503{
1504 if (ixj_WriteDSPCommand(0x5143, j))
1505 return -1;
1506
1507 j->gpio.bytes.low = j->ssr.low;
1508 j->gpio.bytes.high = j->ssr.high;
1509
1510 return 0;
1511}
1512
1513static inline void LED_SetState(int state, IXJ *j)
1514{
1515 if (j->cardtype == QTI_LINEJACK) {
1516 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1517 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1518 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1519 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1520
1521 outb(j->pld_scrw.byte, j->XILINXbase);
1522 }
1523}
1524
1525/*********************************************************************
1526* GPIO Pins are configured as follows on the Quicknet Internet
1527* PhoneJACK Telephony Cards
1528*
1529* POTS Select GPIO_6=0 GPIO_7=0
1530* Mic/Speaker Select GPIO_6=0 GPIO_7=1
1531* Handset Select GPIO_6=1 GPIO_7=0
1532*
1533* SLIC Active GPIO_1=0 GPIO_2=1 GPIO_5=0
1534* SLIC Ringing GPIO_1=1 GPIO_2=1 GPIO_5=0
1535* SLIC Open Circuit GPIO_1=0 GPIO_2=0 GPIO_5=0
1536*
1537* Hook Switch changes reported on GPIO_3
1538*********************************************************************/
1539static int ixj_set_port(IXJ *j, int arg)
1540{
1541 if (j->cardtype == QTI_PHONEJACK_LITE) {
1542 if (arg != PORT_POTS)
1543 return 10;
1544 else
1545 return 0;
1546 }
1547 switch (arg) {
1548 case PORT_POTS:
1549 j->port = PORT_POTS;
1550 switch (j->cardtype) {
1551 case QTI_PHONECARD:
1552 if (j->flags.pcmciasct == 1)
1553 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1554 else
1555 return 11;
1556 break;
1557 case QTI_PHONEJACK_PCI:
1558 j->pld_slicw.pcib.mic = 0;
1559 j->pld_slicw.pcib.spk = 0;
1560 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1561 break;
1562 case QTI_LINEJACK:
1563 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1564 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1565 Software Control Register */
1566 return 2;
1567 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1568
1569 outb(j->pld_scrw.byte, j->XILINXbase);
1570 j->pld_clock.byte = 0;
1571 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1572 j->pld_slicw.bits.rly1 = 1;
1573 j->pld_slicw.bits.spken = 0;
1574 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1575 ixj_mixer(0x1200, j); /* Turn Off MIC switch on mixer left */
1576 ixj_mixer(0x1401, j); /* Turn On Mono1 switch on mixer left */
1577 ixj_mixer(0x1300, j); /* Turn Off MIC switch on mixer right */
1578 ixj_mixer(0x1501, j); /* Turn On Mono1 switch on mixer right */
1579 ixj_mixer(0x0E80, j); /*Mic mute */
1580 ixj_mixer(0x0F00, j); /* Set mono out (SLIC) to 0dB */
1581 ixj_mixer(0x0080, j); /* Mute Master Left volume */
1582 ixj_mixer(0x0180, j); /* Mute Master Right volume */
1583 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1584/* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1585 break;
1586 case QTI_PHONEJACK:
1587 j->gpio.bytes.high = 0x0B;
1588 j->gpio.bits.gpio6 = 0;
1589 j->gpio.bits.gpio7 = 0;
1590 ixj_WriteDSPCommand(j->gpio.word, j);
1591 break;
1592 }
1593 break;
1594 case PORT_PSTN:
1595 if (j->cardtype == QTI_LINEJACK) {
1596 ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1597
1598 j->pld_slicw.bits.rly3 = 0;
1599 j->pld_slicw.bits.rly1 = 1;
1600 j->pld_slicw.bits.spken = 0;
1601 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1602 j->port = PORT_PSTN;
1603 } else {
1604 return 4;
1605 }
1606 break;
1607 case PORT_SPEAKER:
1608 j->port = PORT_SPEAKER;
1609 switch (j->cardtype) {
1610 case QTI_PHONECARD:
1611 if (j->flags.pcmciasct) {
1612 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1613 }
1614 break;
1615 case QTI_PHONEJACK_PCI:
1616 j->pld_slicw.pcib.mic = 1;
1617 j->pld_slicw.pcib.spk = 1;
1618 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1619 break;
1620 case QTI_LINEJACK:
1621 ixj_set_pots(j, 0); /* Disconnect POTS/PSTN relay */
1622 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to
1623 Software Control Register */
1624 return 2;
1625 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
1626
1627 outb(j->pld_scrw.byte, j->XILINXbase);
1628 j->pld_clock.byte = 0;
1629 outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1630 j->pld_slicw.bits.rly1 = 1;
1631 j->pld_slicw.bits.spken = 1;
1632 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1633 ixj_mixer(0x1201, j); /* Turn On MIC switch on mixer left */
1634 ixj_mixer(0x1400, j); /* Turn Off Mono1 switch on mixer left */
1635 ixj_mixer(0x1301, j); /* Turn On MIC switch on mixer right */
1636 ixj_mixer(0x1500, j); /* Turn Off Mono1 switch on mixer right */
1637 ixj_mixer(0x0E06, j); /*Mic un-mute 0dB */
1638 ixj_mixer(0x0F80, j); /* Mute mono out (SLIC) */
1639 ixj_mixer(0x0000, j); /* Set Master Left volume to 0dB */
1640 ixj_mixer(0x0100, j); /* Set Master Right volume to 0dB */
1641 break;
1642 case QTI_PHONEJACK:
1643 j->gpio.bytes.high = 0x0B;
1644 j->gpio.bits.gpio6 = 0;
1645 j->gpio.bits.gpio7 = 1;
1646 ixj_WriteDSPCommand(j->gpio.word, j);
1647 break;
1648 }
1649 break;
1650 case PORT_HANDSET:
1651 if (j->cardtype != QTI_PHONEJACK) {
1652 return 5;
1653 } else {
1654 j->gpio.bytes.high = 0x0B;
1655 j->gpio.bits.gpio6 = 1;
1656 j->gpio.bits.gpio7 = 0;
1657 ixj_WriteDSPCommand(j->gpio.word, j);
1658 j->port = PORT_HANDSET;
1659 }
1660 break;
1661 default:
1662 return 6;
1663 break;
1664 }
1665 return 0;
1666}
1667
1668static int ixj_set_pots(IXJ *j, int arg)
1669{
1670 if (j->cardtype == QTI_LINEJACK) {
1671 if (arg) {
1672 if (j->port == PORT_PSTN) {
1673 j->pld_slicw.bits.rly1 = 0;
1674 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1675 j->flags.pots_pstn = 1;
1676 return 1;
1677 } else {
1678 j->flags.pots_pstn = 0;
1679 return 0;
1680 }
1681 } else {
1682 j->pld_slicw.bits.rly1 = 1;
1683 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1684 j->flags.pots_pstn = 0;
1685 return 1;
1686 }
1687 } else {
1688 return 0;
1689 }
1690}
1691
1692static void ixj_ring_on(IXJ *j)
1693{
1694 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1695 {
1696 if (ixjdebug & 0x0004)
1697 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1698
1699 j->gpio.bytes.high = 0x0B;
1700 j->gpio.bytes.low = 0x00;
1701 j->gpio.bits.gpio1 = 1;
1702 j->gpio.bits.gpio2 = 1;
1703 j->gpio.bits.gpio5 = 0;
1704 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring signal */
1705 } else /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1706 {
1707 if (ixjdebug & 0x0004)
1708 printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1709
1710 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1711 }
1712}
1713
1714static int ixj_siadc(IXJ *j, int val)
1715{
1716 if(j->cardtype == QTI_PHONECARD){
1717 if(j->flags.pcmciascp){
1718 if(val == -1)
1719 return j->siadc.bits.rxg;
1720
1721 if(val < 0 || val > 0x1F)
1722 return -1;
1723
1724 j->siadc.bits.hom = 0; /* Handset Out Mute */
1725 j->siadc.bits.lom = 0; /* Line Out Mute */
1726 j->siadc.bits.rxg = val; /*(0xC000 - 0x41C8) / 0x4EF; RX PGA Gain */
1727 j->psccr.bits.addr = 6; /* R/W Smart Cable Register Address */
1728 j->psccr.bits.rw = 0; /* Read / Write flag */
1729 j->psccr.bits.dev = 0;
1730 outb(j->siadc.byte, j->XILINXbase + 0x00);
1731 outb(j->psccr.byte, j->XILINXbase + 0x01);
1732 ixj_PCcontrol_wait(j);
1733 return j->siadc.bits.rxg;
1734 }
1735 }
1736 return -1;
1737}
1738
1739static int ixj_sidac(IXJ *j, int val)
1740{
1741 if(j->cardtype == QTI_PHONECARD){
1742 if(j->flags.pcmciascp){
1743 if(val == -1)
1744 return j->sidac.bits.txg;
1745
1746 if(val < 0 || val > 0x1F)
1747 return -1;
1748
1749 j->sidac.bits.srm = 1; /* Speaker Right Mute */
1750 j->sidac.bits.slm = 1; /* Speaker Left Mute */
1751 j->sidac.bits.txg = val; /* (0xC000 - 0x45E4) / 0x5D3; TX PGA Gain */
1752 j->psccr.bits.addr = 7; /* R/W Smart Cable Register Address */
1753 j->psccr.bits.rw = 0; /* Read / Write flag */
1754 j->psccr.bits.dev = 0;
1755 outb(j->sidac.byte, j->XILINXbase + 0x00);
1756 outb(j->psccr.byte, j->XILINXbase + 0x01);
1757 ixj_PCcontrol_wait(j);
1758 return j->sidac.bits.txg;
1759 }
1760 }
1761 return -1;
1762}
1763
1764static int ixj_pcmcia_cable_check(IXJ *j)
1765{
1766 j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1767 if (!j->flags.pcmciastate) {
1768 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1769 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1770 j->flags.pcmciastate = 4;
1771 return 0;
1772 }
1773 if (j->pccr1.bits.ed) {
1774 j->pccr1.bits.ed = 0;
1775 j->psccr.bits.dev = 3;
1776 j->psccr.bits.rw = 1;
1777 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1778 ixj_PCcontrol_wait(j);
1779 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1780 j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1781 j->psccr.bits.dev = 3;
1782 j->psccr.bits.rw = 0;
1783 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1784 ixj_PCcontrol_wait(j);
1785 return j->pslic.bits.led2 ? 1 : 0;
1786 } else if (j->flags.pcmciasct) {
1787 return j->r_hook;
1788 } else {
1789 return 1;
1790 }
1791 } else if (j->flags.pcmciastate == 4) {
1792 if (!j->pccr1.bits.drf) {
1793 j->flags.pcmciastate = 3;
1794 }
1795 return 0;
1796 } else if (j->flags.pcmciastate == 3) {
1797 j->pccr2.bits.pwr = 0;
1798 j->pccr2.bits.rstc = 1;
1799 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1800 j->checkwait = jiffies + (hertz * 2);
1801 j->flags.incheck = 1;
1802 j->flags.pcmciastate = 2;
1803 return 0;
1804 } else if (j->flags.pcmciastate == 2) {
1805 if (j->flags.incheck) {
1806 if (time_before(jiffies, j->checkwait)) {
1807 return 0;
1808 } else {
1809 j->flags.incheck = 0;
1810 }
1811 }
1812 j->pccr2.bits.pwr = 0;
1813 j->pccr2.bits.rstc = 0;
1814 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1815 j->flags.pcmciastate = 1;
1816 return 0;
1817 } else if (j->flags.pcmciastate == 1) {
1818 j->flags.pcmciastate = 0;
1819 if (!j->pccr1.bits.drf) {
1820 j->psccr.bits.dev = 3;
1821 j->psccr.bits.rw = 1;
1822 outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1823 ixj_PCcontrol_wait(j);
1824 j->flags.pcmciascp = 1; /* Set Cable Present Flag */
1825
1826 j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03; /* Get Cable Type */
1827
1828 if (j->flags.pcmciasct == 3) {
1829 j->flags.pcmciastate = 4;
1830 return 0;
1831 } else if (j->flags.pcmciasct == 0) {
1832 j->pccr2.bits.pwr = 1;
1833 j->pccr2.bits.rstc = 0;
1834 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1835 j->port = PORT_SPEAKER;
1836 } else {
1837 j->port = PORT_POTS;
1838 }
1839 j->sic1.bits.cpd = 0; /* Chip Power Down */
1840 j->sic1.bits.mpd = 0; /* MIC Bias Power Down */
1841 j->sic1.bits.hpd = 0; /* Handset Bias Power Down */
1842 j->sic1.bits.lpd = 0; /* Line Bias Power Down */
1843 j->sic1.bits.spd = 1; /* Speaker Drive Power Down */
1844 j->psccr.bits.addr = 1; /* R/W Smart Cable Register Address */
1845 j->psccr.bits.rw = 0; /* Read / Write flag */
1846 j->psccr.bits.dev = 0;
1847 outb(j->sic1.byte, j->XILINXbase + 0x00);
1848 outb(j->psccr.byte, j->XILINXbase + 0x01);
1849 ixj_PCcontrol_wait(j);
1850
1851 j->sic2.bits.al = 0; /* Analog Loopback DAC analog -> ADC analog */
1852 j->sic2.bits.dl2 = 0; /* Digital Loopback DAC -> ADC one bit */
1853 j->sic2.bits.dl1 = 0; /* Digital Loopback ADC -> DAC one bit */
1854 j->sic2.bits.pll = 0; /* 1 = div 10, 0 = div 5 */
1855 j->sic2.bits.hpd = 0; /* HPF disable */
1856 j->psccr.bits.addr = 2; /* R/W Smart Cable Register Address */
1857 j->psccr.bits.rw = 0; /* Read / Write flag */
1858 j->psccr.bits.dev = 0;
1859 outb(j->sic2.byte, j->XILINXbase + 0x00);
1860 outb(j->psccr.byte, j->XILINXbase + 0x01);
1861 ixj_PCcontrol_wait(j);
1862
1863 j->psccr.bits.addr = 3; /* R/W Smart Cable Register Address */
1864 j->psccr.bits.rw = 0; /* Read / Write flag */
1865 j->psccr.bits.dev = 0;
1866 outb(0x00, j->XILINXbase + 0x00); /* PLL Divide N1 */
1867 outb(j->psccr.byte, j->XILINXbase + 0x01);
1868 ixj_PCcontrol_wait(j);
1869
1870 j->psccr.bits.addr = 4; /* R/W Smart Cable Register Address */
1871 j->psccr.bits.rw = 0; /* Read / Write flag */
1872 j->psccr.bits.dev = 0;
1873 outb(0x09, j->XILINXbase + 0x00); /* PLL Multiply M1 */
1874 outb(j->psccr.byte, j->XILINXbase + 0x01);
1875 ixj_PCcontrol_wait(j);
1876
1877 j->sirxg.bits.lig = 1; /* Line In Gain */
1878 j->sirxg.bits.lim = 1; /* Line In Mute */
1879 j->sirxg.bits.mcg = 0; /* MIC In Gain was 3 */
1880 j->sirxg.bits.mcm = 0; /* MIC In Mute */
1881 j->sirxg.bits.him = 0; /* Handset In Mute */
1882 j->sirxg.bits.iir = 1; /* IIR */
1883 j->psccr.bits.addr = 5; /* R/W Smart Cable Register Address */
1884 j->psccr.bits.rw = 0; /* Read / Write flag */
1885 j->psccr.bits.dev = 0;
1886 outb(j->sirxg.byte, j->XILINXbase + 0x00);
1887 outb(j->psccr.byte, j->XILINXbase + 0x01);
1888 ixj_PCcontrol_wait(j);
1889
1890 ixj_siadc(j, 0x17);
1891 ixj_sidac(j, 0x1D);
1892
1893 j->siaatt.bits.sot = 0;
1894 j->psccr.bits.addr = 9; /* R/W Smart Cable Register Address */
1895 j->psccr.bits.rw = 0; /* Read / Write flag */
1896 j->psccr.bits.dev = 0;
1897 outb(j->siaatt.byte, j->XILINXbase + 0x00);
1898 outb(j->psccr.byte, j->XILINXbase + 0x01);
1899 ixj_PCcontrol_wait(j);
1900
1901 if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1902 j->psccr.byte = j->pslic.byte = 0;
1903 j->pslic.bits.powerdown = 1;
1904 j->psccr.bits.dev = 3;
1905 j->psccr.bits.rw = 0;
1906 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1907 ixj_PCcontrol_wait(j);
1908 }
1909 }
1910 return 0;
1911 } else {
1912 j->flags.pcmciascp = 0;
1913 return 0;
1914 }
1915 return 0;
1916}
1917
1918static int ixj_hookstate(IXJ *j)
1919{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]1920 int fOffHook = 0;
1921
1922 switch (j->cardtype) {
1923 case QTI_PHONEJACK:
1924 ixj_gpio_read(j);
1925 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1926 break;
1927 case QTI_LINEJACK:
1928 case QTI_PHONEJACK_LITE:
1929 case QTI_PHONEJACK_PCI:
1930 SLIC_GetState(j);
1931 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1932 fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1933 if(fOffHook != j->p_hook) {
1934 if(!j->checkwait) {
1935 j->checkwait = jiffies;
1936 }
1937 if(time_before(jiffies, j->checkwait + 2)) {
1938 fOffHook ^= 1;
1939 } else {
1940 j->checkwait = 0;
1941 }
1942 j->p_hook = fOffHook;
1943 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1944 }
1945 } else {
1946 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1947 j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1948 if (j->flags.ringing || j->flags.cringing) {
1949 if (!in_interrupt()) {
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]1950 msleep(20);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]1951 }
1952 SLIC_GetState(j);
1953 if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1954 ixj_ring_on(j);
1955 }
1956 }
1957 if (j->cardtype == QTI_PHONEJACK_PCI) {
1958 j->pld_scrr.byte = inb_p(j->XILINXbase);
1959 fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1960 } else
1961 fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1962 }
1963 }
1964 break;
1965 case QTI_PHONECARD:
1966 fOffHook = ixj_pcmcia_cable_check(j);
1967 break;
1968 }
1969 if (j->r_hook != fOffHook) {
1970 j->r_hook = fOffHook;
1971 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1972 j->ex.bits.hookstate = 1;
1973 ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1974 } else if (!fOffHook) {
1975 j->flash_end = jiffies + ((60 * hertz) / 100);
1976 }
1977 }
1978 if (fOffHook) {
1979 if(time_before(jiffies, j->flash_end)) {
1980 j->ex.bits.flash = 1;
1981 j->flash_end = 0;
1982 ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1983 }
1984 } else {
1985 if(time_before(jiffies, j->flash_end)) {
1986 fOffHook = 1;
1987 }
1988 }
1989
1990 if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1991 fOffHook |= 2;
1992
1993 if (j->port == PORT_SPEAKER) {
1994 if(j->cardtype == QTI_PHONECARD) {
1995 if(j->flags.pcmciascp && j->flags.pcmciasct) {
1996 fOffHook |= 2;
1997 }
1998 } else {
1999 fOffHook |= 2;
2000 }
2001 }
2002
2003 if (j->port == PORT_HANDSET)
2004 fOffHook |= 2;
2005
2006 return fOffHook;
2007}
2008
2009static void ixj_ring_off(IXJ *j)
2010{
2011 if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2012 {
2013 if (ixjdebug & 0x0004)
2014 printk(KERN_INFO "IXJ Ring Off\n");
2015 j->gpio.bytes.high = 0x0B;
2016 j->gpio.bytes.low = 0x00;
2017 j->gpio.bits.gpio1 = 0;
2018 j->gpio.bits.gpio2 = 1;
2019 j->gpio.bits.gpio5 = 0;
2020 ixj_WriteDSPCommand(j->gpio.word, j);
2021 } else /* Internet LineJACK */
2022 {
2023 if (ixjdebug & 0x0004)
2024 printk(KERN_INFO "IXJ Ring Off\n");
2025
2026 if(!j->flags.cidplay)
2027 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2028
2029 SLIC_GetState(j);
2030 }
2031}
2032
2033static void ixj_ring_start(IXJ *j)
2034{
2035 j->flags.cringing = 1;
2036 if (ixjdebug & 0x0004)
2037 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2038 if (ixj_hookstate(j) & 1) {
2039 if (j->port == PORT_POTS)
2040 ixj_ring_off(j);
2041 j->flags.cringing = 0;
2042 if (ixjdebug & 0x0004)
2043 printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2044 } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2045 j->ring_cadence_jif = jiffies;
2046 j->flags.cidsent = j->flags.cidring = 0;
2047 j->cadence_f[5].state = 0;
2048 if(j->cadence_f[5].on1)
2049 ixj_ring_on(j);
2050 } else {
2051 j->ring_cadence_jif = jiffies;
2052 j->ring_cadence_t = 15;
2053 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2054 ixj_ring_on(j);
2055 } else {
2056 ixj_ring_off(j);
2057 }
2058 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2059 }
2060}
2061
2062static int ixj_ring(IXJ *j)
2063{
2064 char cntr;
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]2065 unsigned long jif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2066
2067 j->flags.ringing = 1;
2068 if (ixj_hookstate(j) & 1) {
2069 ixj_ring_off(j);
2070 j->flags.ringing = 0;
2071 return 1;
2072 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2073 for (cntr = 0; cntr < j->maxrings; cntr++) {
2074 jif = jiffies + (1 * hertz);
2075 ixj_ring_on(j);
2076 while (time_before(jiffies, jif)) {
2077 if (ixj_hookstate(j) & 1) {
2078 ixj_ring_off(j);
2079 j->flags.ringing = 0;
2080 return 1;
2081 }
Nishanth Aravamudan1e63bc72005-09-10 00:27:31 -0700[diff] [blame]2082 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2083 if (signal_pending(current))
2084 break;
2085 }
2086 jif = jiffies + (3 * hertz);
2087 ixj_ring_off(j);
2088 while (time_before(jiffies, jif)) {
2089 if (ixj_hookstate(j) & 1) {
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]2090 msleep(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2091 if (ixj_hookstate(j) & 1) {
2092 j->flags.ringing = 0;
2093 return 1;
2094 }
2095 }
Nishanth Aravamudan1e63bc72005-09-10 00:27:31 -0700[diff] [blame]2096 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2097 if (signal_pending(current))
2098 break;
2099 }
2100 }
2101 ixj_ring_off(j);
2102 j->flags.ringing = 0;
2103 return 0;
2104}
2105
2106static int ixj_open(struct phone_device *p, struct file *file_p)
2107{
2108 IXJ *j = get_ixj(p->board);
2109 file_p->private_data = j;
2110
2111 if (!j->DSPbase)
2112 return -ENODEV;
2113
2114 if (file_p->f_mode & FMODE_READ) {
2115 if(!j->readers) {
2116 j->readers++;
2117 } else {
2118 return -EBUSY;
2119 }
2120 }
2121
2122 if (file_p->f_mode & FMODE_WRITE) {
2123 if(!j->writers) {
2124 j->writers++;
2125 } else {
2126 if (file_p->f_mode & FMODE_READ){
2127 j->readers--;
2128 }
2129 return -EBUSY;
2130 }
2131 }
2132
2133 if (j->cardtype == QTI_PHONECARD) {
2134 j->pslic.bits.powerdown = 0;
2135 j->psccr.bits.dev = 3;
2136 j->psccr.bits.rw = 0;
2137 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2138 ixj_PCcontrol_wait(j);
2139 }
2140
2141 j->flags.cidplay = 0;
2142 j->flags.cidcw_ack = 0;
2143
2144 if (ixjdebug & 0x0002)
2145 printk(KERN_INFO "Opening board %d\n", p->board);
2146
2147 j->framesread = j->frameswritten = 0;
2148 return 0;
2149}
2150
2151static int ixj_release(struct inode *inode, struct file *file_p)
2152{
2153 IXJ_TONE ti;
2154 int cnt;
2155 IXJ *j = file_p->private_data;
2156 int board = j->p.board;
2157
2158 /*
2159 * Set up locks to ensure that only one process is talking to the DSP at a time.
2160 * This is necessary to keep the DSP from locking up.
2161 */
Nishanth Aravamudan1e63bc72005-09-10 00:27:31 -0700[diff] [blame]2162 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2163 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2164 if (ixjdebug & 0x0002)
2165 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2166
2167 if (j->cardtype == QTI_PHONECARD)
2168 ixj_set_port(j, PORT_SPEAKER);
2169 else
2170 ixj_set_port(j, PORT_POTS);
2171
2172 aec_stop(j);
2173 ixj_play_stop(j);
2174 ixj_record_stop(j);
2175 set_play_volume(j, 0x100);
2176 set_rec_volume(j, 0x100);
2177 ixj_ring_off(j);
2178
2179 /* Restore the tone table to default settings. */
2180 ti.tone_index = 10;
2181 ti.gain0 = 1;
2182 ti.freq0 = hz941;
2183 ti.gain1 = 0;
2184 ti.freq1 = hz1209;
2185 ixj_init_tone(j, &ti);
2186 ti.tone_index = 11;
2187 ti.gain0 = 1;
2188 ti.freq0 = hz941;
2189 ti.gain1 = 0;
2190 ti.freq1 = hz1336;
2191 ixj_init_tone(j, &ti);
2192 ti.tone_index = 12;
2193 ti.gain0 = 1;
2194 ti.freq0 = hz941;
2195 ti.gain1 = 0;
2196 ti.freq1 = hz1477;
2197 ixj_init_tone(j, &ti);
2198 ti.tone_index = 13;
2199 ti.gain0 = 1;
2200 ti.freq0 = hz800;
2201 ti.gain1 = 0;
2202 ti.freq1 = 0;
2203 ixj_init_tone(j, &ti);
2204 ti.tone_index = 14;
2205 ti.gain0 = 1;
2206 ti.freq0 = hz1000;
2207 ti.gain1 = 0;
2208 ti.freq1 = 0;
2209 ixj_init_tone(j, &ti);
2210 ti.tone_index = 15;
2211 ti.gain0 = 1;
2212 ti.freq0 = hz1250;
2213 ti.gain1 = 0;
2214 ti.freq1 = 0;
2215 ixj_init_tone(j, &ti);
2216 ti.tone_index = 16;
2217 ti.gain0 = 1;
2218 ti.freq0 = hz950;
2219 ti.gain1 = 0;
2220 ti.freq1 = 0;
2221 ixj_init_tone(j, &ti);
2222 ti.tone_index = 17;
2223 ti.gain0 = 1;
2224 ti.freq0 = hz1100;
2225 ti.gain1 = 0;
2226 ti.freq1 = 0;
2227 ixj_init_tone(j, &ti);
2228 ti.tone_index = 18;
2229 ti.gain0 = 1;
2230 ti.freq0 = hz1400;
2231 ti.gain1 = 0;
2232 ti.freq1 = 0;
2233 ixj_init_tone(j, &ti);
2234 ti.tone_index = 19;
2235 ti.gain0 = 1;
2236 ti.freq0 = hz1500;
2237 ti.gain1 = 0;
2238 ti.freq1 = 0;
2239 ixj_init_tone(j, &ti);
2240 ti.tone_index = 20;
2241 ti.gain0 = 1;
2242 ti.freq0 = hz1600;
2243 ti.gain1 = 0;
2244 ti.freq1 = 0;
2245 ixj_init_tone(j, &ti);
2246 ti.tone_index = 21;
2247 ti.gain0 = 1;
2248 ti.freq0 = hz1800;
2249 ti.gain1 = 0;
2250 ti.freq1 = 0;
2251 ixj_init_tone(j, &ti);
2252 ti.tone_index = 22;
2253 ti.gain0 = 1;
2254 ti.freq0 = hz2100;
2255 ti.gain1 = 0;
2256 ti.freq1 = 0;
2257 ixj_init_tone(j, &ti);
2258 ti.tone_index = 23;
2259 ti.gain0 = 1;
2260 ti.freq0 = hz1300;
2261 ti.gain1 = 0;
2262 ti.freq1 = 0;
2263 ixj_init_tone(j, &ti);
2264 ti.tone_index = 24;
2265 ti.gain0 = 1;
2266 ti.freq0 = hz2450;
2267 ti.gain1 = 0;
2268 ti.freq1 = 0;
2269 ixj_init_tone(j, &ti);
2270 ti.tone_index = 25;
2271 ti.gain0 = 1;
2272 ti.freq0 = hz350;
2273 ti.gain1 = 0;
2274 ti.freq1 = hz440;
2275 ixj_init_tone(j, &ti);
2276 ti.tone_index = 26;
2277 ti.gain0 = 1;
2278 ti.freq0 = hz440;
2279 ti.gain1 = 0;
2280 ti.freq1 = hz480;
2281 ixj_init_tone(j, &ti);
2282 ti.tone_index = 27;
2283 ti.gain0 = 1;
2284 ti.freq0 = hz480;
2285 ti.gain1 = 0;
2286 ti.freq1 = hz620;
2287 ixj_init_tone(j, &ti);
2288
2289 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
2290
2291 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
2292
2293 j->ex.bits.dtmf_ready = 0;
2294 j->dtmf_state = 0;
2295 j->dtmf_wp = j->dtmf_rp = 0;
2296 j->rec_mode = j->play_mode = -1;
2297 j->flags.ringing = 0;
2298 j->maxrings = MAXRINGS;
2299 j->ring_cadence = USA_RING_CADENCE;
2300 if(j->cadence_f[5].enable) {
2301 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2302 }
2303 j->drybuffer = 0;
2304 j->winktime = 320;
2305 j->flags.dtmf_oob = 0;
2306 for (cnt = 0; cnt < 4; cnt++)
2307 j->cadence_f[cnt].enable = 0;
2308
2309 idle(j);
2310
2311 if(j->cardtype == QTI_PHONECARD) {
2312 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2313 }
2314
2315 if (file_p->f_mode & FMODE_READ)
2316 j->readers--;
2317 if (file_p->f_mode & FMODE_WRITE)
2318 j->writers--;
2319
2320 if (j->read_buffer && !j->readers) {
2321 kfree(j->read_buffer);
2322 j->read_buffer = NULL;
2323 j->read_buffer_size = 0;
2324 }
2325 if (j->write_buffer && !j->writers) {
2326 kfree(j->write_buffer);
2327 j->write_buffer = NULL;
2328 j->write_buffer_size = 0;
2329 }
2330 j->rec_codec = j->play_codec = 0;
2331 j->rec_frame_size = j->play_frame_size = 0;
2332 j->flags.cidsent = j->flags.cidring = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2333
2334 if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2335 ixj_set_port(j, PORT_PSTN);
2336 daa_set_mode(j, SOP_PU_SLEEP);
2337 ixj_set_pots(j, 1);
2338 }
2339 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2340
2341 /* Set up the default signals for events */
2342 for (cnt = 0; cnt < 35; cnt++)
2343 j->ixj_signals[cnt] = SIGIO;
2344
2345 /* Set the excetion signal enable flags */
2346 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2347 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 =
2348 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;
2349
2350 file_p->private_data = NULL;
2351 clear_bit(board, &j->busyflags);
2352 return 0;
2353}
2354
2355static int read_filters(IXJ *j)
2356{
2357 unsigned short fc, cnt, trg;
2358 int var;
2359
2360 trg = 0;
2361 if (ixj_WriteDSPCommand(0x5144, j)) {
2362 if(ixjdebug & 0x0001) {
2363 printk(KERN_INFO "Read Frame Counter failed!\n");
2364 }
2365 return -1;
2366 }
2367 fc = j->ssr.high << 8 | j->ssr.low;
2368 if (fc == j->frame_count)
2369 return 1;
2370
2371 j->frame_count = fc;
2372
2373 if (j->dtmf_proc)
2374 return 1;
2375
2376 var = 10;
2377
2378 for (cnt = 0; cnt < 4; cnt++) {
2379 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2380 if(ixjdebug & 0x0001) {
2381 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2382 }
2383 return -1;
2384 }
2385 if (ixj_WriteDSPCommand(0x515C, j)) {
2386 if(ixjdebug & 0x0001) {
2387 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2388 }
2389 return -1;
2390 }
2391 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2392
2393 if (j->cadence_f[cnt].enable) {
2394 if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2395 if (j->cadence_f[cnt].state == 0) {
2396 j->cadence_f[cnt].state = 1;
2397 j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2398 j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2399 j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2400 } else if (j->cadence_f[cnt].state == 2 &&
2401 (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2402 time_before(jiffies, j->cadence_f[cnt].off1max))) {
2403 if (j->cadence_f[cnt].on2) {
2404 j->cadence_f[cnt].state = 3;
2405 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2406 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2407 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2408 } else {
2409 j->cadence_f[cnt].state = 7;
2410 }
2411 } else if (j->cadence_f[cnt].state == 4 &&
2412 (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2413 time_before(jiffies, j->cadence_f[cnt].off2max))) {
2414 if (j->cadence_f[cnt].on3) {
2415 j->cadence_f[cnt].state = 5;
2416 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2417 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2418 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2419 } else {
2420 j->cadence_f[cnt].state = 7;
2421 }
2422 } else {
2423 j->cadence_f[cnt].state = 0;
2424 }
2425 } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2426 if (j->cadence_f[cnt].state == 1) {
2427 if(!j->cadence_f[cnt].on1) {
2428 j->cadence_f[cnt].state = 7;
2429 } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2430 time_before(jiffies, j->cadence_f[cnt].on1max))) {
2431 if(j->cadence_f[cnt].off1) {
2432 j->cadence_f[cnt].state = 2;
2433 j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2434 j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2435 j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2436 } else {
2437 j->cadence_f[cnt].state = 7;
2438 }
2439 } else {
2440 j->cadence_f[cnt].state = 0;
2441 }
2442 } else if (j->cadence_f[cnt].state == 3) {
2443 if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2444 time_before(jiffies, j->cadence_f[cnt].on2max))) {
2445 if(j->cadence_f[cnt].off2) {
2446 j->cadence_f[cnt].state = 4;
2447 j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2448 j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2449 j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2450 } else {
2451 j->cadence_f[cnt].state = 7;
2452 }
2453 } else {
2454 j->cadence_f[cnt].state = 0;
2455 }
2456 } else if (j->cadence_f[cnt].state == 5) {
2457 if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2458 time_before(jiffies, j->cadence_f[cnt].on3max))) {
2459 if(j->cadence_f[cnt].off3) {
2460 j->cadence_f[cnt].state = 6;
2461 j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2462 j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2463 j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2464 } else {
2465 j->cadence_f[cnt].state = 7;
2466 }
2467 } else {
2468 j->cadence_f[cnt].state = 0;
2469 }
2470 } else {
2471 j->cadence_f[cnt].state = 0;
2472 }
2473 } else {
2474 switch(j->cadence_f[cnt].state) {
2475 case 1:
2476 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2477 !j->cadence_f[cnt].off1 &&
2478 !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2479 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2480 j->cadence_f[cnt].state = 7;
2481 }
2482 break;
2483 case 3:
2484 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2485 !j->cadence_f[cnt].off2 &&
2486 !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2487 j->cadence_f[cnt].state = 7;
2488 }
2489 break;
2490 case 5:
2491 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2492 !j->cadence_f[cnt].off3) {
2493 j->cadence_f[cnt].state = 7;
2494 }
2495 break;
2496 }
2497 }
2498
2499 if (ixjdebug & 0x0040) {
2500 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2501 switch(j->cadence_f[cnt].state) {
2502 case 0:
2503 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2504 break;
2505 case 1:
2506 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2507 j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2508 break;
2509 case 2:
2510 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2511 j->cadence_f[cnt].off1max);
2512 break;
2513 case 3:
2514 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2515 j->cadence_f[cnt].on2max);
2516 break;
2517 case 4:
2518 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2519 j->cadence_f[cnt].off2max);
2520 break;
2521 case 5:
2522 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2523 j->cadence_f[cnt].on3max);
2524 break;
2525 case 6:
2526 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2527 j->cadence_f[cnt].off3max);
2528 break;
2529 }
2530 }
2531 }
2532 if (j->cadence_f[cnt].state == 7) {
2533 j->cadence_f[cnt].state = 0;
2534 if (j->cadence_f[cnt].enable == 1)
2535 j->cadence_f[cnt].enable = 0;
2536 switch (cnt) {
2537 case 0:
2538 if(ixjdebug & 0x0020) {
2539 printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2540 }
2541 j->ex.bits.fc0 = 1;
2542 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2543 break;
2544 case 1:
2545 if(ixjdebug & 0x0020) {
2546 printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2547 }
2548 j->ex.bits.fc1 = 1;
2549 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2550 break;
2551 case 2:
2552 if(ixjdebug & 0x0020) {
2553 printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2554 }
2555 j->ex.bits.fc2 = 1;
2556 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2557 break;
2558 case 3:
2559 if(ixjdebug & 0x0020) {
2560 printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2561 }
2562 j->ex.bits.fc3 = 1;
2563 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2564 break;
2565 }
2566 }
2567 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2568 (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2569 if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2570 trg = 1;
2571 } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2572 trg = 0;
2573 }
2574 switch (cnt) {
2575 case 0:
2576 if(ixjdebug & 0x0020) {
2577 printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2578 }
2579 j->ex.bits.f0 = 1;
2580 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2581 break;
2582 case 1:
2583 if(ixjdebug & 0x0020) {
2584 printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2585 }
2586 j->ex.bits.f1 = 1;
2587 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2588 break;
2589 case 2:
2590 if(ixjdebug & 0x0020) {
2591 printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2592 }
2593 j->ex.bits.f2 = 1;
2594 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2595 break;
2596 case 3:
2597 if(ixjdebug & 0x0020) {
2598 printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2599 }
2600 j->ex.bits.f3 = 1;
2601 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2602 break;
2603 }
2604 }
2605 }
2606 return 0;
2607}
2608
2609static int LineMonitor(IXJ *j)
2610{
2611 if (j->dtmf_proc) {
2612 return -1;
2613 }
2614 j->dtmf_proc = 1;
2615
2616 if (ixj_WriteDSPCommand(0x7000, j)) /* Line Monitor */
2617 return -1;
2618
2619 j->dtmf.bytes.high = j->ssr.high;
2620 j->dtmf.bytes.low = j->ssr.low;
2621 if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2622 j->dtmf_state = 1;
2623 j->dtmf_current = j->dtmf.bits.digit;
2624 }
2625 if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) /* && j->dtmf_wp != j->dtmf_rp) */
2626 {
2627 if(!j->cidcw_wait) {
2628 j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2629 j->dtmf_wp++;
2630 if (j->dtmf_wp == 79)
2631 j->dtmf_wp = 0;
2632 j->ex.bits.dtmf_ready = 1;
2633 if(j->ex_sig.bits.dtmf_ready) {
2634 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2635 }
2636 }
2637 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2638 if(ixjdebug & 0x0020) {
2639 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2640 }
2641 j->flags.cidcw_ack = 1;
2642 }
2643 j->dtmf_state = 0;
2644 }
2645 j->dtmf_proc = 0;
2646
2647 return 0;
2648}
2649
2650/************************************************************************
2651*
2652* Functions to allow alaw <-> ulaw conversions.
2653*
2654************************************************************************/
2655
2656static void ulaw2alaw(unsigned char *buff, unsigned long len)
2657{
2658 static unsigned char table_ulaw2alaw[] =
2659 {
2660 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2661 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2662 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2663 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2664 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2665 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2666 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2667 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2668 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2669 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2670 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2671 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2672 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2673 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2674 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2675 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2676 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2677 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2678 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2679 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2680 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2681 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2682 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2683 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2684 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2685 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2686 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2687 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2688 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2689 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2690 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2691 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2692 };
2693
2694 while (len--)
2695 {
2696 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2697 buff++;
2698 }
2699}
2700
2701static void alaw2ulaw(unsigned char *buff, unsigned long len)
2702{
2703 static unsigned char table_alaw2ulaw[] =
2704 {
2705 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2706 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2707 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2708 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2709 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2710 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2711 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2712 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2713 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2714 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2715 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2716 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2717 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2718 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2719 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2720 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2721 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2722 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2723 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2724 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2725 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2726 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2727 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2728 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2729 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2730 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2731 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2732 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2733 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2734 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2735 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2736 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2737 };
2738
2739 while (len--)
2740 {
2741 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2742 buff++;
2743 }
2744}
2745
2746static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2747{
2748 unsigned long i = *ppos;
Josef Sipekd1f22972006-12-08 02:37:14 -0800[diff] [blame]2749 IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2750
2751 DECLARE_WAITQUEUE(wait, current);
2752
2753 if (j->flags.inread)
2754 return -EALREADY;
2755
2756 j->flags.inread = 1;
2757
2758 add_wait_queue(&j->read_q, &wait);
2759 set_current_state(TASK_INTERRUPTIBLE);
2760 mb();
2761
2762 while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2763 ++j->read_wait;
2764 if (file_p->f_flags & O_NONBLOCK) {
2765 set_current_state(TASK_RUNNING);
2766 remove_wait_queue(&j->read_q, &wait);
2767 j->flags.inread = 0;
2768 return -EAGAIN;
2769 }
2770 if (!ixj_hookstate(j)) {
2771 set_current_state(TASK_RUNNING);
2772 remove_wait_queue(&j->read_q, &wait);
2773 j->flags.inread = 0;
2774 return 0;
2775 }
2776 interruptible_sleep_on(&j->read_q);
2777 if (signal_pending(current)) {
2778 set_current_state(TASK_RUNNING);
2779 remove_wait_queue(&j->read_q, &wait);
2780 j->flags.inread = 0;
2781 return -EINTR;
2782 }
2783 }
2784
2785 remove_wait_queue(&j->read_q, &wait);
2786 set_current_state(TASK_RUNNING);
2787 /* Don't ever copy more than the user asks */
2788 if(j->rec_codec == ALAW)
2789 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2790 i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2791 j->read_buffer_ready = 0;
2792 if (i) {
2793 j->flags.inread = 0;
2794 return -EFAULT;
2795 } else {
2796 j->flags.inread = 0;
2797 return min(length, j->read_buffer_size);
2798 }
2799}
2800
2801static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2802 loff_t * ppos)
2803{
2804 int pre_retval;
2805 ssize_t read_retval = 0;
Josef Sipekd1f22972006-12-08 02:37:14 -0800[diff] [blame]2806 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2807
2808 pre_retval = ixj_PreRead(j, 0L);
2809 switch (pre_retval) {
2810 case NORMAL:
2811 read_retval = ixj_read(file_p, buf, length, ppos);
2812 ixj_PostRead(j, 0L);
2813 break;
2814 case NOPOST:
2815 read_retval = ixj_read(file_p, buf, length, ppos);
2816 break;
2817 case POSTONLY:
2818 ixj_PostRead(j, 0L);
2819 break;
2820 default:
2821 read_retval = pre_retval;
2822 }
2823 return read_retval;
2824}
2825
2826static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2827{
2828 unsigned long i = *ppos;
2829 IXJ *j = file_p->private_data;
2830
2831 DECLARE_WAITQUEUE(wait, current);
2832
2833 if (j->flags.inwrite)
2834 return -EALREADY;
2835
2836 j->flags.inwrite = 1;
2837
2838 add_wait_queue(&j->write_q, &wait);
2839 set_current_state(TASK_INTERRUPTIBLE);
2840 mb();
2841
2842
2843 while (!j->write_buffers_empty) {
2844 ++j->write_wait;
2845 if (file_p->f_flags & O_NONBLOCK) {
2846 set_current_state(TASK_RUNNING);
2847 remove_wait_queue(&j->write_q, &wait);
2848 j->flags.inwrite = 0;
2849 return -EAGAIN;
2850 }
2851 if (!ixj_hookstate(j)) {
2852 set_current_state(TASK_RUNNING);
2853 remove_wait_queue(&j->write_q, &wait);
2854 j->flags.inwrite = 0;
2855 return 0;
2856 }
2857 interruptible_sleep_on(&j->write_q);
2858 if (signal_pending(current)) {
2859 set_current_state(TASK_RUNNING);
2860 remove_wait_queue(&j->write_q, &wait);
2861 j->flags.inwrite = 0;
2862 return -EINTR;
2863 }
2864 }
2865 set_current_state(TASK_RUNNING);
2866 remove_wait_queue(&j->write_q, &wait);
2867 if (j->write_buffer_wp + count >= j->write_buffer_end)
2868 j->write_buffer_wp = j->write_buffer;
2869 i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2870 if (i) {
2871 j->flags.inwrite = 0;
2872 return -EFAULT;
2873 }
2874 if(j->play_codec == ALAW)
2875 alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2876 j->flags.inwrite = 0;
2877 return min(count, j->write_buffer_size);
2878}
2879
2880static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2881{
2882 int pre_retval;
2883 ssize_t write_retval = 0;
2884
Josef Sipekd1f22972006-12-08 02:37:14 -0800[diff] [blame]2885 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]2886
2887 pre_retval = ixj_PreWrite(j, 0L);
2888 switch (pre_retval) {
2889 case NORMAL:
2890 write_retval = ixj_write(file_p, buf, count, ppos);
2891 if (write_retval > 0) {
2892 ixj_PostWrite(j, 0L);
2893 j->write_buffer_wp += write_retval;
2894 j->write_buffers_empty--;
2895 }
2896 break;
2897 case NOPOST:
2898 write_retval = ixj_write(file_p, buf, count, ppos);
2899 if (write_retval > 0) {
2900 j->write_buffer_wp += write_retval;
2901 j->write_buffers_empty--;
2902 }
2903 break;
2904 case POSTONLY:
2905 ixj_PostWrite(j, 0L);
2906 break;
2907 default:
2908 write_retval = pre_retval;
2909 }
2910 return write_retval;
2911}
2912
2913static void ixj_read_frame(IXJ *j)
2914{
2915 int cnt, dly;
2916
2917 if (j->read_buffer) {
2918 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2919 if (!(cnt % 16) && !IsRxReady(j)) {
2920 dly = 0;
2921 while (!IsRxReady(j)) {
2922 if (dly++ > 5) {
2923 dly = 0;
2924 break;
2925 }
2926 udelay(10);
2927 }
2928 }
2929 /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2930 if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2931 inb_p(j->DSPbase + 0x0E);
2932 inb_p(j->DSPbase + 0x0F);
2933 }
2934 *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2935 *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2936 }
2937 ++j->framesread;
2938 if (j->intercom != -1) {
2939 if (IsTxReady(get_ixj(j->intercom))) {
2940 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2941 if (!(cnt % 16) && !IsTxReady(j)) {
2942 dly = 0;
2943 while (!IsTxReady(j)) {
2944 if (dly++ > 5) {
2945 dly = 0;
2946 break;
2947 }
2948 udelay(10);
2949 }
2950 }
2951 outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2952 outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2953 }
2954 get_ixj(j->intercom)->frameswritten++;
2955 }
2956 } else {
2957 j->read_buffer_ready = 1;
2958 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
2959
2960 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
2961
2962 if(j->ixj_signals[SIG_READ_READY])
2963 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2964 }
2965 }
2966}
2967
2968static short fsk[][6][20] =
2969{
2970 {
2971 {
2972 0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2973 -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2974 },
2975 {
2976 -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2977 -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2978 },
2979 {
2980 -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2981 -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2982 },
2983 {
2984 0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2985 16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2986 },
2987 {
2988 28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2989 32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2990 },
2991 {
2992 28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2993 16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2994 }
2995 },
2996 {
2997 {
2998 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2999 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3000 },
3001 {
3002 -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3003 28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3004 },
3005 {
3006 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3007 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3008 },
3009 {
3010 0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3011 0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3012 },
3013 {
3014 28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3015 -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3016 },
3017 {
3018 28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3019 -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3020 }
3021 }
3022};
3023
3024
3025static void ixj_write_cid_bit(IXJ *j, int bit)
3026{
3027 while (j->fskcnt < 20) {
3028 if(j->fskdcnt < (j->fsksize - 1))
3029 j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3030
3031 j->fskcnt += 3;
3032 }
3033 j->fskcnt %= 20;
3034
3035 if (!bit)
3036 j->fskz++;
3037 if (j->fskz >= 6)
3038 j->fskz = 0;
3039
3040}
3041
3042static void ixj_write_cid_byte(IXJ *j, char byte)
3043{
3044 IXJ_CBYTE cb;
3045
3046 cb.cbyte = byte;
3047 ixj_write_cid_bit(j, 0);
3048 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3049 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3050 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3051 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3052 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3053 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3054 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3055 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3056 ixj_write_cid_bit(j, 1);
3057}
3058
3059static void ixj_write_cid_seize(IXJ *j)
3060{
3061 int cnt;
3062
3063 for (cnt = 0; cnt < 150; cnt++) {
3064 ixj_write_cid_bit(j, 0);
3065 ixj_write_cid_bit(j, 1);
3066 }
3067 for (cnt = 0; cnt < 180; cnt++) {
3068 ixj_write_cid_bit(j, 1);
3069 }
3070}
3071
3072static void ixj_write_cidcw_seize(IXJ *j)
3073{
3074 int cnt;
3075
3076 for (cnt = 0; cnt < 80; cnt++) {
3077 ixj_write_cid_bit(j, 1);
3078 }
3079}
3080
3081static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3082{
3083 int cnt;
3084
3085 for (cnt = 0; cnt < strlen(s); cnt++) {
3086 ixj_write_cid_byte(j, s[cnt]);
3087 checksum = (checksum + s[cnt]);
3088 }
3089 return checksum;
3090}
3091
3092static void ixj_pad_fsk(IXJ *j, int pad)
3093{
3094 int cnt;
3095
3096 for (cnt = 0; cnt < pad; cnt++) {
3097 if(j->fskdcnt < (j->fsksize - 1))
3098 j->fskdata[j->fskdcnt++] = 0x0000;
3099 }
3100 for (cnt = 0; cnt < 720; cnt++) {
3101 if(j->fskdcnt < (j->fsksize - 1))
3102 j->fskdata[j->fskdcnt++] = 0x0000;
3103 }
3104}
3105
3106static void ixj_pre_cid(IXJ *j)
3107{
3108 j->cid_play_codec = j->play_codec;
3109 j->cid_play_frame_size = j->play_frame_size;
3110 j->cid_play_volume = get_play_volume(j);
3111 j->cid_play_flag = j->flags.playing;
3112
3113 j->cid_rec_codec = j->rec_codec;
3114 j->cid_rec_volume = get_rec_volume(j);
3115 j->cid_rec_flag = j->flags.recording;
3116
3117 j->cid_play_aec_level = j->aec_level;
3118
3119 switch(j->baseframe.low) {
3120 case 0xA0:
3121 j->cid_base_frame_size = 20;
3122 break;
3123 case 0x50:
3124 j->cid_base_frame_size = 10;
3125 break;
3126 case 0xF0:
3127 j->cid_base_frame_size = 30;
3128 break;
3129 }
3130
3131 ixj_play_stop(j);
3132 ixj_cpt_stop(j);
3133
3134 j->flags.cidplay = 1;
3135
3136 set_base_frame(j, 30);
3137 set_play_codec(j, LINEAR16);
3138 set_play_volume(j, 0x1B);
3139 ixj_play_start(j);
3140}
3141
3142static void ixj_post_cid(IXJ *j)
3143{
3144 ixj_play_stop(j);
3145
3146 if(j->cidsize > 5000) {
3147 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3148 }
3149 j->flags.cidplay = 0;
3150 if(ixjdebug & 0x0200) {
3151 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3152 }
3153
3154 ixj_fsk_free(j);
3155
3156 j->fskdcnt = 0;
3157 set_base_frame(j, j->cid_base_frame_size);
3158 set_play_codec(j, j->cid_play_codec);
3159 ixj_aec_start(j, j->cid_play_aec_level);
3160 set_play_volume(j, j->cid_play_volume);
3161
3162 set_rec_codec(j, j->cid_rec_codec);
3163 set_rec_volume(j, j->cid_rec_volume);
3164
3165 if(j->cid_rec_flag)
3166 ixj_record_start(j);
3167
3168 if(j->cid_play_flag)
3169 ixj_play_start(j);
3170
3171 if(j->cid_play_flag) {
3172 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3173 }
3174}
3175
3176static void ixj_write_cid(IXJ *j)
3177{
3178 char sdmf1[50];
3179 char sdmf2[50];
3180 char sdmf3[80];
3181 char mdmflen, len1, len2, len3;
3182 int pad;
3183
3184 int checksum = 0;
3185
3186 if (j->dsp.low == 0x20 || j->flags.cidplay)
3187 return;
3188
3189 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3190 j->cidsize = j->cidcnt = 0;
3191
3192 ixj_fsk_alloc(j);
3193
3194 strcpy(sdmf1, j->cid_send.month);
3195 strcat(sdmf1, j->cid_send.day);
3196 strcat(sdmf1, j->cid_send.hour);
3197 strcat(sdmf1, j->cid_send.min);
3198 strcpy(sdmf2, j->cid_send.number);
3199 strcpy(sdmf3, j->cid_send.name);
3200
3201 len1 = strlen(sdmf1);
3202 len2 = strlen(sdmf2);
3203 len3 = strlen(sdmf3);
3204 mdmflen = len1 + len2 + len3 + 6;
3205
3206 while(1){
3207 ixj_write_cid_seize(j);
3208
3209 ixj_write_cid_byte(j, 0x80);
3210 checksum = 0x80;
3211 ixj_write_cid_byte(j, mdmflen);
3212 checksum = checksum + mdmflen;
3213
3214 ixj_write_cid_byte(j, 0x01);
3215 checksum = checksum + 0x01;
3216 ixj_write_cid_byte(j, len1);
3217 checksum = checksum + len1;
3218 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3219 if(ixj_hookstate(j) & 1)
3220 break;
3221
3222 ixj_write_cid_byte(j, 0x02);
3223 checksum = checksum + 0x02;
3224 ixj_write_cid_byte(j, len2);
3225 checksum = checksum + len2;
3226 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3227 if(ixj_hookstate(j) & 1)
3228 break;
3229
3230 ixj_write_cid_byte(j, 0x07);
3231 checksum = checksum + 0x07;
3232 ixj_write_cid_byte(j, len3);
3233 checksum = checksum + len3;
3234 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3235 if(ixj_hookstate(j) & 1)
3236 break;
3237
3238 checksum %= 256;
3239 checksum ^= 0xFF;
3240 checksum += 1;
3241
3242 ixj_write_cid_byte(j, (char) checksum);
3243
3244 pad = j->fskdcnt % 240;
3245 if (pad) {
3246 pad = 240 - pad;
3247 }
3248 ixj_pad_fsk(j, pad);
3249 break;
3250 }
3251
3252 ixj_write_frame(j);
3253}
3254
3255static void ixj_write_cidcw(IXJ *j)
3256{
3257 IXJ_TONE ti;
3258
3259 char sdmf1[50];
3260 char sdmf2[50];
3261 char sdmf3[80];
3262 char mdmflen, len1, len2, len3;
3263 int pad;
3264
3265 int checksum = 0;
3266
3267 if (j->dsp.low == 0x20 || j->flags.cidplay)
3268 return;
3269
3270 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3271 j->cidsize = j->cidcnt = 0;
3272
3273 ixj_fsk_alloc(j);
3274
3275 j->flags.cidcw_ack = 0;
3276
3277 ti.tone_index = 23;
3278 ti.gain0 = 1;
3279 ti.freq0 = hz440;
3280 ti.gain1 = 0;
3281 ti.freq1 = 0;
3282 ixj_init_tone(j, &ti);
3283
3284 ixj_set_tone_on(1500, j);
3285 ixj_set_tone_off(32, j);
3286 if(ixjdebug & 0x0200) {
3287 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3288 }
3289 ixj_play_tone(j, 23);
3290
3291 clear_bit(j->board, &j->busyflags);
Nishanth Aravamudan1e63bc72005-09-10 00:27:31 -0700[diff] [blame]3292 while(j->tone_state)
3293 schedule_timeout_interruptible(1);
3294 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3295 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3296 if(ixjdebug & 0x0200) {
3297 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3298 }
3299
3300 ti.tone_index = 24;
3301 ti.gain0 = 1;
3302 ti.freq0 = hz2130;
3303 ti.gain1 = 0;
3304 ti.freq1 = hz2750;
3305 ixj_init_tone(j, &ti);
3306
3307 ixj_set_tone_off(10, j);
3308 ixj_set_tone_on(600, j);
3309 if(ixjdebug & 0x0200) {
3310 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3311 }
3312 ixj_play_tone(j, 24);
3313
3314 clear_bit(j->board, &j->busyflags);
Nishanth Aravamudan1e63bc72005-09-10 00:27:31 -0700[diff] [blame]3315 while(j->tone_state)
3316 schedule_timeout_interruptible(1);
3317 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3318 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3319 if(ixjdebug & 0x0200) {
3320 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3321 }
3322
3323 j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3324
3325 clear_bit(j->board, &j->busyflags);
Nishanth Aravamudan1e63bc72005-09-10 00:27:31 -0700[diff] [blame]3326 while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3327 schedule_timeout_interruptible(1);
3328 while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3329 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3330 j->cidcw_wait = 0;
3331 if(!j->flags.cidcw_ack) {
3332 if(ixjdebug & 0x0200) {
3333 printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3334 }
3335 ixj_post_cid(j);
3336 if(j->cid_play_flag) {
3337 wake_up_interruptible(&j->write_q); /* Wake any blocked readers */
3338 }
3339 return;
3340 } else {
3341 ixj_pre_cid(j);
3342 }
3343 j->flags.cidcw_ack = 0;
3344 strcpy(sdmf1, j->cid_send.month);
3345 strcat(sdmf1, j->cid_send.day);
3346 strcat(sdmf1, j->cid_send.hour);
3347 strcat(sdmf1, j->cid_send.min);
3348 strcpy(sdmf2, j->cid_send.number);
3349 strcpy(sdmf3, j->cid_send.name);
3350
3351 len1 = strlen(sdmf1);
3352 len2 = strlen(sdmf2);
3353 len3 = strlen(sdmf3);
3354 mdmflen = len1 + len2 + len3 + 6;
3355
3356 ixj_write_cidcw_seize(j);
3357
3358 ixj_write_cid_byte(j, 0x80);
3359 checksum = 0x80;
3360 ixj_write_cid_byte(j, mdmflen);
3361 checksum = checksum + mdmflen;
3362
3363 ixj_write_cid_byte(j, 0x01);
3364 checksum = checksum + 0x01;
3365 ixj_write_cid_byte(j, len1);
3366 checksum = checksum + len1;
3367 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3368
3369 ixj_write_cid_byte(j, 0x02);
3370 checksum = checksum + 0x02;
3371 ixj_write_cid_byte(j, len2);
3372 checksum = checksum + len2;
3373 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3374
3375 ixj_write_cid_byte(j, 0x07);
3376 checksum = checksum + 0x07;
3377 ixj_write_cid_byte(j, len3);
3378 checksum = checksum + len3;
3379 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3380
3381 checksum %= 256;
3382 checksum ^= 0xFF;
3383 checksum += 1;
3384
3385 ixj_write_cid_byte(j, (char) checksum);
3386
3387 pad = j->fskdcnt % 240;
3388 if (pad) {
3389 pad = 240 - pad;
3390 }
3391 ixj_pad_fsk(j, pad);
3392 if(ixjdebug & 0x0200) {
3393 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3394 }
3395}
3396
3397static void ixj_write_vmwi(IXJ *j, int msg)
3398{
3399 char mdmflen;
3400 int pad;
3401
3402 int checksum = 0;
3403
3404 if (j->dsp.low == 0x20 || j->flags.cidplay)
3405 return;
3406
3407 j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3408 j->cidsize = j->cidcnt = 0;
3409
3410 ixj_fsk_alloc(j);
3411
3412 mdmflen = 3;
3413
3414 if (j->port == PORT_POTS)
3415 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3416
3417 ixj_write_cid_seize(j);
3418
3419 ixj_write_cid_byte(j, 0x82);
3420 checksum = 0x82;
3421 ixj_write_cid_byte(j, mdmflen);
3422 checksum = checksum + mdmflen;
3423
3424 ixj_write_cid_byte(j, 0x0B);
3425 checksum = checksum + 0x0B;
3426 ixj_write_cid_byte(j, 1);
3427 checksum = checksum + 1;
3428
3429 if(msg) {
3430 ixj_write_cid_byte(j, 0xFF);
3431 checksum = checksum + 0xFF;
3432 }
3433 else {
3434 ixj_write_cid_byte(j, 0x00);
3435 checksum = checksum + 0x00;
3436 }
3437
3438 checksum %= 256;
3439 checksum ^= 0xFF;
3440 checksum += 1;
3441
3442 ixj_write_cid_byte(j, (char) checksum);
3443
3444 pad = j->fskdcnt % 240;
3445 if (pad) {
3446 pad = 240 - pad;
3447 }
3448 ixj_pad_fsk(j, pad);
3449}
3450
3451static void ixj_write_frame(IXJ *j)
3452{
3453 int cnt, frame_count, dly;
3454 IXJ_WORD dat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3455
3456 frame_count = 0;
3457 if(j->flags.cidplay) {
3458 for(cnt = 0; cnt < 480; cnt++) {
3459 if (!(cnt % 16) && !IsTxReady(j)) {
3460 dly = 0;
3461 while (!IsTxReady(j)) {
3462 if (dly++ > 5) {
3463 dly = 0;
3464 break;
3465 }
3466 udelay(10);
3467 }
3468 }
3469 dat.word = j->fskdata[j->cidcnt++];
3470 outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3471 outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3472 cnt++;
3473 }
3474 if(j->cidcnt >= j->fskdcnt) {
3475 ixj_post_cid(j);
3476 }
3477 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3478 and there is real audio data in the buffer, we need to throw it away because
3479 we just used it's time slot */
3480 if (j->write_buffer_rp > j->write_buffer_wp) {
3481 j->write_buffer_rp += j->cid_play_frame_size * 2;
3482 if (j->write_buffer_rp >= j->write_buffer_end) {
3483 j->write_buffer_rp = j->write_buffer;
3484 }
3485 j->write_buffers_empty++;
3486 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3487
3488 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3489 }
3490 } else if (j->write_buffer && j->write_buffers_empty < 1) {
3491 if (j->write_buffer_wp > j->write_buffer_rp) {
3492 frame_count =
3493 (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3494 }
3495 if (j->write_buffer_rp > j->write_buffer_wp) {
3496 frame_count =
3497 (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3498 (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3499 }
3500 if (frame_count >= 1) {
3501 if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
Jeff Garzik0d480db2007-07-17 01:35:08 -0400[diff] [blame]3502 BYTES blankword;
3503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3504 switch (j->play_mode) {
3505 case PLAYBACK_MODE_ULAW:
3506 case PLAYBACK_MODE_ALAW:
3507 blankword.low = blankword.high = 0xFF;
3508 break;
3509 case PLAYBACK_MODE_8LINEAR:
3510 case PLAYBACK_MODE_16LINEAR:
Jeff Garzik0d480db2007-07-17 01:35:08 -0400[diff] [blame]3511 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3512 blankword.low = blankword.high = 0x00;
3513 break;
3514 case PLAYBACK_MODE_8LINEAR_WSS:
3515 blankword.low = blankword.high = 0x80;
3516 break;
3517 }
3518 for (cnt = 0; cnt < 16; cnt++) {
3519 if (!(cnt % 16) && !IsTxReady(j)) {
3520 dly = 0;
3521 while (!IsTxReady(j)) {
3522 if (dly++ > 5) {
3523 dly = 0;
3524 break;
3525 }
3526 udelay(10);
3527 }
3528 }
3529 outb_p((blankword.low), j->DSPbase + 0x0C);
3530 outb_p((blankword.high), j->DSPbase + 0x0D);
3531 }
3532 j->flags.play_first_frame = 0;
3533 } else if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3534 for (cnt = 0; cnt < 24; cnt++) {
Jeff Garzik0d480db2007-07-17 01:35:08 -0400[diff] [blame]3535 BYTES blankword;
3536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3537 if(cnt == 12) {
3538 blankword.low = 0x02;
3539 blankword.high = 0x00;
3540 }
3541 else {
3542 blankword.low = blankword.high = 0x00;
3543 }
3544 if (!(cnt % 16) && !IsTxReady(j)) {
3545 dly = 0;
3546 while (!IsTxReady(j)) {
3547 if (dly++ > 5) {
3548 dly = 0;
3549 break;
3550 }
3551 udelay(10);
3552 }
3553 }
3554 outb_p((blankword.low), j->DSPbase + 0x0C);
3555 outb_p((blankword.high), j->DSPbase + 0x0D);
3556 }
3557 j->flags.play_first_frame = 0;
3558 }
3559 for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3560 if (!(cnt % 16) && !IsTxReady(j)) {
3561 dly = 0;
3562 while (!IsTxReady(j)) {
3563 if (dly++ > 5) {
3564 dly = 0;
3565 break;
3566 }
3567 udelay(10);
3568 }
3569 }
3570 /* Add word 0 to G.729 frames for the 8021. Right now we don't do VAD/CNG */
3571 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
Alexey Dobriyan66ac5a22006-02-03 03:04:35 -0800[diff] [blame]3572 if (j->write_buffer_rp[cnt] == 0 &&
3573 j->write_buffer_rp[cnt + 1] == 0 &&
3574 j->write_buffer_rp[cnt + 2] == 0 &&
3575 j->write_buffer_rp[cnt + 3] == 0 &&
3576 j->write_buffer_rp[cnt + 4] == 0 &&
3577 j->write_buffer_rp[cnt + 5] == 0 &&
3578 j->write_buffer_rp[cnt + 6] == 0 &&
3579 j->write_buffer_rp[cnt + 7] == 0 &&
3580 j->write_buffer_rp[cnt + 8] == 0 &&
3581 j->write_buffer_rp[cnt + 9] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3582 /* someone is trying to write silence lets make this a type 0 frame. */
3583 outb_p(0x00, j->DSPbase + 0x0C);
3584 outb_p(0x00, j->DSPbase + 0x0D);
3585 } else {
3586 /* so all other frames are type 1. */
3587 outb_p(0x01, j->DSPbase + 0x0C);
3588 outb_p(0x00, j->DSPbase + 0x0D);
3589 }
3590 }
3591 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3592 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3593 *(j->write_buffer_rp + cnt) = 0;
3594 *(j->write_buffer_rp + cnt + 1) = 0;
3595 }
3596 j->write_buffer_rp += j->play_frame_size * 2;
3597 if (j->write_buffer_rp >= j->write_buffer_end) {
3598 j->write_buffer_rp = j->write_buffer;
3599 }
3600 j->write_buffers_empty++;
3601 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
3602
3603 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
3604
3605 ++j->frameswritten;
3606 }
3607 } else {
3608 j->drybuffer++;
3609 }
3610 if(j->ixj_signals[SIG_WRITE_READY]) {
3611 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3612 }
3613}
3614
3615static int idle(IXJ *j)
3616{
3617 if (ixj_WriteDSPCommand(0x0000, j)) /* DSP Idle */
3618
3619 return 0;
3620
3621 if (j->ssr.high || j->ssr.low) {
3622 return 0;
3623 } else {
3624 j->play_mode = -1;
3625 j->flags.playing = 0;
3626 j->rec_mode = -1;
3627 j->flags.recording = 0;
3628 return 1;
3629 }
3630}
3631
3632static int set_base_frame(IXJ *j, int size)
3633{
3634 unsigned short cmd;
3635 int cnt;
3636
3637 idle(j);
3638 j->cid_play_aec_level = j->aec_level;
3639 aec_stop(j);
3640 for (cnt = 0; cnt < 10; cnt++) {
3641 if (idle(j))
3642 break;
3643 }
3644 if (j->ssr.high || j->ssr.low)
3645 return -1;
3646 if (j->dsp.low != 0x20) {
3647 switch (size) {
3648 case 30:
3649 cmd = 0x07F0;
3650 /* Set Base Frame Size to 240 pg9-10 8021 */
3651 break;
3652 case 20:
3653 cmd = 0x07A0;
3654 /* Set Base Frame Size to 160 pg9-10 8021 */
3655 break;
3656 case 10:
3657 cmd = 0x0750;
3658 /* Set Base Frame Size to 80 pg9-10 8021 */
3659 break;
3660 default:
3661 return -1;
3662 }
3663 } else {
3664 if (size == 30)
3665 return size;
3666 else
3667 return -1;
3668 }
3669 if (ixj_WriteDSPCommand(cmd, j)) {
3670 j->baseframe.high = j->baseframe.low = 0xFF;
3671 return -1;
3672 } else {
3673 j->baseframe.high = j->ssr.high;
3674 j->baseframe.low = j->ssr.low;
3675 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3676 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3677 return -1;
3678 }
3679 }
3680 ixj_aec_start(j, j->cid_play_aec_level);
3681 return size;
3682}
3683
3684static int set_rec_codec(IXJ *j, int rate)
3685{
3686 int retval = 0;
3687
3688 j->rec_codec = rate;
3689
3690 switch (rate) {
3691 case G723_63:
3692 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3693 j->rec_frame_size = 12;
3694 j->rec_mode = 0;
3695 } else {
3696 retval = 1;
3697 }
3698 break;
3699 case G723_53:
3700 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3701 j->rec_frame_size = 10;
3702 j->rec_mode = 0;
3703 } else {
3704 retval = 1;
3705 }
3706 break;
3707 case TS85:
3708 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3709 j->rec_frame_size = 16;
3710 j->rec_mode = 0;
3711 } else {
3712 retval = 1;
3713 }
3714 break;
3715 case TS48:
3716 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3717 j->rec_frame_size = 9;
3718 j->rec_mode = 0;
3719 } else {
3720 retval = 1;
3721 }
3722 break;
3723 case TS41:
3724 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3725 j->rec_frame_size = 8;
3726 j->rec_mode = 0;
3727 } else {
3728 retval = 1;
3729 }
3730 break;
3731 case G728:
3732 if (j->dsp.low != 0x20) {
3733 j->rec_frame_size = 48;
3734 j->rec_mode = 0;
3735 } else {
3736 retval = 1;
3737 }
3738 break;
3739 case G729:
3740 if (j->dsp.low != 0x20) {
3741 if (!j->flags.g729_loaded) {
3742 retval = 1;
3743 break;
3744 }
3745 switch (j->baseframe.low) {
3746 case 0xA0:
3747 j->rec_frame_size = 10;
3748 break;
3749 case 0x50:
3750 j->rec_frame_size = 5;
3751 break;
3752 default:
3753 j->rec_frame_size = 15;
3754 break;
3755 }
3756 j->rec_mode = 0;
3757 } else {
3758 retval = 1;
3759 }
3760 break;
3761 case G729B:
3762 if (j->dsp.low != 0x20) {
3763 if (!j->flags.g729_loaded) {
3764 retval = 1;
3765 break;
3766 }
3767 switch (j->baseframe.low) {
3768 case 0xA0:
3769 j->rec_frame_size = 12;
3770 break;
3771 case 0x50:
3772 j->rec_frame_size = 6;
3773 break;
3774 default:
3775 j->rec_frame_size = 18;
3776 break;
3777 }
3778 j->rec_mode = 0;
3779 } else {
3780 retval = 1;
3781 }
3782 break;
3783 case ULAW:
3784 switch (j->baseframe.low) {
3785 case 0xA0:
3786 j->rec_frame_size = 80;
3787 break;
3788 case 0x50:
3789 j->rec_frame_size = 40;
3790 break;
3791 default:
3792 j->rec_frame_size = 120;
3793 break;
3794 }
3795 j->rec_mode = 4;
3796 break;
3797 case ALAW:
3798 switch (j->baseframe.low) {
3799 case 0xA0:
3800 j->rec_frame_size = 80;
3801 break;
3802 case 0x50:
3803 j->rec_frame_size = 40;
3804 break;
3805 default:
3806 j->rec_frame_size = 120;
3807 break;
3808 }
3809 j->rec_mode = 4;
3810 break;
3811 case LINEAR16:
3812 switch (j->baseframe.low) {
3813 case 0xA0:
3814 j->rec_frame_size = 160;
3815 break;
3816 case 0x50:
3817 j->rec_frame_size = 80;
3818 break;
3819 default:
3820 j->rec_frame_size = 240;
3821 break;
3822 }
3823 j->rec_mode = 5;
3824 break;
3825 case LINEAR8:
3826 switch (j->baseframe.low) {
3827 case 0xA0:
3828 j->rec_frame_size = 80;
3829 break;
3830 case 0x50:
3831 j->rec_frame_size = 40;
3832 break;
3833 default:
3834 j->rec_frame_size = 120;
3835 break;
3836 }
3837 j->rec_mode = 6;
3838 break;
3839 case WSS:
3840 switch (j->baseframe.low) {
3841 case 0xA0:
3842 j->rec_frame_size = 80;
3843 break;
3844 case 0x50:
3845 j->rec_frame_size = 40;
3846 break;
3847 default:
3848 j->rec_frame_size = 120;
3849 break;
3850 }
3851 j->rec_mode = 7;
3852 break;
3853 default:
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]3854 kfree(j->read_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3855 j->rec_frame_size = 0;
3856 j->rec_mode = -1;
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]3857 j->read_buffer = NULL;
3858 j->read_buffer_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3859 retval = 1;
3860 break;
3861 }
3862 return retval;
3863}
3864
3865static int ixj_record_start(IXJ *j)
3866{
3867 unsigned short cmd = 0x0000;
3868
3869 if (j->read_buffer) {
3870 ixj_record_stop(j);
3871 }
3872 j->flags.recording = 1;
3873 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3874
3875 if(ixjdebug & 0x0002)
3876 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3877
3878 if (!j->rec_mode) {
3879 switch (j->rec_codec) {
3880 case G723_63:
3881 cmd = 0x5131;
3882 break;
3883 case G723_53:
3884 cmd = 0x5132;
3885 break;
3886 case TS85:
3887 cmd = 0x5130; /* TrueSpeech 8.5 */
3888
3889 break;
3890 case TS48:
3891 cmd = 0x5133; /* TrueSpeech 4.8 */
3892
3893 break;
3894 case TS41:
3895 cmd = 0x5134; /* TrueSpeech 4.1 */
3896
3897 break;
3898 case G728:
3899 cmd = 0x5135;
3900 break;
3901 case G729:
3902 case G729B:
3903 cmd = 0x5136;
3904 break;
3905 default:
3906 return 1;
3907 }
3908 if (ixj_WriteDSPCommand(cmd, j))
3909 return -1;
3910 }
3911 if (!j->read_buffer) {
3912 if (!j->read_buffer)
3913 j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3914 if (!j->read_buffer) {
3915 printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3916 return -ENOMEM;
3917 }
3918 }
3919 j->read_buffer_size = j->rec_frame_size * 2;
3920
3921 if (ixj_WriteDSPCommand(0x5102, j)) /* Set Poll sync mode */
3922
3923 return -1;
3924
3925 switch (j->rec_mode) {
3926 case 0:
3927 cmd = 0x1C03; /* Record C1 */
3928
3929 break;
3930 case 4:
3931 if (j->ver.low == 0x12) {
3932 cmd = 0x1E03; /* Record C1 */
3933
3934 } else {
3935 cmd = 0x1E01; /* Record C1 */
3936
3937 }
3938 break;
3939 case 5:
3940 if (j->ver.low == 0x12) {
3941 cmd = 0x1E83; /* Record C1 */
3942
3943 } else {
3944 cmd = 0x1E81; /* Record C1 */
3945
3946 }
3947 break;
3948 case 6:
3949 if (j->ver.low == 0x12) {
3950 cmd = 0x1F03; /* Record C1 */
3951
3952 } else {
3953 cmd = 0x1F01; /* Record C1 */
3954
3955 }
3956 break;
3957 case 7:
3958 if (j->ver.low == 0x12) {
3959 cmd = 0x1F83; /* Record C1 */
3960 } else {
3961 cmd = 0x1F81; /* Record C1 */
3962 }
3963 break;
3964 }
3965 if (ixj_WriteDSPCommand(cmd, j))
3966 return -1;
3967
3968 if (j->flags.playing) {
3969 ixj_aec_start(j, j->aec_level);
3970 }
3971 return 0;
3972}
3973
3974static void ixj_record_stop(IXJ *j)
3975{
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]3976 if (ixjdebug & 0x0002)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3977 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3978
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]3979 kfree(j->read_buffer);
3980 j->read_buffer = NULL;
3981 j->read_buffer_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]3982 if (j->rec_mode > -1) {
3983 ixj_WriteDSPCommand(0x5120, j);
3984 j->rec_mode = -1;
3985 }
3986 j->flags.recording = 0;
3987}
3988static void ixj_vad(IXJ *j, int arg)
3989{
3990 if (arg)
3991 ixj_WriteDSPCommand(0x513F, j);
3992 else
3993 ixj_WriteDSPCommand(0x513E, j);
3994}
3995
3996static void set_rec_depth(IXJ *j, int depth)
3997{
3998 if (depth > 60)
3999 depth = 60;
4000 if (depth < 0)
4001 depth = 0;
4002 ixj_WriteDSPCommand(0x5180 + depth, j);
4003}
4004
4005static void set_dtmf_prescale(IXJ *j, int volume)
4006{
4007 ixj_WriteDSPCommand(0xCF07, j);
4008 ixj_WriteDSPCommand(volume, j);
4009}
4010
4011static int get_dtmf_prescale(IXJ *j)
4012{
4013 ixj_WriteDSPCommand(0xCF05, j);
4014 return j->ssr.high << 8 | j->ssr.low;
4015}
4016
4017static void set_rec_volume(IXJ *j, int volume)
4018{
4019 if(j->aec_level == AEC_AGC) {
4020 if (ixjdebug & 0x0002)
4021 printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4022 ixj_WriteDSPCommand(0xCF96, j);
4023 ixj_WriteDSPCommand(volume, j);
4024 } else {
4025 if (ixjdebug & 0x0002)
4026 printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4027 ixj_WriteDSPCommand(0xCF03, j);
4028 ixj_WriteDSPCommand(volume, j);
4029 }
4030}
4031
4032static int set_rec_volume_linear(IXJ *j, int volume)
4033{
4034 int newvolume, dsprecmax;
4035
4036 if (ixjdebug & 0x0002)
4037 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4038 if(volume > 100 || volume < 0) {
4039 return -1;
4040 }
4041
4042 /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4043 switch (j->cardtype) {
4044 case QTI_PHONEJACK:
4045 dsprecmax = 0x440;
4046 break;
4047 case QTI_LINEJACK:
4048 dsprecmax = 0x180;
4049 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
4050 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
4051 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
4052 break;
4053 case QTI_PHONEJACK_LITE:
4054 dsprecmax = 0x4C0;
4055 break;
4056 case QTI_PHONEJACK_PCI:
4057 dsprecmax = 0x100;
4058 break;
4059 case QTI_PHONECARD:
4060 dsprecmax = 0x400;
4061 break;
4062 default:
4063 return -1;
4064 }
4065 newvolume = (dsprecmax * volume) / 100;
4066 set_rec_volume(j, newvolume);
4067 return 0;
4068}
4069
4070static int get_rec_volume(IXJ *j)
4071{
4072 if(j->aec_level == AEC_AGC) {
4073 if (ixjdebug & 0x0002)
4074 printk(KERN_INFO "Getting AGC Threshold\n");
4075 ixj_WriteDSPCommand(0xCF86, j);
4076 if (ixjdebug & 0x0002)
4077 printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4078 return j->ssr.high << 8 | j->ssr.low;
4079 } else {
4080 if (ixjdebug & 0x0002)
4081 printk(KERN_INFO "Getting Record Volume\n");
4082 ixj_WriteDSPCommand(0xCF01, j);
4083 return j->ssr.high << 8 | j->ssr.low;
4084 }
4085}
4086
4087static int get_rec_volume_linear(IXJ *j)
4088{
4089 int volume, newvolume, dsprecmax;
4090
4091 switch (j->cardtype) {
4092 case QTI_PHONEJACK:
4093 dsprecmax = 0x440;
4094 break;
4095 case QTI_LINEJACK:
4096 dsprecmax = 0x180;
4097 break;
4098 case QTI_PHONEJACK_LITE:
4099 dsprecmax = 0x4C0;
4100 break;
4101 case QTI_PHONEJACK_PCI:
4102 dsprecmax = 0x100;
4103 break;
4104 case QTI_PHONECARD:
4105 dsprecmax = 0x400;
4106 break;
4107 default:
4108 return -1;
4109 }
4110 volume = get_rec_volume(j);
4111 newvolume = (volume * 100) / dsprecmax;
4112 if(newvolume > 100)
4113 newvolume = 100;
4114 return newvolume;
4115}
4116
4117static int get_rec_level(IXJ *j)
4118{
4119 int retval;
4120
4121 ixj_WriteDSPCommand(0xCF88, j);
4122
4123 retval = j->ssr.high << 8 | j->ssr.low;
4124 retval = (retval * 256) / 240;
4125 return retval;
4126}
4127
4128static void ixj_aec_start(IXJ *j, int level)
4129{
4130 j->aec_level = level;
4131 if (ixjdebug & 0x0002)
4132 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4133 if (!level) {
4134 aec_stop(j);
4135 } else {
4136 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4137 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4138
4139 ixj_WriteDSPCommand(0x0300, j);
4140 }
4141 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4142
4143 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4144
4145 switch (level) {
4146 case AEC_LOW:
4147 ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4148
4149 ixj_WriteDSPCommand(0xE011, j);
4150 ixj_WriteDSPCommand(0xFFFF, j);
4151
4152 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4153 ixj_WriteDSPCommand(0x0000, j); /* to off */
4154
4155 break;
4156
4157 case AEC_MED:
4158 ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4159
4160 ixj_WriteDSPCommand(0xE011, j);
4161 ixj_WriteDSPCommand(0x0080, j);
4162
4163 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4164 ixj_WriteDSPCommand(0x0000, j); /* to off */
4165
4166 break;
4167
4168 case AEC_HIGH:
4169 ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4170
4171 ixj_WriteDSPCommand(0xE011, j);
4172 ixj_WriteDSPCommand(0x0080, j);
4173
4174 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4175 ixj_WriteDSPCommand(0x0000, j); /* to off */
4176
4177 break;
4178
4179 case AEC_AGC:
4180 /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4181 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4182
4183 ixj_WriteDSPCommand(0xE011, j);
4184 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4185
4186 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4187
4188 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4189 ixj_WriteDSPCommand(0x0224, j);
4190 else
4191 ixj_WriteDSPCommand(0x1224, j);
4192
4193 ixj_WriteDSPCommand(0xE014, j);
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200[diff] [blame]4194 ixj_WriteDSPCommand(0x0003, j); /* Lock threshold at 3dB */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4195
4196 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4197
4198 /* Now we can set the AGC initial parameters and turn it on */
4199 ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4200 ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4201
4202 ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4203 ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4204
4205 ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4206 ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4207
4208 ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4209 ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4210
4211 ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4212 ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4213
4214 ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4215 ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4216
4217 ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4218 ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4219
4220 ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4221 ixj_WriteDSPCommand(0x0001, j); /* to on */
4222
4223 break;
4224
4225 case AEC_AUTO:
4226 ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4227
4228 ixj_WriteDSPCommand(0xE011, j);
4229 ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4230
4231 ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4232
4233 if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4234 ixj_WriteDSPCommand(0x0224, j);
4235 else
4236 ixj_WriteDSPCommand(0x1224, j);
4237
4238 ixj_WriteDSPCommand(0xE014, j);
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200[diff] [blame]4239 ixj_WriteDSPCommand(0x0003, j); /* Lock threshold at 3dB */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4240
4241 ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4242
4243 break;
4244 }
4245 }
4246}
4247
4248static void aec_stop(IXJ *j)
4249{
4250 j->aec_level = AEC_OFF;
4251 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4252 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4253
4254 ixj_WriteDSPCommand(0x0700, j);
4255 }
4256 if (j->play_mode != -1 && j->rec_mode != -1)
4257 {
4258 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4259 }
4260}
4261
4262static int set_play_codec(IXJ *j, int rate)
4263{
4264 int retval = 0;
4265
4266 j->play_codec = rate;
4267
4268 switch (rate) {
4269 case G723_63:
4270 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4271 j->play_frame_size = 12;
4272 j->play_mode = 0;
4273 } else {
4274 retval = 1;
4275 }
4276 break;
4277 case G723_53:
4278 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4279 j->play_frame_size = 10;
4280 j->play_mode = 0;
4281 } else {
4282 retval = 1;
4283 }
4284 break;
4285 case TS85:
4286 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4287 j->play_frame_size = 16;
4288 j->play_mode = 0;
4289 } else {
4290 retval = 1;
4291 }
4292 break;
4293 case TS48:
4294 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4295 j->play_frame_size = 9;
4296 j->play_mode = 0;
4297 } else {
4298 retval = 1;
4299 }
4300 break;
4301 case TS41:
4302 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4303 j->play_frame_size = 8;
4304 j->play_mode = 0;
4305 } else {
4306 retval = 1;
4307 }
4308 break;
4309 case G728:
4310 if (j->dsp.low != 0x20) {
4311 j->play_frame_size = 48;
4312 j->play_mode = 0;
4313 } else {
4314 retval = 1;
4315 }
4316 break;
4317 case G729:
4318 if (j->dsp.low != 0x20) {
4319 if (!j->flags.g729_loaded) {
4320 retval = 1;
4321 break;
4322 }
4323 switch (j->baseframe.low) {
4324 case 0xA0:
4325 j->play_frame_size = 10;
4326 break;
4327 case 0x50:
4328 j->play_frame_size = 5;
4329 break;
4330 default:
4331 j->play_frame_size = 15;
4332 break;
4333 }
4334 j->play_mode = 0;
4335 } else {
4336 retval = 1;
4337 }
4338 break;
4339 case G729B:
4340 if (j->dsp.low != 0x20) {
4341 if (!j->flags.g729_loaded) {
4342 retval = 1;
4343 break;
4344 }
4345 switch (j->baseframe.low) {
4346 case 0xA0:
4347 j->play_frame_size = 12;
4348 break;
4349 case 0x50:
4350 j->play_frame_size = 6;
4351 break;
4352 default:
4353 j->play_frame_size = 18;
4354 break;
4355 }
4356 j->play_mode = 0;
4357 } else {
4358 retval = 1;
4359 }
4360 break;
4361 case ULAW:
4362 switch (j->baseframe.low) {
4363 case 0xA0:
4364 j->play_frame_size = 80;
4365 break;
4366 case 0x50:
4367 j->play_frame_size = 40;
4368 break;
4369 default:
4370 j->play_frame_size = 120;
4371 break;
4372 }
4373 j->play_mode = 2;
4374 break;
4375 case ALAW:
4376 switch (j->baseframe.low) {
4377 case 0xA0:
4378 j->play_frame_size = 80;
4379 break;
4380 case 0x50:
4381 j->play_frame_size = 40;
4382 break;
4383 default:
4384 j->play_frame_size = 120;
4385 break;
4386 }
4387 j->play_mode = 2;
4388 break;
4389 case LINEAR16:
4390 switch (j->baseframe.low) {
4391 case 0xA0:
4392 j->play_frame_size = 160;
4393 break;
4394 case 0x50:
4395 j->play_frame_size = 80;
4396 break;
4397 default:
4398 j->play_frame_size = 240;
4399 break;
4400 }
4401 j->play_mode = 6;
4402 break;
4403 case LINEAR8:
4404 switch (j->baseframe.low) {
4405 case 0xA0:
4406 j->play_frame_size = 80;
4407 break;
4408 case 0x50:
4409 j->play_frame_size = 40;
4410 break;
4411 default:
4412 j->play_frame_size = 120;
4413 break;
4414 }
4415 j->play_mode = 4;
4416 break;
4417 case WSS:
4418 switch (j->baseframe.low) {
4419 case 0xA0:
4420 j->play_frame_size = 80;
4421 break;
4422 case 0x50:
4423 j->play_frame_size = 40;
4424 break;
4425 default:
4426 j->play_frame_size = 120;
4427 break;
4428 }
4429 j->play_mode = 5;
4430 break;
4431 default:
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]4432 kfree(j->write_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4433 j->play_frame_size = 0;
4434 j->play_mode = -1;
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]4435 j->write_buffer = NULL;
4436 j->write_buffer_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4437 retval = 1;
4438 break;
4439 }
4440 return retval;
4441}
4442
4443static int ixj_play_start(IXJ *j)
4444{
4445 unsigned short cmd = 0x0000;
4446
4447 if (j->write_buffer) {
4448 ixj_play_stop(j);
4449 }
4450
4451 if(ixjdebug & 0x0002)
4452 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4453
4454 j->flags.playing = 1;
4455 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4456
4457 j->flags.play_first_frame = 1;
4458 j->drybuffer = 0;
4459
4460 if (!j->play_mode) {
4461 switch (j->play_codec) {
4462 case G723_63:
4463 cmd = 0x5231;
4464 break;
4465 case G723_53:
4466 cmd = 0x5232;
4467 break;
4468 case TS85:
4469 cmd = 0x5230; /* TrueSpeech 8.5 */
4470
4471 break;
4472 case TS48:
4473 cmd = 0x5233; /* TrueSpeech 4.8 */
4474
4475 break;
4476 case TS41:
4477 cmd = 0x5234; /* TrueSpeech 4.1 */
4478
4479 break;
4480 case G728:
4481 cmd = 0x5235;
4482 break;
4483 case G729:
4484 case G729B:
4485 cmd = 0x5236;
4486 break;
4487 default:
4488 return 1;
4489 }
4490 if (ixj_WriteDSPCommand(cmd, j))
4491 return -1;
4492 }
4493 j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4494 if (!j->write_buffer) {
4495 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4496 return -ENOMEM;
4497 }
4498/* j->write_buffers_empty = 2; */
4499 j->write_buffers_empty = 1;
4500 j->write_buffer_size = j->play_frame_size * 2;
4501 j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4502 j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4503
4504 if (ixj_WriteDSPCommand(0x5202, j)) /* Set Poll sync mode */
4505
4506 return -1;
4507
4508 switch (j->play_mode) {
4509 case 0:
4510 cmd = 0x2C03;
4511 break;
4512 case 2:
4513 if (j->ver.low == 0x12) {
4514 cmd = 0x2C23;
4515 } else {
4516 cmd = 0x2C21;
4517 }
4518 break;
4519 case 4:
4520 if (j->ver.low == 0x12) {
4521 cmd = 0x2C43;
4522 } else {
4523 cmd = 0x2C41;
4524 }
4525 break;
4526 case 5:
4527 if (j->ver.low == 0x12) {
4528 cmd = 0x2C53;
4529 } else {
4530 cmd = 0x2C51;
4531 }
4532 break;
4533 case 6:
4534 if (j->ver.low == 0x12) {
4535 cmd = 0x2C63;
4536 } else {
4537 cmd = 0x2C61;
4538 }
4539 break;
4540 }
4541 if (ixj_WriteDSPCommand(cmd, j))
4542 return -1;
4543
4544 if (ixj_WriteDSPCommand(0x2000, j)) /* Playback C2 */
4545 return -1;
4546
4547 if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j)) /* Playback C3 */
4548 return -1;
4549
4550 if (j->flags.recording) {
4551 ixj_aec_start(j, j->aec_level);
4552 }
4553
4554 return 0;
4555}
4556
4557static void ixj_play_stop(IXJ *j)
4558{
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]4559 if (ixjdebug & 0x0002)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4560 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4561
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]4562 kfree(j->write_buffer);
4563 j->write_buffer = NULL;
4564 j->write_buffer_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4565 if (j->play_mode > -1) {
4566 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers. 8022 reference page 9-40 */
4567
4568 j->play_mode = -1;
4569 }
4570 j->flags.playing = 0;
4571}
4572
4573static inline int get_play_level(IXJ *j)
4574{
4575 int retval;
4576
4577 ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4578 return j->ssr.high << 8 | j->ssr.low;
4579 retval = j->ssr.high << 8 | j->ssr.low;
4580 retval = (retval * 256) / 240;
4581 return retval;
4582}
4583
4584static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4585{
4586 unsigned int mask = 0;
4587
Josef Sipekd1f22972006-12-08 02:37:14 -0800[diff] [blame]4588 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4589
4590 poll_wait(file_p, &(j->poll_q), wait);
4591 if (j->read_buffer_ready > 0)
4592 mask |= POLLIN | POLLRDNORM; /* readable */
4593 if (j->write_buffers_empty > 0)
4594 mask |= POLLOUT | POLLWRNORM; /* writable */
4595 if (j->ex.bytes)
4596 mask |= POLLPRI;
4597 return mask;
4598}
4599
4600static int ixj_play_tone(IXJ *j, char tone)
4601{
4602 if (!j->tone_state) {
4603 if(ixjdebug & 0x0002) {
4604 printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4605 }
4606 if (j->dsp.low == 0x20) {
4607 idle(j);
4608 }
4609 j->tone_start_jif = jiffies;
4610
4611 j->tone_state = 1;
4612 }
4613
4614 j->tone_index = tone;
4615 if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4616 return -1;
4617
4618 return 0;
4619}
4620
4621static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4622{
4623 j->tone_on_time = arg;
4624
4625 if (ixj_WriteDSPCommand(0x6E04, j)) /* Set Tone On Period */
4626
4627 return -1;
4628
4629 if (ixj_WriteDSPCommand(arg, j))
4630 return -1;
4631
4632 return 0;
4633}
4634
4635static int SCI_WaitHighSCI(IXJ *j)
4636{
4637 int cnt;
4638
4639 j->pld_scrr.byte = inb_p(j->XILINXbase);
4640 if (!j->pld_scrr.bits.sci) {
4641 for (cnt = 0; cnt < 10; cnt++) {
4642 udelay(32);
4643 j->pld_scrr.byte = inb_p(j->XILINXbase);
4644
4645 if ((j->pld_scrr.bits.sci))
4646 return 1;
4647 }
4648 if (ixjdebug & 0x0001)
4649 printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4650 return 0;
4651 } else
4652 return 1;
4653}
4654
4655static int SCI_WaitLowSCI(IXJ *j)
4656{
4657 int cnt;
4658
4659 j->pld_scrr.byte = inb_p(j->XILINXbase);
4660 if (j->pld_scrr.bits.sci) {
4661 for (cnt = 0; cnt < 10; cnt++) {
4662 udelay(32);
4663 j->pld_scrr.byte = inb_p(j->XILINXbase);
4664
4665 if (!(j->pld_scrr.bits.sci))
4666 return 1;
4667 }
4668 if (ixjdebug & 0x0001)
4669 printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4670 return 0;
4671 } else
4672 return 1;
4673}
4674
4675static int SCI_Control(IXJ *j, int control)
4676{
4677 switch (control) {
4678 case SCI_End:
4679 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4680
4681 j->pld_scrw.bits.c1 = 0; /* to no selection */
4682
4683 break;
4684 case SCI_Enable_DAA:
4685 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4686
4687 j->pld_scrw.bits.c1 = 0; /* to write to DAA */
4688
4689 break;
4690 case SCI_Enable_Mixer:
4691 j->pld_scrw.bits.c0 = 0; /* Set PLD Serial control interface */
4692
4693 j->pld_scrw.bits.c1 = 1; /* to write to mixer */
4694
4695 break;
4696 case SCI_Enable_EEPROM:
4697 j->pld_scrw.bits.c0 = 1; /* Set PLD Serial control interface */
4698
4699 j->pld_scrw.bits.c1 = 1; /* to write to EEPROM */
4700
4701 break;
4702 default:
4703 return 0;
4704 break;
4705 }
4706 outb_p(j->pld_scrw.byte, j->XILINXbase);
4707
4708 switch (control) {
4709 case SCI_End:
4710 return 1;
4711 break;
4712 case SCI_Enable_DAA:
4713 case SCI_Enable_Mixer:
4714 case SCI_Enable_EEPROM:
4715 if (!SCI_WaitHighSCI(j))
4716 return 0;
4717 break;
4718 default:
4719 return 0;
4720 break;
4721 }
4722 return 1;
4723}
4724
4725static int SCI_Prepare(IXJ *j)
4726{
4727 if (!SCI_Control(j, SCI_End))
4728 return 0;
4729
4730 if (!SCI_WaitLowSCI(j))
4731 return 0;
4732
4733 return 1;
4734}
4735
4736static int ixj_get_mixer(long val, IXJ *j)
4737{
4738 int reg = (val & 0x1F00) >> 8;
4739 return j->mix.vol[reg];
4740}
4741
4742static int ixj_mixer(long val, IXJ *j)
4743{
4744 BYTES bytes;
4745
4746 bytes.high = (val & 0x1F00) >> 8;
4747 bytes.low = val & 0x00FF;
4748
4749 /* save mixer value so we can get back later on */
4750 j->mix.vol[bytes.high] = bytes.low;
4751
4752 outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); /* Load Mixer Address */
4753
4754 outb_p(bytes.low, j->XILINXbase + 0x02); /* Load Mixer Data */
4755
4756 SCI_Control(j, SCI_Enable_Mixer);
4757
4758 SCI_Control(j, SCI_End);
4759
4760 return 0;
4761}
4762
4763static int daa_load(BYTES * p_bytes, IXJ *j)
4764{
4765 outb_p(p_bytes->high, j->XILINXbase + 0x03);
4766 outb_p(p_bytes->low, j->XILINXbase + 0x02);
4767 if (!SCI_Control(j, SCI_Enable_DAA))
4768 return 0;
4769 else
4770 return 1;
4771}
4772
4773static int ixj_daa_cr4(IXJ *j, char reg)
4774{
4775 BYTES bytes;
4776
4777 switch (j->daa_mode) {
4778 case SOP_PU_SLEEP:
4779 bytes.high = 0x14;
4780 break;
4781 case SOP_PU_RINGING:
4782 bytes.high = 0x54;
4783 break;
4784 case SOP_PU_CONVERSATION:
4785 bytes.high = 0x94;
4786 break;
4787 case SOP_PU_PULSEDIALING:
4788 bytes.high = 0xD4;
4789 break;
4790 }
4791
4792 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4793
4794 switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4795 case 0:
4796 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4797 break;
4798 case 1:
4799 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4800 break;
4801 case 2:
4802 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4803 break;
4804 case 3:
4805 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4806 break;
4807 }
4808
4809 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4810
4811 if (!daa_load(&bytes, j))
4812 return 0;
4813
4814 if (!SCI_Prepare(j))
4815 return 0;
4816
4817 return 1;
4818}
4819
4820static char daa_int_read(IXJ *j)
4821{
4822 BYTES bytes;
4823
4824 if (!SCI_Prepare(j))
4825 return 0;
4826
4827 bytes.high = 0x38;
4828 bytes.low = 0x00;
4829 outb_p(bytes.high, j->XILINXbase + 0x03);
4830 outb_p(bytes.low, j->XILINXbase + 0x02);
4831
4832 if (!SCI_Control(j, SCI_Enable_DAA))
4833 return 0;
4834
4835 bytes.high = inb_p(j->XILINXbase + 0x03);
4836 bytes.low = inb_p(j->XILINXbase + 0x02);
4837 if (bytes.low != ALISDAA_ID_BYTE) {
4838 if (ixjdebug & 0x0001)
4839 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4840 return 0;
4841 }
4842 if (!SCI_Control(j, SCI_Enable_DAA))
4843 return 0;
4844 if (!SCI_Control(j, SCI_End))
4845 return 0;
4846
4847 bytes.high = inb_p(j->XILINXbase + 0x03);
4848 bytes.low = inb_p(j->XILINXbase + 0x02);
4849
4850 j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4851
4852 return 1;
4853}
4854
4855static char daa_CR_read(IXJ *j, int cr)
4856{
4857 IXJ_WORD wdata;
4858 BYTES bytes;
4859
4860 if (!SCI_Prepare(j))
4861 return 0;
4862
4863 switch (j->daa_mode) {
4864 case SOP_PU_SLEEP:
4865 bytes.high = 0x30 + cr;
4866 break;
4867 case SOP_PU_RINGING:
4868 bytes.high = 0x70 + cr;
4869 break;
4870 case SOP_PU_CONVERSATION:
4871 bytes.high = 0xB0 + cr;
4872 break;
4873 case SOP_PU_PULSEDIALING:
Jeff Garzik0d480db2007-07-17 01:35:08 -0400[diff] [blame]4874 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4875 bytes.high = 0xF0 + cr;
4876 break;
4877 }
4878
4879 bytes.low = 0x00;
4880
4881 outb_p(bytes.high, j->XILINXbase + 0x03);
4882 outb_p(bytes.low, j->XILINXbase + 0x02);
4883
4884 if (!SCI_Control(j, SCI_Enable_DAA))
4885 return 0;
4886
4887 bytes.high = inb_p(j->XILINXbase + 0x03);
4888 bytes.low = inb_p(j->XILINXbase + 0x02);
4889 if (bytes.low != ALISDAA_ID_BYTE) {
4890 if (ixjdebug & 0x0001)
4891 printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4892 return 0;
4893 }
4894 if (!SCI_Control(j, SCI_Enable_DAA))
4895 return 0;
4896 if (!SCI_Control(j, SCI_End))
4897 return 0;
4898
4899 wdata.word = inw_p(j->XILINXbase + 0x02);
4900
4901 switch(cr){
4902 case 5:
4903 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4904 break;
4905 case 4:
4906 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4907 break;
4908 case 3:
4909 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4910 break;
4911 case 2:
4912 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4913 break;
4914 case 1:
4915 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4916 break;
4917 case 0:
4918 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4919 break;
4920 default:
4921 return 0;
4922 }
4923 return 1;
4924}
4925
4926static int ixj_daa_cid_reset(IXJ *j)
4927{
4928 int i;
4929 BYTES bytes;
4930
4931 if (ixjdebug & 0x0002)
4932 printk("DAA Clearing CID ram\n");
4933
4934 if (!SCI_Prepare(j))
4935 return 0;
4936
4937 bytes.high = 0x58;
4938 bytes.low = 0x00;
4939 outb_p(bytes.high, j->XILINXbase + 0x03);
4940 outb_p(bytes.low, j->XILINXbase + 0x02);
4941
4942 if (!SCI_Control(j, SCI_Enable_DAA))
4943 return 0;
4944
4945 if (!SCI_WaitHighSCI(j))
4946 return 0;
4947
4948 for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4949 bytes.high = bytes.low = 0x00;
4950 outb_p(bytes.high, j->XILINXbase + 0x03);
4951
4952 if (i < ALISDAA_CALLERID_SIZE - 1)
4953 outb_p(bytes.low, j->XILINXbase + 0x02);
4954
4955 if (!SCI_Control(j, SCI_Enable_DAA))
4956 return 0;
4957
4958 if (!SCI_WaitHighSCI(j))
4959 return 0;
4960
4961 }
4962
4963 if (!SCI_Control(j, SCI_End))
4964 return 0;
4965
4966 if (ixjdebug & 0x0002)
4967 printk("DAA CID ram cleared\n");
4968
4969 return 1;
4970}
4971
4972static int ixj_daa_cid_read(IXJ *j)
4973{
4974 int i;
4975 BYTES bytes;
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]4976 char CID[ALISDAA_CALLERID_SIZE];
4977 bool mContinue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]4978 char *pIn, *pOut;
4979
4980 if (!SCI_Prepare(j))
4981 return 0;
4982
4983 bytes.high = 0x78;
4984 bytes.low = 0x00;
4985 outb_p(bytes.high, j->XILINXbase + 0x03);
4986 outb_p(bytes.low, j->XILINXbase + 0x02);
4987
4988 if (!SCI_Control(j, SCI_Enable_DAA))
4989 return 0;
4990
4991 if (!SCI_WaitHighSCI(j))
4992 return 0;
4993
4994 bytes.high = inb_p(j->XILINXbase + 0x03);
4995 bytes.low = inb_p(j->XILINXbase + 0x02);
4996 if (bytes.low != ALISDAA_ID_BYTE) {
4997 if (ixjdebug & 0x0001)
4998 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4999 return 0;
5000 }
5001 for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5002 bytes.high = bytes.low = 0x00;
5003 outb_p(bytes.high, j->XILINXbase + 0x03);
5004 outb_p(bytes.low, j->XILINXbase + 0x02);
5005
5006 if (!SCI_Control(j, SCI_Enable_DAA))
5007 return 0;
5008
5009 if (!SCI_WaitHighSCI(j))
5010 return 0;
5011
5012 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5013 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5014 }
5015
5016 if (!SCI_Control(j, SCI_End))
5017 return 0;
5018
5019 pIn = CID;
5020 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]5021 mContinue = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5022 while (mContinue) {
5023 if ((pIn[1] & 0x03) == 0x01) {
5024 pOut[0] = pIn[0];
5025 }
5026 if ((pIn[2] & 0x0c) == 0x04) {
5027 pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5028 }
5029 if ((pIn[3] & 0x30) == 0x10) {
5030 pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5031 }
5032 if ((pIn[4] & 0xc0) == 0x40) {
5033 pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5034 } else {
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]5035 mContinue = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5036 }
5037 pIn += 5, pOut += 4;
5038 }
5039 memset(&j->cid, 0, sizeof(PHONE_CID));
5040 pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5041 pOut += 4;
5042 strncpy(j->cid.month, pOut, 2);
5043 pOut += 2;
5044 strncpy(j->cid.day, pOut, 2);
5045 pOut += 2;
5046 strncpy(j->cid.hour, pOut, 2);
5047 pOut += 2;
5048 strncpy(j->cid.min, pOut, 2);
5049 pOut += 3;
5050 j->cid.numlen = *pOut;
5051 pOut += 1;
5052 strncpy(j->cid.number, pOut, j->cid.numlen);
5053 pOut += j->cid.numlen + 1;
5054 j->cid.namelen = *pOut;
5055 pOut += 1;
5056 strncpy(j->cid.name, pOut, j->cid.namelen);
5057
5058 ixj_daa_cid_reset(j);
5059 return 1;
5060}
5061
5062static char daa_get_version(IXJ *j)
5063{
5064 BYTES bytes;
5065
5066 if (!SCI_Prepare(j))
5067 return 0;
5068
5069 bytes.high = 0x35;
5070 bytes.low = 0x00;
5071 outb_p(bytes.high, j->XILINXbase + 0x03);
5072 outb_p(bytes.low, j->XILINXbase + 0x02);
5073
5074 if (!SCI_Control(j, SCI_Enable_DAA))
5075 return 0;
5076
5077 bytes.high = inb_p(j->XILINXbase + 0x03);
5078 bytes.low = inb_p(j->XILINXbase + 0x02);
5079 if (bytes.low != ALISDAA_ID_BYTE) {
5080 if (ixjdebug & 0x0001)
5081 printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5082 return 0;
5083 }
5084 if (!SCI_Control(j, SCI_Enable_DAA))
5085 return 0;
5086
5087 if (!SCI_Control(j, SCI_End))
5088 return 0;
5089
5090 bytes.high = inb_p(j->XILINXbase + 0x03);
5091 bytes.low = inb_p(j->XILINXbase + 0x02);
5092 if (ixjdebug & 0x0002)
5093 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5094 j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5095 return bytes.high;
5096}
5097
5098static int daa_set_mode(IXJ *j, int mode)
5099{
5100 /* NOTE:
5101 The DAA *MUST* be in the conversation mode if the
5102 PSTN line is to be seized (PSTN line off-hook).
5103 Taking the PSTN line off-hook while the DAA is in
5104 a mode other than conversation mode will cause a
5105 hardware failure of the ALIS-A part.
5106
5107 NOTE:
5108 The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5109 if the PSTN line is on-hook. Failure to have the PSTN line
5110 in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5111 ALIS-A part.
5112 */
5113
5114 BYTES bytes;
5115
5116 j->flags.pstn_rmr = 0;
5117
5118 if (!SCI_Prepare(j))
5119 return 0;
5120
5121 switch (mode) {
5122 case SOP_PU_RESET:
5123 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5124
5125 outb_p(j->pld_scrw.byte, j->XILINXbase);
5126 j->pld_slicw.bits.rly2 = 0;
5127 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5128 bytes.high = 0x10;
5129 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5130 daa_load(&bytes, j);
5131 if (!SCI_Prepare(j))
5132 return 0;
5133
5134 j->daa_mode = SOP_PU_SLEEP;
5135 break;
5136 case SOP_PU_SLEEP:
5137 if(j->daa_mode == SOP_PU_SLEEP)
5138 {
5139 break;
5140 }
5141 if (ixjdebug & 0x0008)
5142 printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5143/* if(j->daa_mode == SOP_PU_CONVERSATION) */
5144 {
5145 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5146
5147 outb_p(j->pld_scrw.byte, j->XILINXbase);
5148 j->pld_slicw.bits.rly2 = 0;
5149 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5150 bytes.high = 0x10;
5151 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5152 daa_load(&bytes, j);
5153 if (!SCI_Prepare(j))
5154 return 0;
5155 }
5156 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5157
5158 outb_p(j->pld_scrw.byte, j->XILINXbase);
5159 j->pld_slicw.bits.rly2 = 0;
5160 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5161 bytes.high = 0x10;
5162 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5163 daa_load(&bytes, j);
5164 if (!SCI_Prepare(j))
5165 return 0;
5166
5167 j->daa_mode = SOP_PU_SLEEP;
5168 j->flags.pstn_ringing = 0;
5169 j->ex.bits.pstn_ring = 0;
5170 j->pstn_sleeptil = jiffies + (hertz / 4);
5171 wake_up_interruptible(&j->read_q); /* Wake any blocked readers */
5172 wake_up_interruptible(&j->write_q); /* Wake any blocked writers */
5173 wake_up_interruptible(&j->poll_q); /* Wake any blocked selects */
5174 break;
5175 case SOP_PU_RINGING:
5176 if (ixjdebug & 0x0008)
5177 printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5178 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5179
5180 outb_p(j->pld_scrw.byte, j->XILINXbase);
5181 j->pld_slicw.bits.rly2 = 0;
5182 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5183 bytes.high = 0x50;
5184 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5185 daa_load(&bytes, j);
5186 if (!SCI_Prepare(j))
5187 return 0;
5188 j->daa_mode = SOP_PU_RINGING;
5189 break;
5190 case SOP_PU_CONVERSATION:
5191 if (ixjdebug & 0x0008)
5192 printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5193 bytes.high = 0x90;
5194 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5195 daa_load(&bytes, j);
5196 if (!SCI_Prepare(j))
5197 return 0;
5198 j->pld_slicw.bits.rly2 = 1;
5199 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5200 j->pld_scrw.bits.daafsyncen = 1; /* Turn on DAA Frame Sync */
5201
5202 outb_p(j->pld_scrw.byte, j->XILINXbase);
5203 j->daa_mode = SOP_PU_CONVERSATION;
5204 j->flags.pstn_ringing = 0;
5205 j->ex.bits.pstn_ring = 0;
5206 j->pstn_sleeptil = jiffies;
5207 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5208 break;
5209 case SOP_PU_PULSEDIALING:
5210 if (ixjdebug & 0x0008)
5211 printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5212 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
5213
5214 outb_p(j->pld_scrw.byte, j->XILINXbase);
5215 j->pld_slicw.bits.rly2 = 0;
5216 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5217 bytes.high = 0xD0;
5218 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5219 daa_load(&bytes, j);
5220 if (!SCI_Prepare(j))
5221 return 0;
5222 j->daa_mode = SOP_PU_PULSEDIALING;
5223 break;
5224 default:
5225 break;
5226 }
5227 return 1;
5228}
5229
5230static int ixj_daa_write(IXJ *j)
5231{
5232 BYTES bytes;
5233
5234 j->flags.pstncheck = 1;
5235
5236 daa_set_mode(j, SOP_PU_SLEEP);
5237
5238 if (!SCI_Prepare(j))
5239 return 0;
5240
5241 outb_p(j->pld_scrw.byte, j->XILINXbase);
5242
5243 bytes.high = 0x14;
5244 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5245 if (!daa_load(&bytes, j))
5246 return 0;
5247
5248 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5249 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5250 if (!daa_load(&bytes, j))
5251 return 0;
5252
5253 bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5254 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5255 if (!daa_load(&bytes, j))
5256 return 0;
5257
5258 if (!SCI_Prepare(j))
5259 return 0;
5260
5261 bytes.high = 0x1F;
5262 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5263 if (!daa_load(&bytes, j))
5264 return 0;
5265
5266 bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5267 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5268 if (!daa_load(&bytes, j))
5269 return 0;
5270
5271 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5272 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5273 if (!daa_load(&bytes, j))
5274 return 0;
5275
5276 bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5277 bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5278 if (!daa_load(&bytes, j))
5279 return 0;
5280
5281 bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5282 bytes.low = 0x00;
5283 if (!daa_load(&bytes, j))
5284 return 0;
5285
5286 if (!SCI_Prepare(j))
5287 return 0;
5288
5289 bytes.high = 0x00;
5290 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5291 if (!daa_load(&bytes, j))
5292 return 0;
5293
5294 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5295 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5296 if (!daa_load(&bytes, j))
5297 return 0;
5298
5299 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5300 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5301 if (!daa_load(&bytes, j))
5302 return 0;
5303
5304 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5305 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5306 if (!daa_load(&bytes, j))
5307 return 0;
5308
5309 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5310 bytes.low = 0x00;
5311 if (!daa_load(&bytes, j))
5312 return 0;
5313
5314 if (!SCI_Control(j, SCI_End))
5315 return 0;
5316 if (!SCI_WaitLowSCI(j))
5317 return 0;
5318
5319 bytes.high = 0x01;
5320 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5321 if (!daa_load(&bytes, j))
5322 return 0;
5323
5324 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5325 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5326 if (!daa_load(&bytes, j))
5327 return 0;
5328
5329 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5330 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5331 if (!daa_load(&bytes, j))
5332 return 0;
5333
5334 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5335 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5336 if (!daa_load(&bytes, j))
5337 return 0;
5338
5339 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5340 bytes.low = 0x00;
5341 if (!daa_load(&bytes, j))
5342 return 0;
5343
5344 if (!SCI_Control(j, SCI_End))
5345 return 0;
5346 if (!SCI_WaitLowSCI(j))
5347 return 0;
5348
5349 bytes.high = 0x02;
5350 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5351 if (!daa_load(&bytes, j))
5352 return 0;
5353
5354 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5355 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5356 if (!daa_load(&bytes, j))
5357 return 0;
5358
5359 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5360 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5361 if (!daa_load(&bytes, j))
5362 return 0;
5363
5364 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5365 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5366 if (!daa_load(&bytes, j))
5367 return 0;
5368
5369 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5370 bytes.low = 0x00;
5371 if (!daa_load(&bytes, j))
5372 return 0;
5373
5374 if (!SCI_Control(j, SCI_End))
5375 return 0;
5376 if (!SCI_WaitLowSCI(j))
5377 return 0;
5378
5379 bytes.high = 0x03;
5380 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5381 if (!daa_load(&bytes, j))
5382 return 0;
5383
5384 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5385 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5386 if (!daa_load(&bytes, j))
5387 return 0;
5388
5389 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5390 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5391 if (!daa_load(&bytes, j))
5392 return 0;
5393
5394 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5395 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5396 if (!daa_load(&bytes, j))
5397 return 0;
5398
5399 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5400 bytes.low = 0x00;
5401 if (!daa_load(&bytes, j))
5402 return 0;
5403
5404 if (!SCI_Control(j, SCI_End))
5405 return 0;
5406 if (!SCI_WaitLowSCI(j))
5407 return 0;
5408
5409 bytes.high = 0x04;
5410 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5411 if (!daa_load(&bytes, j))
5412 return 0;
5413
5414 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5415 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5416 if (!daa_load(&bytes, j))
5417 return 0;
5418
5419 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5420 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5421 if (!daa_load(&bytes, j))
5422 return 0;
5423
5424 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5425 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5426 if (!daa_load(&bytes, j))
5427 return 0;
5428
5429 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5430 bytes.low = 0x00;
5431 if (!daa_load(&bytes, j))
5432 return 0;
5433
5434 if (!SCI_Control(j, SCI_End))
5435 return 0;
5436 if (!SCI_WaitLowSCI(j))
5437 return 0;
5438
5439 bytes.high = 0x05;
5440 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5441 if (!daa_load(&bytes, j))
5442 return 0;
5443
5444 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5445 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5446 if (!daa_load(&bytes, j))
5447 return 0;
5448
5449 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5450 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5451 if (!daa_load(&bytes, j))
5452 return 0;
5453
5454 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5455 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5456 if (!daa_load(&bytes, j))
5457 return 0;
5458
5459 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5460 bytes.low = 0x00;
5461 if (!daa_load(&bytes, j))
5462 return 0;
5463
5464 if (!SCI_Control(j, SCI_End))
5465 return 0;
5466 if (!SCI_WaitLowSCI(j))
5467 return 0;
5468
5469 bytes.high = 0x06;
5470 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5471 if (!daa_load(&bytes, j))
5472 return 0;
5473
5474 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5475 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5476 if (!daa_load(&bytes, j))
5477 return 0;
5478
5479 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5480 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5481 if (!daa_load(&bytes, j))
5482 return 0;
5483
5484 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5485 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5486 if (!daa_load(&bytes, j))
5487 return 0;
5488
5489 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5490 bytes.low = 0x00;
5491 if (!daa_load(&bytes, j))
5492 return 0;
5493
5494 if (!SCI_Control(j, SCI_End))
5495 return 0;
5496 if (!SCI_WaitLowSCI(j))
5497 return 0;
5498
5499 bytes.high = 0x07;
5500 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5501 if (!daa_load(&bytes, j))
5502 return 0;
5503
5504 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5505 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5506 if (!daa_load(&bytes, j))
5507 return 0;
5508
5509 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5510 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5511 if (!daa_load(&bytes, j))
5512 return 0;
5513
5514 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5515 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5516 if (!daa_load(&bytes, j))
5517 return 0;
5518
5519 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5520 bytes.low = 0x00;
5521 if (!daa_load(&bytes, j))
5522 return 0;
5523
5524 if (!SCI_Control(j, SCI_End))
5525 return 0;
5526 if (!SCI_WaitLowSCI(j))
5527 return 0;
5528
5529 bytes.high = 0x08;
5530 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5531 if (!daa_load(&bytes, j))
5532 return 0;
5533
5534 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5535 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5536 if (!daa_load(&bytes, j))
5537 return 0;
5538
5539 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5540 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5541 if (!daa_load(&bytes, j))
5542 return 0;
5543
5544 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5545 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5546 if (!daa_load(&bytes, j))
5547 return 0;
5548
5549 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5550 bytes.low = 0x00;
5551 if (!daa_load(&bytes, j))
5552 return 0;
5553
5554 if (!SCI_Control(j, SCI_End))
5555 return 0;
5556 if (!SCI_WaitLowSCI(j))
5557 return 0;
5558
5559 bytes.high = 0x09;
5560 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5561 if (!daa_load(&bytes, j))
5562 return 0;
5563
5564 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5565 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5566 if (!daa_load(&bytes, j))
5567 return 0;
5568
5569 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5570 bytes.low = 0x00;
5571 if (!daa_load(&bytes, j))
5572 return 0;
5573
5574 if (!SCI_Control(j, SCI_End))
5575 return 0;
5576 if (!SCI_WaitLowSCI(j))
5577 return 0;
5578
5579 bytes.high = 0x0A;
5580 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5581 if (!daa_load(&bytes, j))
5582 return 0;
5583
5584 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5585 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5586 if (!daa_load(&bytes, j))
5587 return 0;
5588
5589 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5590 bytes.low = 0x00;
5591 if (!daa_load(&bytes, j))
5592 return 0;
5593
5594 if (!SCI_Control(j, SCI_End))
5595 return 0;
5596 if (!SCI_WaitLowSCI(j))
5597 return 0;
5598
5599 bytes.high = 0x0B;
5600 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5601 if (!daa_load(&bytes, j))
5602 return 0;
5603
5604 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5605 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5606 if (!daa_load(&bytes, j))
5607 return 0;
5608
5609 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5610 bytes.low = 0x00;
5611 if (!daa_load(&bytes, j))
5612 return 0;
5613
5614 if (!SCI_Control(j, SCI_End))
5615 return 0;
5616 if (!SCI_WaitLowSCI(j))
5617 return 0;
5618
5619 bytes.high = 0x0C;
5620 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5621 if (!daa_load(&bytes, j))
5622 return 0;
5623
5624 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5625 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5626 if (!daa_load(&bytes, j))
5627 return 0;
5628
5629 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5630 bytes.low = 0x00;
5631 if (!daa_load(&bytes, j))
5632 return 0;
5633
5634 if (!SCI_Control(j, SCI_End))
5635 return 0;
5636 if (!SCI_WaitLowSCI(j))
5637 return 0;
5638
5639 bytes.high = 0x0D;
5640 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5641 if (!daa_load(&bytes, j))
5642 return 0;
5643
5644 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5645 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5646 if (!daa_load(&bytes, j))
5647 return 0;
5648
5649 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5650 bytes.low = 0x00;
5651 if (!daa_load(&bytes, j))
5652 return 0;
5653
5654 if (!SCI_Control(j, SCI_End))
5655 return 0;
5656 if (!SCI_WaitLowSCI(j))
5657 return 0;
5658
5659 bytes.high = 0x0E;
5660 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5661 if (!daa_load(&bytes, j))
5662 return 0;
5663
5664 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5665 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5666 if (!daa_load(&bytes, j))
5667 return 0;
5668
5669 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5670 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5671 if (!daa_load(&bytes, j))
5672 return 0;
5673
5674 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5675 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5676 if (!daa_load(&bytes, j))
5677 return 0;
5678
5679 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5680 bytes.low = 0x00;
5681 if (!daa_load(&bytes, j))
5682 return 0;
5683
5684 if (!SCI_Control(j, SCI_End))
5685 return 0;
5686 if (!SCI_WaitLowSCI(j))
5687 return 0;
5688
5689 bytes.high = 0x0F;
5690 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5691 if (!daa_load(&bytes, j))
5692 return 0;
5693
5694 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5695 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5696 if (!daa_load(&bytes, j))
5697 return 0;
5698
5699 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5700 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5701 if (!daa_load(&bytes, j))
5702 return 0;
5703
5704 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5705 bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5706 if (!daa_load(&bytes, j))
5707 return 0;
5708
5709 bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5710 bytes.low = 0x00;
5711 if (!daa_load(&bytes, j))
5712 return 0;
5713
5714 udelay(32);
5715 j->pld_scrr.byte = inb_p(j->XILINXbase);
5716 if (!SCI_Control(j, SCI_End))
5717 return 0;
5718
5719 outb_p(j->pld_scrw.byte, j->XILINXbase);
5720
5721 if (ixjdebug & 0x0002)
5722 printk("DAA Coefficients Loaded\n");
5723
5724 j->flags.pstncheck = 0;
5725 return 1;
5726}
5727
Matthew Martinbc940c42006-06-26 18:43:54 +0200[diff] [blame]5728static int ixj_set_tone_off(unsigned short arg, IXJ *j)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5729{
5730 j->tone_off_time = arg;
5731 if (ixj_WriteDSPCommand(0x6E05, j)) /* Set Tone Off Period */
5732
5733 return -1;
5734 if (ixj_WriteDSPCommand(arg, j))
5735 return -1;
5736 return 0;
5737}
5738
5739static int ixj_get_tone_on(IXJ *j)
5740{
5741 if (ixj_WriteDSPCommand(0x6E06, j)) /* Get Tone On Period */
5742
5743 return -1;
5744 return 0;
5745}
5746
5747static int ixj_get_tone_off(IXJ *j)
5748{
5749 if (ixj_WriteDSPCommand(0x6E07, j)) /* Get Tone Off Period */
5750
5751 return -1;
5752 return 0;
5753}
5754
5755static void ixj_busytone(IXJ *j)
5756{
5757 j->flags.ringback = 0;
5758 j->flags.dialtone = 0;
5759 j->flags.busytone = 1;
5760 ixj_set_tone_on(0x07D0, j);
5761 ixj_set_tone_off(0x07D0, j);
5762 ixj_play_tone(j, 27);
5763}
5764
5765static void ixj_dialtone(IXJ *j)
5766{
5767 j->flags.ringback = 0;
5768 j->flags.dialtone = 1;
5769 j->flags.busytone = 0;
5770 if (j->dsp.low == 0x20) {
5771 return;
5772 } else {
5773 ixj_set_tone_on(0xFFFF, j);
5774 ixj_set_tone_off(0x0000, j);
5775 ixj_play_tone(j, 25);
5776 }
5777}
5778
5779static void ixj_cpt_stop(IXJ *j)
5780{
5781 if(j->tone_state || j->tone_cadence_state)
5782 {
5783 j->flags.dialtone = 0;
5784 j->flags.busytone = 0;
5785 j->flags.ringback = 0;
5786 ixj_set_tone_on(0x0001, j);
5787 ixj_set_tone_off(0x0000, j);
5788 ixj_play_tone(j, 0);
5789 j->tone_state = j->tone_cadence_state = 0;
5790 if (j->cadence_t) {
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]5791 kfree(j->cadence_t->ce);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5792 kfree(j->cadence_t);
5793 j->cadence_t = NULL;
5794 }
5795 }
5796 if (j->play_mode == -1 && j->rec_mode == -1)
5797 idle(j);
5798 if (j->play_mode != -1 && j->dsp.low == 0x20)
5799 ixj_play_start(j);
5800 if (j->rec_mode != -1 && j->dsp.low == 0x20)
5801 ixj_record_start(j);
5802}
5803
5804static void ixj_ringback(IXJ *j)
5805{
5806 j->flags.busytone = 0;
5807 j->flags.dialtone = 0;
5808 j->flags.ringback = 1;
5809 ixj_set_tone_on(0x0FA0, j);
5810 ixj_set_tone_off(0x2EE0, j);
5811 ixj_play_tone(j, 26);
5812}
5813
5814static void ixj_testram(IXJ *j)
5815{
5816 ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5817}
5818
5819static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5820{
5821 ixj_cadence *lcp;
5822 IXJ_CADENCE_ELEMENT __user *cep;
5823 IXJ_CADENCE_ELEMENT *lcep;
5824 IXJ_TONE ti;
5825 int err;
5826
5827 lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5828 if (lcp == NULL)
5829 return -ENOMEM;
5830
5831 err = -EFAULT;
5832 if (copy_from_user(&lcp->elements_used,
5833 &cp->elements_used, sizeof(int)))
5834 goto out;
5835 if (copy_from_user(&lcp->termination,
5836 &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5837 goto out;
5838 if (get_user(cep, &cp->ce))
5839 goto out;
5840
5841 err = -EINVAL;
5842 if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5843 goto out;
5844
5845 err = -ENOMEM;
5846 lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5847 if (!lcep)
5848 goto out;
5849
5850 err = -EFAULT;
5851 if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5852 goto out1;
5853
5854 if (j->cadence_t) {
5855 kfree(j->cadence_t->ce);
5856 kfree(j->cadence_t);
5857 }
5858 lcp->ce = (void *) lcep;
5859 j->cadence_t = lcp;
5860 j->tone_cadence_state = 0;
5861 ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5862 ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5863 if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5864 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5865 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5866 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5867 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5868 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5869 ixj_init_tone(j, &ti);
5870 }
5871 ixj_play_tone(j, lcp->ce[0].index);
5872 return 1;
5873out1:
5874 kfree(lcep);
5875out:
5876 kfree(lcp);
5877 return err;
5878}
5879
5880static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5881{
5882 IXJ_FILTER_CADENCE *lcp;
Julia Lawallb8d6b0d2010-05-26 14:42:32 -0700[diff] [blame]5883 lcp = memdup_user(cp, sizeof(IXJ_FILTER_CADENCE));
5884 if (IS_ERR(lcp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5885 if(ixjdebug & 0x0001) {
Julia Lawallb8d6b0d2010-05-26 14:42:32 -0700[diff] [blame]5886 printk(KERN_INFO "Could not allocate memory for cadence or could not copy cadence to kernel\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5887 }
Julia Lawallb8d6b0d2010-05-26 14:42:32 -0700[diff] [blame]5888 return PTR_ERR(lcp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5889 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]5890 if (lcp->filter > 5) {
5891 if(ixjdebug & 0x0001) {
5892 printk(KERN_INFO "Cadence out of range\n");
5893 }
5894 kfree(lcp);
5895 return -1;
5896 }
5897 j->cadence_f[lcp->filter].state = 0;
5898 j->cadence_f[lcp->filter].enable = lcp->enable;
5899 j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5900 j->cadence_f[lcp->filter].on1 = lcp->on1;
5901 j->cadence_f[lcp->filter].on1min = 0;
5902 j->cadence_f[lcp->filter].on1max = 0;
5903 j->cadence_f[lcp->filter].off1 = lcp->off1;
5904 j->cadence_f[lcp->filter].off1min = 0;
5905 j->cadence_f[lcp->filter].off1max = 0;
5906 j->cadence_f[lcp->filter].on2 = lcp->on2;
5907 j->cadence_f[lcp->filter].on2min = 0;
5908 j->cadence_f[lcp->filter].on2max = 0;
5909 j->cadence_f[lcp->filter].off2 = lcp->off2;
5910 j->cadence_f[lcp->filter].off2min = 0;
5911 j->cadence_f[lcp->filter].off2max = 0;
5912 j->cadence_f[lcp->filter].on3 = lcp->on3;
5913 j->cadence_f[lcp->filter].on3min = 0;
5914 j->cadence_f[lcp->filter].on3max = 0;
5915 j->cadence_f[lcp->filter].off3 = lcp->off3;
5916 j->cadence_f[lcp->filter].off3min = 0;
5917 j->cadence_f[lcp->filter].off3max = 0;
5918 if(ixjdebug & 0x0002) {
5919 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5920 }
5921 kfree(lcp);
5922 return 0;
5923}
5924
5925static void add_caps(IXJ *j)
5926{
5927 j->caps = 0;
5928 j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5929 strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5930 j->caplist[j->caps].captype = vendor;
5931 j->caplist[j->caps].handle = j->caps++;
5932 j->caplist[j->caps].captype = device;
5933 switch (j->cardtype) {
5934 case QTI_PHONEJACK:
5935 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5936 break;
5937 case QTI_LINEJACK:
5938 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5939 break;
5940 case QTI_PHONEJACK_LITE:
5941 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5942 break;
5943 case QTI_PHONEJACK_PCI:
5944 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5945 break;
5946 case QTI_PHONECARD:
5947 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5948 break;
5949 }
5950 j->caplist[j->caps].cap = j->cardtype;
5951 j->caplist[j->caps].handle = j->caps++;
5952 strcpy(j->caplist[j->caps].desc, "POTS");
5953 j->caplist[j->caps].captype = port;
5954 j->caplist[j->caps].cap = pots;
5955 j->caplist[j->caps].handle = j->caps++;
5956
5957 /* add devices that can do speaker/mic */
5958 switch (j->cardtype) {
5959 case QTI_PHONEJACK:
5960 case QTI_LINEJACK:
5961 case QTI_PHONEJACK_PCI:
5962 case QTI_PHONECARD:
5963 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5964 j->caplist[j->caps].captype = port;
5965 j->caplist[j->caps].cap = speaker;
5966 j->caplist[j->caps].handle = j->caps++;
5967 default:
5968 break;
5969 }
5970
5971 /* add devices that can do handset */
5972 switch (j->cardtype) {
5973 case QTI_PHONEJACK:
5974 strcpy(j->caplist[j->caps].desc, "HANDSET");
5975 j->caplist[j->caps].captype = port;
5976 j->caplist[j->caps].cap = handset;
5977 j->caplist[j->caps].handle = j->caps++;
5978 break;
5979 default:
5980 break;
5981 }
5982
5983 /* add devices that can do PSTN */
5984 switch (j->cardtype) {
5985 case QTI_LINEJACK:
5986 strcpy(j->caplist[j->caps].desc, "PSTN");
5987 j->caplist[j->caps].captype = port;
5988 j->caplist[j->caps].cap = pstn;
5989 j->caplist[j->caps].handle = j->caps++;
5990 break;
5991 default:
5992 break;
5993 }
5994
5995 /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
5996 strcpy(j->caplist[j->caps].desc, "ULAW");
5997 j->caplist[j->caps].captype = codec;
5998 j->caplist[j->caps].cap = ULAW;
5999 j->caplist[j->caps].handle = j->caps++;
6000
6001 strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6002 j->caplist[j->caps].captype = codec;
6003 j->caplist[j->caps].cap = LINEAR16;
6004 j->caplist[j->caps].handle = j->caps++;
6005
6006 strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6007 j->caplist[j->caps].captype = codec;
6008 j->caplist[j->caps].cap = LINEAR8;
6009 j->caplist[j->caps].handle = j->caps++;
6010
6011 strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6012 j->caplist[j->caps].captype = codec;
6013 j->caplist[j->caps].cap = WSS;
6014 j->caplist[j->caps].handle = j->caps++;
6015
6016 /* software ALAW codec, made from ULAW */
6017 strcpy(j->caplist[j->caps].desc, "ALAW");
6018 j->caplist[j->caps].captype = codec;
6019 j->caplist[j->caps].cap = ALAW;
6020 j->caplist[j->caps].handle = j->caps++;
6021
6022 /* version 12 of the 8020 does the following codecs in a broken way */
6023 if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6024 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6025 j->caplist[j->caps].captype = codec;
6026 j->caplist[j->caps].cap = G723_63;
6027 j->caplist[j->caps].handle = j->caps++;
6028
6029 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6030 j->caplist[j->caps].captype = codec;
6031 j->caplist[j->caps].cap = G723_53;
6032 j->caplist[j->caps].handle = j->caps++;
6033
6034 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6035 j->caplist[j->caps].captype = codec;
6036 j->caplist[j->caps].cap = TS48;
6037 j->caplist[j->caps].handle = j->caps++;
6038
6039 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6040 j->caplist[j->caps].captype = codec;
6041 j->caplist[j->caps].cap = TS41;
6042 j->caplist[j->caps].handle = j->caps++;
6043 }
6044
6045 /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6046 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6047 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6048 j->caplist[j->caps].captype = codec;
6049 j->caplist[j->caps].cap = TS85;
6050 j->caplist[j->caps].handle = j->caps++;
6051 }
6052
6053 /* 8021 chips can do G728 */
6054 if (j->dsp.low == 0x21) {
6055 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6056 j->caplist[j->caps].captype = codec;
6057 j->caplist[j->caps].cap = G728;
6058 j->caplist[j->caps].handle = j->caps++;
6059 }
6060
6061 /* 8021/8022 chips can do G729 if loaded */
6062 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6063 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6064 j->caplist[j->caps].captype = codec;
6065 j->caplist[j->caps].cap = G729;
6066 j->caplist[j->caps].handle = j->caps++;
6067 }
6068 if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6069 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6070 j->caplist[j->caps].captype = codec;
6071 j->caplist[j->caps].cap = G729B;
6072 j->caplist[j->caps].handle = j->caps++;
6073 }
6074}
6075
6076static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6077{
6078 int cnt;
6079 int retval = 0;
6080 for (cnt = 0; cnt < j->caps; cnt++) {
6081 if (pcreq->captype == j->caplist[cnt].captype
6082 && pcreq->cap == j->caplist[cnt].cap) {
6083 retval = 1;
6084 break;
6085 }
6086 }
6087 return retval;
6088}
6089
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6090static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6091{
6092 IXJ_TONE ti;
6093 IXJ_FILTER jf;
6094 IXJ_FILTER_RAW jfr;
6095 void __user *argp = (void __user *)arg;
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6096 struct inode *inode = file_p->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6097 unsigned int minor = iminor(inode);
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6098 unsigned int raise, mant;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6099 int board = NUM(inode);
6100
6101 IXJ *j = get_ixj(NUM(inode));
6102
6103 int retval = 0;
6104
6105 /*
6106 * Set up locks to ensure that only one process is talking to the DSP at a time.
6107 * This is necessary to keep the DSP from locking up.
6108 */
Nishanth Aravamudan1e63bc72005-09-10 00:27:31 -0700[diff] [blame]6109 while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6110 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6111 if (ixjdebug & 0x0040)
6112 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6113 if (minor >= IXJMAX) {
6114 clear_bit(board, &j->busyflags);
6115 return -ENODEV;
6116 }
6117 /*
6118 * Check ioctls only root can use.
6119 */
6120 if (!capable(CAP_SYS_ADMIN)) {
6121 switch (cmd) {
6122 case IXJCTL_TESTRAM:
6123 case IXJCTL_HZ:
6124 retval = -EPERM;
6125 }
6126 }
6127 switch (cmd) {
6128 case IXJCTL_TESTRAM:
6129 ixj_testram(j);
6130 retval = (j->ssr.high << 8) + j->ssr.low;
6131 break;
6132 case IXJCTL_CARDTYPE:
6133 retval = j->cardtype;
6134 break;
6135 case IXJCTL_SERIAL:
6136 retval = j->serial;
6137 break;
6138 case IXJCTL_VERSION:
Domen Puncerfba478b2005-05-05 16:16:13 -0700[diff] [blame]6139 {
6140 char arg_str[100];
6141 snprintf(arg_str, sizeof(arg_str),
6142 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6143 IXJ_VER_MINOR, IXJ_BLD_VER);
6144 if (copy_to_user(argp, arg_str, strlen(arg_str)))
6145 retval = -EFAULT;
6146 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6147 break;
6148 case PHONE_RING_CADENCE:
6149 j->ring_cadence = arg;
6150 break;
6151 case IXJCTL_CIDCW:
6152 if(arg) {
6153 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6154 retval = -EFAULT;
6155 break;
6156 }
6157 } else {
6158 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6159 }
6160 ixj_write_cidcw(j);
6161 break;
6162 /* Binary compatbility */
6163 case OLD_PHONE_RING_START:
6164 arg = 0;
6165 /* Fall through */
6166 case PHONE_RING_START:
6167 if(arg) {
6168 if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6169 retval = -EFAULT;
6170 break;
6171 }
6172 ixj_write_cid(j);
6173 } else {
6174 memset(&j->cid_send, 0, sizeof(PHONE_CID));
6175 }
6176 ixj_ring_start(j);
6177 break;
6178 case PHONE_RING_STOP:
6179 j->flags.cringing = 0;
6180 if(j->cadence_f[5].enable) {
6181 j->cadence_f[5].state = 0;
6182 }
6183 ixj_ring_off(j);
6184 break;
6185 case PHONE_RING:
6186 retval = ixj_ring(j);
6187 break;
6188 case PHONE_EXCEPTION:
6189 retval = j->ex.bytes;
6190 if(j->ex.bits.flash) {
6191 j->flash_end = 0;
6192 j->ex.bits.flash = 0;
6193 }
6194 j->ex.bits.pstn_ring = 0;
6195 j->ex.bits.caller_id = 0;
6196 j->ex.bits.pstn_wink = 0;
6197 j->ex.bits.f0 = 0;
6198 j->ex.bits.f1 = 0;
6199 j->ex.bits.f2 = 0;
6200 j->ex.bits.f3 = 0;
6201 j->ex.bits.fc0 = 0;
6202 j->ex.bits.fc1 = 0;
6203 j->ex.bits.fc2 = 0;
6204 j->ex.bits.fc3 = 0;
6205 j->ex.bits.reserved = 0;
6206 break;
6207 case PHONE_HOOKSTATE:
6208 j->ex.bits.hookstate = 0;
6209 retval = j->hookstate; //j->r_hook;
6210 break;
6211 case IXJCTL_SET_LED:
6212 LED_SetState(arg, j);
6213 break;
6214 case PHONE_FRAME:
6215 retval = set_base_frame(j, arg);
6216 break;
6217 case PHONE_REC_CODEC:
6218 retval = set_rec_codec(j, arg);
6219 break;
6220 case PHONE_VAD:
6221 ixj_vad(j, arg);
6222 break;
6223 case PHONE_REC_START:
6224 ixj_record_start(j);
6225 break;
6226 case PHONE_REC_STOP:
6227 ixj_record_stop(j);
6228 break;
6229 case PHONE_REC_DEPTH:
6230 set_rec_depth(j, arg);
6231 break;
6232 case PHONE_REC_VOLUME:
6233 if(arg == -1) {
6234 retval = get_rec_volume(j);
6235 }
6236 else {
6237 set_rec_volume(j, arg);
6238 retval = arg;
6239 }
6240 break;
6241 case PHONE_REC_VOLUME_LINEAR:
6242 if(arg == -1) {
6243 retval = get_rec_volume_linear(j);
6244 }
6245 else {
6246 set_rec_volume_linear(j, arg);
6247 retval = arg;
6248 }
6249 break;
6250 case IXJCTL_DTMF_PRESCALE:
6251 if(arg == -1) {
6252 retval = get_dtmf_prescale(j);
6253 }
6254 else {
6255 set_dtmf_prescale(j, arg);
6256 retval = arg;
6257 }
6258 break;
6259 case PHONE_REC_LEVEL:
6260 retval = get_rec_level(j);
6261 break;
6262 case IXJCTL_SC_RXG:
6263 retval = ixj_siadc(j, arg);
6264 break;
6265 case IXJCTL_SC_TXG:
6266 retval = ixj_sidac(j, arg);
6267 break;
6268 case IXJCTL_AEC_START:
6269 ixj_aec_start(j, arg);
6270 break;
6271 case IXJCTL_AEC_STOP:
6272 aec_stop(j);
6273 break;
6274 case IXJCTL_AEC_GET_LEVEL:
6275 retval = j->aec_level;
6276 break;
6277 case PHONE_PLAY_CODEC:
6278 retval = set_play_codec(j, arg);
6279 break;
6280 case PHONE_PLAY_START:
6281 retval = ixj_play_start(j);
6282 break;
6283 case PHONE_PLAY_STOP:
6284 ixj_play_stop(j);
6285 break;
6286 case PHONE_PLAY_DEPTH:
6287 set_play_depth(j, arg);
6288 break;
6289 case PHONE_PLAY_VOLUME:
6290 if(arg == -1) {
6291 retval = get_play_volume(j);
6292 }
6293 else {
6294 set_play_volume(j, arg);
6295 retval = arg;
6296 }
6297 break;
6298 case PHONE_PLAY_VOLUME_LINEAR:
6299 if(arg == -1) {
6300 retval = get_play_volume_linear(j);
6301 }
6302 else {
6303 set_play_volume_linear(j, arg);
6304 retval = arg;
6305 }
6306 break;
6307 case PHONE_PLAY_LEVEL:
6308 retval = get_play_level(j);
6309 break;
6310 case IXJCTL_DSP_TYPE:
6311 retval = (j->dsp.high << 8) + j->dsp.low;
6312 break;
6313 case IXJCTL_DSP_VERSION:
6314 retval = (j->ver.high << 8) + j->ver.low;
6315 break;
6316 case IXJCTL_HZ:
6317 hertz = arg;
6318 break;
6319 case IXJCTL_RATE:
6320 if (arg > hertz)
6321 retval = -1;
6322 else
6323 samplerate = arg;
6324 break;
6325 case IXJCTL_DRYBUFFER_READ:
6326 put_user(j->drybuffer, (unsigned long __user *) argp);
6327 break;
6328 case IXJCTL_DRYBUFFER_CLEAR:
6329 j->drybuffer = 0;
6330 break;
6331 case IXJCTL_FRAMES_READ:
6332 put_user(j->framesread, (unsigned long __user *) argp);
6333 break;
6334 case IXJCTL_FRAMES_WRITTEN:
6335 put_user(j->frameswritten, (unsigned long __user *) argp);
6336 break;
6337 case IXJCTL_READ_WAIT:
6338 put_user(j->read_wait, (unsigned long __user *) argp);
6339 break;
6340 case IXJCTL_WRITE_WAIT:
6341 put_user(j->write_wait, (unsigned long __user *) argp);
6342 break;
6343 case PHONE_MAXRINGS:
6344 j->maxrings = arg;
6345 break;
6346 case PHONE_SET_TONE_ON_TIME:
6347 ixj_set_tone_on(arg, j);
6348 break;
6349 case PHONE_SET_TONE_OFF_TIME:
6350 ixj_set_tone_off(arg, j);
6351 break;
6352 case PHONE_GET_TONE_ON_TIME:
6353 if (ixj_get_tone_on(j)) {
6354 retval = -1;
6355 } else {
6356 retval = (j->ssr.high << 8) + j->ssr.low;
6357 }
6358 break;
6359 case PHONE_GET_TONE_OFF_TIME:
6360 if (ixj_get_tone_off(j)) {
6361 retval = -1;
6362 } else {
6363 retval = (j->ssr.high << 8) + j->ssr.low;
6364 }
6365 break;
6366 case PHONE_PLAY_TONE:
6367 if (!j->tone_state)
6368 retval = ixj_play_tone(j, arg);
6369 else
6370 retval = -1;
6371 break;
6372 case PHONE_GET_TONE_STATE:
6373 retval = j->tone_state;
6374 break;
6375 case PHONE_DTMF_READY:
6376 retval = j->ex.bits.dtmf_ready;
6377 break;
6378 case PHONE_GET_DTMF:
6379 if (ixj_hookstate(j)) {
6380 if (j->dtmf_rp != j->dtmf_wp) {
6381 retval = j->dtmfbuffer[j->dtmf_rp];
6382 j->dtmf_rp++;
6383 if (j->dtmf_rp == 79)
6384 j->dtmf_rp = 0;
6385 if (j->dtmf_rp == j->dtmf_wp) {
6386 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6387 }
6388 }
6389 }
6390 break;
6391 case PHONE_GET_DTMF_ASCII:
6392 if (ixj_hookstate(j)) {
6393 if (j->dtmf_rp != j->dtmf_wp) {
6394 switch (j->dtmfbuffer[j->dtmf_rp]) {
6395 case 10:
6396 retval = 42; /* '*'; */
6397
6398 break;
6399 case 11:
6400 retval = 48; /*'0'; */
6401
6402 break;
6403 case 12:
6404 retval = 35; /*'#'; */
6405
6406 break;
6407 case 28:
6408 retval = 65; /*'A'; */
6409
6410 break;
6411 case 29:
6412 retval = 66; /*'B'; */
6413
6414 break;
6415 case 30:
6416 retval = 67; /*'C'; */
6417
6418 break;
6419 case 31:
6420 retval = 68; /*'D'; */
6421
6422 break;
6423 default:
6424 retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6425 break;
6426 }
6427 j->dtmf_rp++;
6428 if (j->dtmf_rp == 79)
6429 j->dtmf_rp = 0;
6430 if(j->dtmf_rp == j->dtmf_wp)
6431 {
6432 j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6433 }
6434 }
6435 }
6436 break;
6437 case PHONE_DTMF_OOB:
6438 j->flags.dtmf_oob = arg;
6439 break;
6440 case PHONE_DIALTONE:
6441 ixj_dialtone(j);
6442 break;
6443 case PHONE_BUSY:
6444 ixj_busytone(j);
6445 break;
6446 case PHONE_RINGBACK:
6447 ixj_ringback(j);
6448 break;
6449 case PHONE_WINK:
6450 if(j->cardtype == QTI_PHONEJACK)
6451 retval = -1;
6452 else
6453 retval = ixj_wink(j);
6454 break;
6455 case PHONE_CPT_STOP:
6456 ixj_cpt_stop(j);
6457 break;
6458 case PHONE_QUERY_CODEC:
6459 {
6460 struct phone_codec_data pd;
6461 int val;
6462 int proto_size[] = {
6463 -1,
6464 12, 10, 16, 9, 8, 48, 5,
6465 40, 40, 80, 40, 40, 6
6466 };
6467 if(copy_from_user(&pd, argp, sizeof(pd))) {
6468 retval = -EFAULT;
6469 break;
6470 }
6471 if(pd.type<1 || pd.type>13) {
6472 retval = -EPROTONOSUPPORT;
6473 break;
6474 }
6475 if(pd.type<G729)
6476 val=proto_size[pd.type];
6477 else switch(j->baseframe.low)
6478 {
6479 case 0xA0:val=2*proto_size[pd.type];break;
6480 case 0x50:val=proto_size[pd.type];break;
6481 default:val=proto_size[pd.type]*3;break;
6482 }
6483 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6484 if(copy_to_user(argp, &pd, sizeof(pd)))
6485 retval = -EFAULT;
6486 break;
6487 }
6488 case IXJCTL_DSP_IDLE:
6489 idle(j);
6490 break;
6491 case IXJCTL_MIXER:
6492 if ((arg & 0xff) == 0xff)
6493 retval = ixj_get_mixer(arg, j);
6494 else
6495 ixj_mixer(arg, j);
6496 break;
6497 case IXJCTL_DAA_COEFF_SET:
6498 switch (arg) {
6499 case DAA_US:
6500 DAA_Coeff_US(j);
6501 retval = ixj_daa_write(j);
6502 break;
6503 case DAA_UK:
6504 DAA_Coeff_UK(j);
6505 retval = ixj_daa_write(j);
6506 break;
6507 case DAA_FRANCE:
6508 DAA_Coeff_France(j);
6509 retval = ixj_daa_write(j);
6510 break;
6511 case DAA_GERMANY:
6512 DAA_Coeff_Germany(j);
6513 retval = ixj_daa_write(j);
6514 break;
6515 case DAA_AUSTRALIA:
6516 DAA_Coeff_Australia(j);
6517 retval = ixj_daa_write(j);
6518 break;
6519 case DAA_JAPAN:
6520 DAA_Coeff_Japan(j);
6521 retval = ixj_daa_write(j);
6522 break;
6523 default:
6524 retval = 1;
6525 break;
6526 }
6527 break;
6528 case IXJCTL_DAA_AGAIN:
6529 ixj_daa_cr4(j, arg | 0x02);
6530 break;
6531 case IXJCTL_PSTN_LINETEST:
6532 retval = ixj_linetest(j);
6533 break;
6534 case IXJCTL_VMWI:
6535 ixj_write_vmwi(j, arg);
6536 break;
6537 case IXJCTL_CID:
6538 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6539 retval = -EFAULT;
6540 j->ex.bits.caller_id = 0;
6541 break;
6542 case IXJCTL_WINK_DURATION:
6543 j->winktime = arg;
6544 break;
6545 case IXJCTL_PORT:
6546 if (arg)
6547 retval = ixj_set_port(j, arg);
6548 else
6549 retval = j->port;
6550 break;
6551 case IXJCTL_POTS_PSTN:
6552 retval = ixj_set_pots(j, arg);
6553 break;
6554 case PHONE_CAPABILITIES:
6555 add_caps(j);
6556 retval = j->caps;
6557 break;
6558 case PHONE_CAPABILITIES_LIST:
6559 add_caps(j);
6560 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6561 retval = -EFAULT;
6562 break;
6563 case PHONE_CAPABILITIES_CHECK:
6564 {
6565 struct phone_capability cap;
6566 if (copy_from_user(&cap, argp, sizeof(cap)))
6567 retval = -EFAULT;
6568 else {
6569 add_caps(j);
6570 retval = capabilities_check(j, &cap);
6571 }
6572 }
6573 break;
6574 case PHONE_PSTN_SET_STATE:
6575 daa_set_mode(j, arg);
6576 break;
6577 case PHONE_PSTN_GET_STATE:
6578 retval = j->daa_mode;
6579 j->ex.bits.pstn_ring = 0;
6580 break;
6581 case IXJCTL_SET_FILTER:
6582 if (copy_from_user(&jf, argp, sizeof(jf)))
6583 retval = -EFAULT;
Nicolas Kaiserb0438a12010-10-29 11:41:42 +0200[diff] [blame^]6584 else
6585 retval = ixj_init_filter(j, &jf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6586 break;
6587 case IXJCTL_SET_FILTER_RAW:
6588 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6589 retval = -EFAULT;
6590 else
6591 retval = ixj_init_filter_raw(j, &jfr);
6592 break;
6593 case IXJCTL_GET_FILTER_HIST:
6594 if(arg<0||arg>3)
6595 retval = -EINVAL;
6596 else
6597 retval = j->filter_hist[arg];
6598 break;
6599 case IXJCTL_INIT_TONE:
6600 if (copy_from_user(&ti, argp, sizeof(ti)))
6601 retval = -EFAULT;
6602 else
6603 retval = ixj_init_tone(j, &ti);
6604 break;
6605 case IXJCTL_TONE_CADENCE:
6606 retval = ixj_build_cadence(j, argp);
6607 break;
6608 case IXJCTL_FILTER_CADENCE:
6609 retval = ixj_build_filter_cadence(j, argp);
6610 break;
6611 case IXJCTL_SIGCTL:
6612 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6613 retval = -EFAULT;
6614 break;
6615 }
6616 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6617 if(j->sigdef.event < 33) {
6618 raise = 1;
6619 for(mant = 0; mant < j->sigdef.event; mant++){
6620 raise *= 2;
6621 }
6622 if(j->sigdef.signal)
6623 j->ex_sig.bytes |= raise;
6624 else
6625 j->ex_sig.bytes &= (raise^0xffff);
6626 }
6627 break;
6628 case IXJCTL_INTERCOM_STOP:
6629 if(arg < 0 || arg >= IXJMAX)
6630 return -EINVAL;
6631 j->intercom = -1;
6632 ixj_record_stop(j);
6633 ixj_play_stop(j);
6634 idle(j);
6635 get_ixj(arg)->intercom = -1;
6636 ixj_record_stop(get_ixj(arg));
6637 ixj_play_stop(get_ixj(arg));
6638 idle(get_ixj(arg));
6639 break;
6640 case IXJCTL_INTERCOM_START:
6641 if(arg < 0 || arg >= IXJMAX)
6642 return -EINVAL;
6643 j->intercom = arg;
6644 ixj_record_start(j);
6645 ixj_play_start(j);
6646 get_ixj(arg)->intercom = board;
6647 ixj_play_start(get_ixj(arg));
6648 ixj_record_start(get_ixj(arg));
6649 break;
6650 }
6651 if (ixjdebug & 0x0040)
6652 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6653 clear_bit(board, &j->busyflags);
6654 return retval;
6655}
6656
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6657static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6658{
6659 long ret;
Arnd Bergmann613655f2010-06-02 14:28:52 +0200[diff] [blame]6660 mutex_lock(&ixj_mutex);
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6661 ret = do_ixj_ioctl(file_p, cmd, arg);
Arnd Bergmann613655f2010-06-02 14:28:52 +0200[diff] [blame]6662 mutex_unlock(&ixj_mutex);
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6663 return ret;
6664}
6665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6666static int ixj_fasync(int fd, struct file *file_p, int mode)
6667{
Josef Sipekd1f22972006-12-08 02:37:14 -0800[diff] [blame]6668 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6669
6670 return fasync_helper(fd, file_p, mode, &j->async_queue);
6671}
6672
Arjan van de Ven00977a52007-02-12 00:55:34 -0800[diff] [blame]6673static const struct file_operations ixj_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6674{
6675 .owner = THIS_MODULE,
6676 .read = ixj_enhanced_read,
6677 .write = ixj_enhanced_write,
6678 .poll = ixj_poll,
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6679 .unlocked_ioctl = ixj_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6680 .release = ixj_release,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200[diff] [blame]6681 .fasync = ixj_fasync,
6682 .llseek = default_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6683};
6684
6685static int ixj_linetest(IXJ *j)
6686{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6687 j->flags.pstncheck = 1; /* Testing */
6688 j->flags.pstn_present = 0; /* Assume the line is not there */
6689
6690 daa_int_read(j); /*Clear DAA Interrupt flags */
6691 /* */
6692 /* Hold all relays in the normally de-energized position. */
6693 /* */
6694
6695 j->pld_slicw.bits.rly1 = 0;
6696 j->pld_slicw.bits.rly2 = 0;
6697 j->pld_slicw.bits.rly3 = 0;
6698 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6699 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6700
6701 outb_p(j->pld_scrw.byte, j->XILINXbase);
6702 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6703 if (j->pld_slicr.bits.potspstn) {
6704 j->flags.pots_pstn = 1;
6705 j->flags.pots_correct = 0;
6706 LED_SetState(0x4, j);
6707 } else {
6708 j->flags.pots_pstn = 0;
6709 j->pld_slicw.bits.rly1 = 0;
6710 j->pld_slicw.bits.rly2 = 0;
6711 j->pld_slicw.bits.rly3 = 1;
6712 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6713 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6714
6715 outb_p(j->pld_scrw.byte, j->XILINXbase);
6716 daa_set_mode(j, SOP_PU_CONVERSATION);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6717 msleep(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6718 daa_int_read(j);
6719 daa_set_mode(j, SOP_PU_RESET);
6720 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6721 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6722 LED_SetState(0x4, j);
6723 j->pld_slicw.bits.rly3 = 0;
6724 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6725 } else {
6726 j->flags.pots_correct = 1;
6727 LED_SetState(0x8, j);
6728 j->pld_slicw.bits.rly1 = 1;
6729 j->pld_slicw.bits.rly2 = 0;
6730 j->pld_slicw.bits.rly3 = 0;
6731 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6732 }
6733 }
6734 j->pld_slicw.bits.rly3 = 0;
6735 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6736 daa_set_mode(j, SOP_PU_CONVERSATION);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6737 msleep(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6738 daa_int_read(j);
6739 daa_set_mode(j, SOP_PU_RESET);
6740 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6741 j->pstn_sleeptil = jiffies + (hertz / 4);
6742 j->flags.pstn_present = 1;
6743 } else {
6744 j->flags.pstn_present = 0;
6745 }
6746 if (j->flags.pstn_present) {
6747 if (j->flags.pots_correct) {
6748 LED_SetState(0xA, j);
6749 } else {
6750 LED_SetState(0x6, j);
6751 }
6752 } else {
6753 if (j->flags.pots_correct) {
6754 LED_SetState(0x9, j);
6755 } else {
6756 LED_SetState(0x5, j);
6757 }
6758 }
6759 j->flags.pstncheck = 0; /* Testing */
6760 return j->flags.pstn_present;
6761}
6762
6763static int ixj_selfprobe(IXJ *j)
6764{
6765 unsigned short cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6766 int cnt;
6767 BYTES bytes;
6768
6769 init_waitqueue_head(&j->poll_q);
6770 init_waitqueue_head(&j->read_q);
6771 init_waitqueue_head(&j->write_q);
6772
6773 while(atomic_read(&j->DSPWrite) > 0)
6774 atomic_dec(&j->DSPWrite);
6775 if (ixjdebug & 0x0002)
6776 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6777 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6778
6779 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6780 return -1;
6781/* The read values of the SSR should be 0x00 for the IDLE command */
6782 if (j->ssr.low || j->ssr.high)
6783 return -1;
6784 if (ixjdebug & 0x0002)
6785 printk(KERN_INFO "Get Device ID Code\n");
6786 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6787 return -1;
6788 j->dsp.low = j->ssr.low;
6789 j->dsp.high = j->ssr.high;
6790 if (ixjdebug & 0x0002)
6791 printk(KERN_INFO "Get Device Version Code\n");
6792 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6793 return -1;
6794 j->ver.low = j->ssr.low;
6795 j->ver.high = j->ssr.high;
6796 if (!j->cardtype) {
6797 if (j->dsp.low == 0x21) {
6798 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6799 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6800/* Test for Internet LineJACK or Internet PhoneJACK Lite */
6801 bytes.low = inb_p(j->XILINXbase + 0x02);
6802 if (bytes.low == bytes.high) /* Register is read only on */
6803 /* Internet PhoneJack Lite */
6804 {
6805 j->cardtype = QTI_PHONEJACK_LITE;
6806 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6807 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6808 return -1;
6809 }
6810 j->pld_slicw.pcib.e1 = 1;
6811 outb_p(j->pld_slicw.byte, j->XILINXbase);
6812 } else {
6813 j->cardtype = QTI_LINEJACK;
6814
6815 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6816 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6817 return -1;
6818 }
6819 }
6820 } else if (j->dsp.low == 0x22) {
6821 j->cardtype = QTI_PHONEJACK_PCI;
6822 request_region(j->XILINXbase, 4, "ixj control");
6823 j->pld_slicw.pcib.e1 = 1;
6824 outb_p(j->pld_slicw.byte, j->XILINXbase);
6825 } else
6826 j->cardtype = QTI_PHONEJACK;
6827 } else {
6828 switch (j->cardtype) {
6829 case QTI_PHONEJACK:
6830 if (!j->dsp.low != 0x20) {
6831 j->dsp.high = 0x80;
6832 j->dsp.low = 0x20;
6833 ixj_WriteDSPCommand(0x3800, j);
6834 j->ver.low = j->ssr.low;
6835 j->ver.high = j->ssr.high;
6836 }
6837 break;
6838 case QTI_LINEJACK:
6839 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6840 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6841 return -1;
6842 }
6843 break;
6844 case QTI_PHONEJACK_LITE:
6845 case QTI_PHONEJACK_PCI:
6846 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6847 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6848 return -1;
6849 }
6850 j->pld_slicw.pcib.e1 = 1;
6851 outb_p(j->pld_slicw.byte, j->XILINXbase);
6852 break;
6853 case QTI_PHONECARD:
6854 break;
6855 }
6856 }
6857 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6858 if (ixjdebug & 0x0002)
6859 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6860 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6861 return -1;
6862 if (ixjdebug & 0x0002)
6863 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6864 if (j->cardtype == QTI_PHONEJACK) {
6865 cmd = 0x9FF2;
6866 } else {
6867 cmd = 0x9FF5;
6868 }
6869 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6870 return -1;
6871 } else {
6872 if (set_base_frame(j, 30) != 30)
6873 return -1;
6874 if (ixjdebug & 0x0002)
6875 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6876 if (j->cardtype == QTI_PHONECARD) {
6877 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6878 return -1;
6879 }
6880 if (j->cardtype == QTI_LINEJACK) {
6881 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6882 return -1;
6883 if (ixjdebug & 0x0002)
6884 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6885 j->pld_clock.byte = 0;
6886 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6887 }
6888 }
6889
6890 if (j->dsp.low == 0x20) {
6891 if (ixjdebug & 0x0002)
6892 printk(KERN_INFO "Configure GPIO pins\n");
6893 j->gpio.bytes.high = 0x09;
6894/* bytes.low = 0xEF; 0xF7 */
6895 j->gpio.bits.gpio1 = 1;
6896 j->gpio.bits.gpio2 = 1;
6897 j->gpio.bits.gpio3 = 0;
6898 j->gpio.bits.gpio4 = 1;
6899 j->gpio.bits.gpio5 = 1;
6900 j->gpio.bits.gpio6 = 1;
6901 j->gpio.bits.gpio7 = 1;
6902 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6903 if (ixjdebug & 0x0002)
6904 printk(KERN_INFO "Enable SLIC\n");
6905 j->gpio.bytes.high = 0x0B;
6906 j->gpio.bytes.low = 0x00;
6907 j->gpio.bits.gpio1 = 0;
6908 j->gpio.bits.gpio2 = 1;
6909 j->gpio.bits.gpio5 = 0;
6910 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6911 j->port = PORT_POTS;
6912 } else {
6913 if (j->cardtype == QTI_LINEJACK) {
6914 LED_SetState(0x1, j);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6915 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6916 LED_SetState(0x2, j);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6917 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6918 LED_SetState(0x4, j);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6919 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6920 LED_SetState(0x8, j);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6921 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6922 LED_SetState(0x0, j);
6923 daa_get_version(j);
6924 if (ixjdebug & 0x0002)
6925 printk("Loading DAA Coefficients\n");
6926 DAA_Coeff_US(j);
6927 if (!ixj_daa_write(j)) {
6928 printk("DAA write failed on board %d\n", j->board);
6929 return -1;
6930 }
6931 if(!ixj_daa_cid_reset(j)) {
6932 printk("DAA CID reset failed on board %d\n", j->board);
6933 return -1;
6934 }
6935 j->flags.pots_correct = 0;
6936 j->flags.pstn_present = 0;
6937 ixj_linetest(j);
6938 if (j->flags.pots_correct) {
6939 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6940
6941 outb_p(j->pld_scrw.byte, j->XILINXbase);
6942 j->pld_slicw.bits.rly1 = 1;
6943 j->pld_slicw.bits.spken = 1;
6944 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6945 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6946/* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6947 j->port = PORT_POTS;
6948 }
6949 ixj_set_port(j, PORT_PSTN);
6950 ixj_set_pots(j, 1);
6951 if (ixjdebug & 0x0002)
6952 printk(KERN_INFO "Enable Mixer\n");
6953 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6954 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6955
6956 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6957 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6958
6959 ixj_mixer(0x0480, j); /*FM Left mute */
6960 ixj_mixer(0x0580, j); /*FM Right mute */
6961
6962 ixj_mixer(0x0680, j); /*CD Left mute */
6963 ixj_mixer(0x0780, j); /*CD Right mute */
6964
6965 ixj_mixer(0x0880, j); /*Line Left mute */
6966 ixj_mixer(0x0980, j); /*Line Right mute */
6967
6968 ixj_mixer(0x0A80, j); /*Aux left mute */
6969 ixj_mixer(0x0B80, j); /*Aux right mute */
6970
6971 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6972 ixj_mixer(0x0D80, j); /*Mono2 mute */
6973
6974 ixj_mixer(0x0E80, j); /*Mic mute */
6975
6976 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6977
6978 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6979 ixj_mixer(0x110C, j);
6980
6981
6982 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6983 ixj_mixer(0x1401, j);
6984
6985 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6986 ixj_mixer(0x1501, j);
6987
6988 ixj_mixer(0x1700, j); /*Clock select */
6989
6990 ixj_mixer(0x1800, j); /*ADC input from mixer */
6991
6992 ixj_mixer(0x1901, j); /*Mic gain 30db */
6993
6994 if (ixjdebug & 0x0002)
6995 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6996 j->cadence_f[4].state = 0;
6997 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
6998 j->cadence_f[4].off1 = 0;
6999 j->cadence_f[4].on2 = 0;
7000 j->cadence_f[4].off2 = 0;
7001 j->cadence_f[4].on3 = 0;
7002 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7003 j->pstn_last_rmr = jiffies;
7004
7005 } else {
7006 if (j->cardtype == QTI_PHONECARD) {
7007 ixj_WriteDSPCommand(0xCF07, j);
7008 ixj_WriteDSPCommand(0x00B0, j);
7009 ixj_set_port(j, PORT_SPEAKER);
7010 } else {
7011 ixj_set_port(j, PORT_POTS);
7012 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7013/* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7014 }
7015 }
7016 }
7017
7018 j->intercom = -1;
7019 j->framesread = j->frameswritten = 0;
7020 j->read_wait = j->write_wait = 0;
7021 j->rxreadycheck = j->txreadycheck = 0;
7022
7023 /* initialise the DTMF prescale to a sensible value */
7024 if (j->cardtype == QTI_LINEJACK) {
7025 set_dtmf_prescale(j, 0x10);
7026 } else {
7027 set_dtmf_prescale(j, 0x40);
7028 }
7029 set_play_volume(j, 0x100);
7030 set_rec_volume(j, 0x100);
7031
7032 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7033 return -1;
7034/* The read values of the SSR should be 0x00 for the IDLE command */
7035 if (j->ssr.low || j->ssr.high)
7036 return -1;
7037
7038 if (ixjdebug & 0x0002)
7039 printk(KERN_INFO "Enable Line Monitor\n");
7040
7041 if (ixjdebug & 0x0002)
7042 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7043
7044 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7045 return -1;
7046
7047 if (ixjdebug & 0x002)
7048 printk(KERN_INFO "Enable DTMF Detectors\n");
7049
7050 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7051 return -1;
7052
7053 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7054 return -1;
7055
7056 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7057
7058 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7059
7060 j->ex.bits.dtmf_ready = 0;
7061 j->dtmf_state = 0;
7062 j->dtmf_wp = j->dtmf_rp = 0;
7063 j->rec_mode = j->play_mode = -1;
7064 j->flags.ringing = 0;
7065 j->maxrings = MAXRINGS;
7066 j->ring_cadence = USA_RING_CADENCE;
7067 j->drybuffer = 0;
7068 j->winktime = 320;
7069 j->flags.dtmf_oob = 0;
7070 for (cnt = 0; cnt < 4; cnt++)
7071 j->cadence_f[cnt].enable = 0;
7072 /* must be a device on the specified address */
7073 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7074
7075 /* Set up the default signals for events */
7076 for (cnt = 0; cnt < 35; cnt++)
7077 j->ixj_signals[cnt] = SIGIO;
7078
7079 /* Set the excetion signal enable flags */
7080 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7081 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 =
7082 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;
7083#ifdef IXJ_DYN_ALLOC
7084 j->fskdata = NULL;
7085#endif
7086 j->fskdcnt = 0;
7087 j->cidcw_wait = 0;
7088
7089 /* Register with the Telephony for Linux subsystem */
7090 j->p.f_op = &ixj_fops;
7091 j->p.open = ixj_open;
7092 j->p.board = j->board;
7093 phone_register_device(&j->p, PHONE_UNIT_ANY);
7094
7095 ixj_init_timer(j);
7096 ixj_add_timer(j);
7097 return 0;
7098}
7099
7100/*
7101 * Exported service for pcmcia card handling
7102 */
7103
7104IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7105{
7106 IXJ *j = ixj_alloc();
7107
7108 j->board = 0;
7109
7110 j->DSPbase = dsp;
7111 j->XILINXbase = xilinx;
7112 j->cardtype = QTI_PHONECARD;
7113 ixj_selfprobe(j);
7114 return j;
7115}
7116
7117EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7118
7119static int ixj_get_status_proc(char *buf)
7120{
7121 int len;
7122 int cnt;
7123 IXJ *j;
7124 len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7125 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7126 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7127 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7128 len += sprintf(buf + len, "\nUsing old telephony API");
7129 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7130
7131 for (cnt = 0; cnt < IXJMAX; cnt++) {
7132 j = get_ixj(cnt);
7133 if(j==NULL)
7134 continue;
7135 if (j->DSPbase) {
7136 len += sprintf(buf + len, "\nCard Num %d", cnt);
7137 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7138 if (j->cardtype != QTI_PHONEJACK)
7139 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7140 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7141 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7142 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7143 switch (j->cardtype) {
7144 case (QTI_PHONEJACK):
7145 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7146 break;
7147 case (QTI_LINEJACK):
7148 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7149 if (j->flags.g729_loaded)
7150 len += sprintf(buf + len, " w/G.729 A/B");
7151 len += sprintf(buf + len, " Country = %d", j->daa_country);
7152 break;
7153 case (QTI_PHONEJACK_LITE):
7154 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7155 if (j->flags.g729_loaded)
7156 len += sprintf(buf + len, " w/G.729 A/B");
7157 break;
7158 case (QTI_PHONEJACK_PCI):
7159 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7160 if (j->flags.g729_loaded)
7161 len += sprintf(buf + len, " w/G.729 A/B");
7162 break;
7163 case (QTI_PHONECARD):
7164 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7165 if (j->flags.g729_loaded)
7166 len += sprintf(buf + len, " w/G.729 A/B");
7167 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7168 if (!j->pccr1.bits.drf)
7169 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7170 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7171 break;
7172 default:
7173 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7174 break;
7175 }
7176 len += sprintf(buf + len, "\nReaders %d", j->readers);
7177 len += sprintf(buf + len, "\nWriters %d", j->writers);
7178 add_caps(j);
7179 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7180 if (j->dsp.low != 0x20)
7181 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7182 if (j->flags.cidsent)
7183 len += sprintf(buf + len, "\nCaller ID data sent");
7184 else
7185 len += sprintf(buf + len, "\nCaller ID data not sent");
7186
7187 len += sprintf(buf + len, "\nPlay CODEC ");
7188 switch (j->play_codec) {
7189 case G723_63:
7190 len += sprintf(buf + len, "G.723.1 6.3");
7191 break;
7192 case G723_53:
7193 len += sprintf(buf + len, "G.723.1 5.3");
7194 break;
7195 case TS85:
7196 len += sprintf(buf + len, "TrueSpeech 8.5");
7197 break;
7198 case TS48:
7199 len += sprintf(buf + len, "TrueSpeech 4.8");
7200 break;
7201 case TS41:
7202 len += sprintf(buf + len, "TrueSpeech 4.1");
7203 break;
7204 case G728:
7205 len += sprintf(buf + len, "G.728");
7206 break;
7207 case G729:
7208 len += sprintf(buf + len, "G.729");
7209 break;
7210 case G729B:
7211 len += sprintf(buf + len, "G.729B");
7212 break;
7213 case ULAW:
7214 len += sprintf(buf + len, "uLaw");
7215 break;
7216 case ALAW:
7217 len += sprintf(buf + len, "aLaw");
7218 break;
7219 case LINEAR16:
7220 len += sprintf(buf + len, "16 bit Linear");
7221 break;
7222 case LINEAR8:
7223 len += sprintf(buf + len, "8 bit Linear");
7224 break;
7225 case WSS:
7226 len += sprintf(buf + len, "Windows Sound System");
7227 break;
7228 default:
7229 len += sprintf(buf + len, "NO CODEC CHOSEN");
7230 break;
7231 }
7232 len += sprintf(buf + len, "\nRecord CODEC ");
7233 switch (j->rec_codec) {
7234 case G723_63:
7235 len += sprintf(buf + len, "G.723.1 6.3");
7236 break;
7237 case G723_53:
7238 len += sprintf(buf + len, "G.723.1 5.3");
7239 break;
7240 case TS85:
7241 len += sprintf(buf + len, "TrueSpeech 8.5");
7242 break;
7243 case TS48:
7244 len += sprintf(buf + len, "TrueSpeech 4.8");
7245 break;
7246 case TS41:
7247 len += sprintf(buf + len, "TrueSpeech 4.1");
7248 break;
7249 case G728:
7250 len += sprintf(buf + len, "G.728");
7251 break;
7252 case G729:
7253 len += sprintf(buf + len, "G.729");
7254 break;
7255 case G729B:
7256 len += sprintf(buf + len, "G.729B");
7257 break;
7258 case ULAW:
7259 len += sprintf(buf + len, "uLaw");
7260 break;
7261 case ALAW:
7262 len += sprintf(buf + len, "aLaw");
7263 break;
7264 case LINEAR16:
7265 len += sprintf(buf + len, "16 bit Linear");
7266 break;
7267 case LINEAR8:
7268 len += sprintf(buf + len, "8 bit Linear");
7269 break;
7270 case WSS:
7271 len += sprintf(buf + len, "Windows Sound System");
7272 break;
7273 default:
7274 len += sprintf(buf + len, "NO CODEC CHOSEN");
7275 break;
7276 }
7277 len += sprintf(buf + len, "\nAEC ");
7278 switch (j->aec_level) {
7279 case AEC_OFF:
7280 len += sprintf(buf + len, "Off");
7281 break;
7282 case AEC_LOW:
7283 len += sprintf(buf + len, "Low");
7284 break;
7285 case AEC_MED:
7286 len += sprintf(buf + len, "Med");
7287 break;
7288 case AEC_HIGH:
7289 len += sprintf(buf + len, "High");
7290 break;
7291 case AEC_AUTO:
7292 len += sprintf(buf + len, "Auto");
7293 break;
7294 case AEC_AGC:
7295 len += sprintf(buf + len, "AEC/AGC");
7296 break;
7297 default:
7298 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7299 break;
7300 }
7301
7302 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7303 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7304 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7305
7306 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7307
7308 if (j->cardtype == QTI_LINEJACK) {
7309 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7310 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7311 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7312 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7313 switch (j->daa_mode) {
7314 case SOP_PU_SLEEP:
7315 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7316 break;
7317 case SOP_PU_RINGING:
7318 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7319 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7320 break;
7321 case SOP_PU_CONVERSATION:
7322 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7323 break;
7324 case SOP_PU_PULSEDIALING:
7325 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7326 break;
7327 }
7328 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7329 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7330 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7331 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7332 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7333 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7334 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7335 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7336 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7337 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7338 }
7339 switch (j->port) {
7340 case PORT_POTS:
7341 len += sprintf(buf + len, "\nPort POTS");
7342 break;
7343 case PORT_PSTN:
7344 len += sprintf(buf + len, "\nPort PSTN");
7345 break;
7346 case PORT_SPEAKER:
7347 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7348 break;
7349 case PORT_HANDSET:
7350 len += sprintf(buf + len, "\nPort HANDSET");
7351 break;
7352 }
7353 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7354 len += sprintf(buf + len, "\nSLIC state ");
7355 switch (SLIC_GetState(j)) {
7356 case PLD_SLIC_STATE_OC:
7357 len += sprintf(buf + len, "OC");
7358 break;
7359 case PLD_SLIC_STATE_RINGING:
7360 len += sprintf(buf + len, "RINGING");
7361 break;
7362 case PLD_SLIC_STATE_ACTIVE:
7363 len += sprintf(buf + len, "ACTIVE");
7364 break;
7365 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7366 len += sprintf(buf + len, "OHT");
7367 break;
7368 case PLD_SLIC_STATE_TIPOPEN:
7369 len += sprintf(buf + len, "TIPOPEN");
7370 break;
7371 case PLD_SLIC_STATE_STANDBY:
7372 len += sprintf(buf + len, "STANDBY");
7373 break;
7374 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7375 len += sprintf(buf + len, "APR");
7376 break;
7377 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7378 len += sprintf(buf + len, "OHTPR");
7379 break;
7380 default:
7381 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7382 break;
7383 }
7384 }
7385 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7386 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7387#ifdef PERFMON_STATS
7388 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7389 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7390 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7391 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7392 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7393 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7394 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7395 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7396 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7397 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7398 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7399 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7400 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7401 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7402
7403#endif
7404 len += sprintf(buf + len, "\n");
7405 }
7406 }
7407 return len;
7408}
7409
7410static int ixj_read_proc(char *page, char **start, off_t off,
7411 int count, int *eof, void *data)
7412{
7413 int len = ixj_get_status_proc(page);
7414 if (len <= off+count) *eof = 1;
7415 *start = page + off;
7416 len -= off;
7417 if (len>count) len = count;
7418 if (len<0) len = 0;
7419 return len;
7420}
7421
7422
7423static void cleanup(void)
7424{
7425 int cnt;
7426 IXJ *j;
7427
7428 for (cnt = 0; cnt < IXJMAX; cnt++) {
7429 j = get_ixj(cnt);
7430 if(j != NULL && j->DSPbase) {
7431 if (ixjdebug & 0x0002)
7432 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7433 del_timer(&j->timer);
7434 if (j->cardtype == QTI_LINEJACK) {
7435 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7436
7437 outb_p(j->pld_scrw.byte, j->XILINXbase);
7438 j->pld_slicw.bits.rly1 = 0;
7439 j->pld_slicw.bits.rly2 = 0;
7440 j->pld_slicw.bits.rly3 = 0;
7441 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7442 LED_SetState(0x0, j);
7443 if (ixjdebug & 0x0002)
7444 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7445 release_region(j->XILINXbase, 8);
7446 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7447 if (ixjdebug & 0x0002)
7448 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7449 release_region(j->XILINXbase, 4);
7450 }
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]7451 kfree(j->read_buffer);
7452 kfree(j->write_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7453 if (j->dev)
7454 pnp_device_detach(j->dev);
7455 if (ixjdebug & 0x0002)
7456 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7457 phone_unregister_device(&j->p);
7458 if (ixjdebug & 0x0002)
7459 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7460 release_region(j->DSPbase, 16);
7461#ifdef IXJ_DYN_ALLOC
7462 if (ixjdebug & 0x0002)
7463 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7464 kfree(j);
7465 ixj[cnt] = NULL;
7466#endif
7467 }
7468 }
7469 if (ixjdebug & 0x0002)
7470 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7471 remove_proc_entry ("ixj", NULL);
7472}
7473
7474/* Typedefs */
7475typedef struct {
7476 BYTE length;
7477 DWORD bits;
7478} DATABLOCK;
7479
7480static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7481{
7482 lastLCC = lastLCC & 0xfb;
7483 lastLCC = lastLCC | (byData ? 4 : 0);
7484 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7485
7486 mdelay(1);
7487 lastLCC = lastLCC | 0x01;
7488 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7489
7490 byData = byData << 1;
7491 lastLCC = lastLCC & 0xfe;
7492 mdelay(1);
7493 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7494
7495}
7496
7497static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7498{
7499 mdelay(1);
7500 lastLCC = lastLCC | 0x01;
7501 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7502
7503 lastLCC = lastLCC & 0xfe;
7504 mdelay(1);
7505 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7506
7507 return ((inb(wEEPROMAddress) >> 3) & 1);
7508}
7509
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]7510static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7511{
7512 BYTE lastLCC;
7513 WORD wEEPROMAddress = wAddress + 3;
7514 DWORD i;
7515 BYTE byResult;
7516 *pwResult = 0;
7517 lastLCC = inb(wEEPROMAddress);
7518 lastLCC = lastLCC | 0x02;
7519 lastLCC = lastLCC & 0xfe;
7520 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7521
7522 mdelay(1); /* delay */
7523
7524 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7525 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7526 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7527 for (i = 0; i < 8; i++) {
7528 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7529 wLoc <<= 1;
7530 }
7531
7532 for (i = 0; i < 16; i++) {
7533 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7534 *pwResult = (*pwResult << 1) | byResult;
7535 }
7536
7537 mdelay(1); /* another delay */
7538
7539 lastLCC = lastLCC & 0xfd;
7540 outb(lastLCC, wEEPROMAddress); /* negate CS */
7541
7542 return 0;
7543}
7544
7545static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7546{
7547 WORD wLo, wHi;
7548 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7549 return 0;
7550 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7551 return 0;
7552 return (((DWORD) wHi << 16) | wLo);
7553}
7554
7555static int dspio[IXJMAX + 1] =
7556{
7557 0,
7558};
7559static int xio[IXJMAX + 1] =
7560{
7561 0,
7562};
7563
7564module_param_array(dspio, int, NULL, 0);
7565module_param_array(xio, int, NULL, 0);
7566MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7567MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7568MODULE_LICENSE("GPL");
7569
7570static void __exit ixj_exit(void)
7571{
7572 cleanup();
7573}
7574
7575static IXJ *new_ixj(unsigned long port)
7576{
7577 IXJ *res;
7578 if (!request_region(port, 16, "ixj DSP")) {
7579 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7580 return NULL;
7581 }
7582 res = ixj_alloc();
7583 if (!res) {
7584 release_region(port, 16);
7585 printk(KERN_INFO "ixj: out of memory\n");
7586 return NULL;
7587 }
7588 res->DSPbase = port;
7589 return res;
7590}
7591
7592static int __init ixj_probe_isapnp(int *cnt)
7593{
7594 int probe = 0;
7595 int func = 0x110;
7596 struct pnp_dev *dev = NULL, *old_dev = NULL;
7597
7598 while (1) {
7599 do {
7600 IXJ *j;
7601 int result;
7602
7603 old_dev = dev;
7604 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7605 ISAPNP_FUNCTION(func), old_dev);
7606 if (!dev || !dev->card)
7607 break;
7608 result = pnp_device_attach(dev);
7609 if (result < 0) {
7610 printk("pnp attach failed %d \n", result);
7611 break;
7612 }
7613 if (pnp_activate_dev(dev) < 0) {
7614 printk("pnp activate failed (out of resources?)\n");
7615 pnp_device_detach(dev);
7616 return -ENOMEM;
7617 }
7618
7619 if (!pnp_port_valid(dev, 0)) {
7620 pnp_device_detach(dev);
7621 return -ENODEV;
7622 }
7623
7624 j = new_ixj(pnp_port_start(dev, 0));
7625 if (!j)
7626 break;
7627
7628 if (func != 0x110)
7629 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7630
7631 switch (func) {
7632 case (0x110):
7633 j->cardtype = QTI_PHONEJACK;
7634 break;
7635 case (0x310):
7636 j->cardtype = QTI_LINEJACK;
7637 break;
7638 case (0x410):
7639 j->cardtype = QTI_PHONEJACK_LITE;
7640 break;
7641 }
7642 j->board = *cnt;
7643 probe = ixj_selfprobe(j);
7644 if(!probe) {
7645 j->serial = dev->card->serial;
7646 j->dev = dev;
7647 switch (func) {
7648 case 0x110:
7649 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7650 break;
7651 case 0x310:
7652 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7653 break;
7654 case 0x410:
7655 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7656 break;
7657 }
7658 }
7659 ++*cnt;
7660 } while (dev);
7661 if (func == 0x410)
7662 break;
7663 if (func == 0x310)
7664 func = 0x410;
7665 if (func == 0x110)
7666 func = 0x310;
7667 dev = NULL;
7668 }
7669 return probe;
7670}
7671
7672static int __init ixj_probe_isa(int *cnt)
7673{
7674 int i, probe;
7675
7676 /* Use passed parameters for older kernels without PnP */
7677 for (i = 0; i < IXJMAX; i++) {
7678 if (dspio[i]) {
7679 IXJ *j = new_ixj(dspio[i]);
7680
7681 if (!j)
7682 break;
7683
7684 j->XILINXbase = xio[i];
7685 j->cardtype = 0;
7686
7687 j->board = *cnt;
7688 probe = ixj_selfprobe(j);
7689 j->dev = NULL;
7690 ++*cnt;
7691 }
7692 }
7693 return 0;
7694}
7695
7696static int __init ixj_probe_pci(int *cnt)
7697{
7698 struct pci_dev *pci = NULL;
7699 int i, probe = 0;
7700 IXJ *j = NULL;
7701
7702 for (i = 0; i < IXJMAX - *cnt; i++) {
Surya6de2d202007-05-08 00:25:57 -0700[diff] [blame]7703 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
Ben Collinsd77f09e2006-10-18 08:45:30 -0400[diff] [blame]7704 PCI_DEVICE_ID_QUICKNET_XJ, pci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7705 if (!pci)
7706 break;
7707
7708 if (pci_enable_device(pci))
7709 break;
7710 j = new_ixj(pci_resource_start(pci, 0));
7711 if (!j)
7712 break;
7713
7714 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7715 j->XILINXbase = j->DSPbase + 0x10;
7716 j->cardtype = QTI_PHONEJACK_PCI;
7717 j->board = *cnt;
7718 probe = ixj_selfprobe(j);
7719 if (!probe)
7720 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7721 ++*cnt;
7722 }
Surya6de2d202007-05-08 00:25:57 -0700[diff] [blame]7723 pci_dev_put(pci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7724 return probe;
7725}
7726
7727static int __init ixj_init(void)
7728{
7729 int cnt = 0;
7730 int probe = 0;
7731
7732 cnt = 0;
7733
7734 /* These might be no-ops, see above. */
7735 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7736 return probe;
7737 }
7738 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7739 return probe;
7740 }
7741 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7742 return probe;
7743 }
Domen Puncerfba478b2005-05-05 16:16:13 -0700[diff] [blame]7744 printk(KERN_INFO "ixj driver initialized.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7745 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7746 return probe;
7747}
7748
7749module_init(ixj_init);
7750module_exit(ixj_exit);
7751
7752static void DAA_Coeff_US(IXJ *j)
7753{
7754 int i;
7755
7756 j->daa_country = DAA_US;
7757 /*----------------------------------------------- */
7758 /* CAO */
7759 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7760 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7761 }
7762
7763/* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7764 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7765 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7766 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7767 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7768 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7769 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7770 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7771 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7772/* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7773 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7774 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7775 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7776 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7777 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7778 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7779 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7780 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7781/* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7782 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7783 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7784 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7785 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7786 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7787 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7788 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7789 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7790/* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7791 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7792 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7793 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7794 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7795 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7796 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7797 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7798 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7799/* Bytes for AX-filter (0A): 16,55,DD,CA */
7800 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7801 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7802 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7803 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7804/* Bytes for AR-filter (09): 52,D3,11,42 */
7805 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7806 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7807 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7808 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7809/* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7810 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7811 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7812 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7813 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7814 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7815 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7816 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7817 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7818/* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7819 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7820 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7821 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7822 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7823 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7824 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7825 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7826 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7827/* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7828 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7829 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7830 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7831 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7832 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7833 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7834 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7835 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7836/* ; (10K, 0.68uF) */
7837 /* */
7838 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7839 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7840 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7841 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7842 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7843 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7844 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7845 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7846 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7847 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7848 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7849 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7850 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7851 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7852 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7853 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7854 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7855 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7856
7857 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7858 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7859 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7860 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7861 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7862
7863 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7864/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7865/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7866/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7867/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7868/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7869/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7870/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7871/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7872 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7873/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7874/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7875/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7876/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7877/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7878/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7879/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7880/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7881/* */
7882 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7883/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7884/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7885/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7886/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7887
7888 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7889 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7890 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7891 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7892 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7893 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7894 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7895 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7896 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7897/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7898 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7899 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7900 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7901 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7902 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7903 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7904 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7905 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7906/* */
7907 /* ;CR Registers */
7908 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7909 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7910/* Config. Reg. 1 (dialing) (cr1):05 */
7911 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7912/* Config. Reg. 2 (caller ID) (cr2):04 */
7913 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7914/* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7915 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7916/* Config. Reg. 4 (analog gain) (cr4):02 */
7917 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7918 /* Config. Reg. 5 (Version) (cr5):02 */
7919 /* Config. Reg. 6 (Reserved) (cr6):00 */
7920 /* Config. Reg. 7 (Reserved) (cr7):00 */
7921 /* */
7922 /* ;xr Registers */
7923 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7924
7925 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7926 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7927
7928 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7929/* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7930 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7931/* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7932 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7933 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7934
7935 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7936/* Ext. Reg. 5 (Ring timer) (xr5):22 */
7937 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7938/* Ext. Reg. 6 (Power State) (xr6):00 */
7939 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7940/* Ext. Reg. 7 (Vdd) (xr7):40 */
7941 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7942 /* */
7943 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7944 /* 12,33,5A,C3 ; 770 Hz */
7945 /* 13,3C,5B,32 ; 852 Hz */
7946 /* 1D,1B,5C,CC ; 941 Hz */
7947
7948 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7949 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7950 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7951 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7952/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7953 /* EC,1D,52,22 ; 1336 Hz */
7954 /* AA,AC,51,D2 ; 1477 Hz */
7955 /* 9B,3B,51,25 ; 1633 Hz */
7956 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7957 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7958 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7959 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7960}
7961
7962static void DAA_Coeff_UK(IXJ *j)
7963{
7964 int i;
7965
7966 j->daa_country = DAA_UK;
7967 /*----------------------------------------------- */
7968 /* CAO */
7969 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7970 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7971 }
7972
7973/* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7974 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7975 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7976 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7977 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7978 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7979 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7980 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7981 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7982/* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7983 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7984 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7985 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7986 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7987 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7988 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7989 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7990 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7991/* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7992 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7993 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7994 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7995 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7996 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7997 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7998 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7999 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8000/* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
8001 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8002 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8003 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8004 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8005 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8006 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8007 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8008 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8009/* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8010 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8011 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8012 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8013 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8014/* Bytes for AR-filter (09): E2,27,10,D6 */
8015 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8016 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8017 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8018 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8019/* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8020 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8021 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8022 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8023 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8024 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8025 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8026 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8027 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8028/* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8029 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8030 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8031 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8032 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8033 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8034 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8035 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8036 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8037/* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8038 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8039 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8040 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8041 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8042 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8043 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8044 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8045 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8046/* ; idle */
8047 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8048 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8049 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8050 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8051 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8052 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8053 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8054 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8055 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8056/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8057 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8058 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8059 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8060 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8061 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8062 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8063 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8064 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8065/* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8066 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8067 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8068 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8069 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8070/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8071 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8072 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8073 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8074 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8075 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8076 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8077 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8078 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8079/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8080 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8081 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8082 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8083 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8084 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8085 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8086 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8087 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8088/* ;CR Registers */
8089 /* Config. Reg. 0 (filters) (cr0):FF */
8090 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8091/* Config. Reg. 1 (dialing) (cr1):05 */
8092 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8093/* Config. Reg. 2 (caller ID) (cr2):04 */
8094 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8095/* Config. Reg. 3 (testloops) (cr3):00 ; */
8096 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8097/* Config. Reg. 4 (analog gain) (cr4):02 */
8098 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8099 /* Config. Reg. 5 (Version) (cr5):02 */
8100 /* Config. Reg. 6 (Reserved) (cr6):00 */
8101 /* Config. Reg. 7 (Reserved) (cr7):00 */
8102 /* ;xr Registers */
8103 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8104
8105 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8106 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8107
8108 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8109 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8110
8111 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8112/* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8113 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8114/* Ext. Reg. 4 (Cadence) (xr4):00 */
8115 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8116/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8117 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8118/* Ext. Reg. 6 (Power State) (xr6):00 */
8119 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8120/* Ext. Reg. 7 (Vdd) (xr7):46 */
8121 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8122 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8123 /* 12,33,5A,C3 ; 770 Hz */
8124 /* 13,3C,5B,32 ; 852 Hz */
8125 /* 1D,1B,5C,CC ; 941 Hz */
8126
8127 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8128 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8129 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8130 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8131/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8132 /* EC,1D,52,22 ; 1336 Hz */
8133 /* AA,AC,51,D2 ; 1477 Hz */
8134 /* 9B,3B,51,25 ; 1633 Hz */
8135 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8136 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8137 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8138 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8139}
8140
8141
8142static void DAA_Coeff_France(IXJ *j)
8143{
8144 int i;
8145
8146 j->daa_country = DAA_FRANCE;
8147 /*----------------------------------------------- */
8148 /* CAO */
8149 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8150 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8151 }
8152
8153/* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8154 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8155 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8156 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8157 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8158 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8159 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8160 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8161 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8162/* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8163 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8164 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8165 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8166 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8167 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8168 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8169 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8170 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8171/* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8172 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8173 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8174 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8175 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8176 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8177 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8178 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8179 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8180/* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8181 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8182 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8183 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8184 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8185 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8186 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8187 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8188 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8189/* Bytes for AX-filter (0A): 16,B5,DD,CA */
8190 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8191 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8192 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8193 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8194/* Bytes for AR-filter (09): 52,C7,10,D6 */
8195 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8196 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8197 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8198 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8199/* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8200 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8201 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8202 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8203 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8204 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8205 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8206 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8207 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8208/* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8209 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8210 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8211 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8212 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8213 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8214 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8215 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8216 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8217/* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8218 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8219 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8220 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8221 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8222 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8223 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8224 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8225 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8226/* ; idle */
8227 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8228 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8229 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8230 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8231 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8232 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8233 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8234 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8235 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8236/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8237 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8238 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8239 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8240 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8241 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8242 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8243 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8244 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8245/* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8246 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8247 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8248 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8249 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8250/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8251 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8252 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8253 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8254 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8255 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8256 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8257 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8258 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8259/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8260 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8261 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8262 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8263 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8264 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8265 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8266 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8267 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8268/* ;CR Registers */
8269 /* Config. Reg. 0 (filters) (cr0):FF */
8270 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8271/* Config. Reg. 1 (dialing) (cr1):05 */
8272 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8273/* Config. Reg. 2 (caller ID) (cr2):04 */
8274 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8275/* Config. Reg. 3 (testloops) (cr3):00 ; */
8276 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8277/* Config. Reg. 4 (analog gain) (cr4):02 */
8278 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8279 /* Config. Reg. 5 (Version) (cr5):02 */
8280 /* Config. Reg. 6 (Reserved) (cr6):00 */
8281 /* Config. Reg. 7 (Reserved) (cr7):00 */
8282 /* ;xr Registers */
8283 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8284
8285 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8286 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8287
8288 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8289 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8290
8291 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8292/* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8293 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8294/* Ext. Reg. 4 (Cadence) (xr4):00 */
8295 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8296/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8297 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8298/* Ext. Reg. 6 (Power State) (xr6):00 */
8299 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8300/* Ext. Reg. 7 (Vdd) (xr7):46 */
8301 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8302 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8303 /* 12,33,5A,C3 ; 770 Hz */
8304 /* 13,3C,5B,32 ; 852 Hz */
8305 /* 1D,1B,5C,CC ; 941 Hz */
8306
8307 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8308 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8309 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8310 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8311/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8312 /* EC,1D,52,22 ; 1336 Hz */
8313 /* AA,AC,51,D2 ; 1477 Hz */
8314 /* 9B,3B,51,25 ; 1633 Hz */
8315 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8316 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8317 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8318 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8319}
8320
8321
8322static void DAA_Coeff_Germany(IXJ *j)
8323{
8324 int i;
8325
8326 j->daa_country = DAA_GERMANY;
8327 /*----------------------------------------------- */
8328 /* CAO */
8329 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8330 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8331 }
8332
8333/* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8334 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8335 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8336 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8337 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8338 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8339 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8340 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8341 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8342/* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8343 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8344 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8345 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8346 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8347 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8348 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8349 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8350 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8351/* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8352 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8353 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8354 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8355 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8356 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8357 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8358 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8359 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8360/* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8361 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8362 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8363 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8364 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8365 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8366 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8367 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8368 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8369/* Bytes for AX-filter (0A): 72,D5,DD,CA */
8370 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8371 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8372 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8373 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8374/* Bytes for AR-filter (09): 72,42,13,4B */
8375 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8376 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8377 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8378 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8379/* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8380 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8381 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8382 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8383 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8384 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8385 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8386 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8387 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8388/* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8389 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8390 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8391 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8392 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8393 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8394 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8395 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8396 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8397/* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8398 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8399 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8400 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8401 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8402 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8403 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8404 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8405 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8406/* ; (10K, 0.68uF) */
8407 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8408 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8409 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8410 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8411 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8412 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8413 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8414 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8415 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8416/* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8417 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8418 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8419 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8420 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8421 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8422 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8423 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8424 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8425/* Levelmetering Ringing (0D):B2,45,0F,8E */
8426 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8427 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8428 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8429 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8430/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8431 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8432 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8433 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8434 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8435 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8436 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8437 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8438 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8439/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8440 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8441 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8442 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8443 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8444 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8445 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8446 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8447 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8448/* ;CR Registers */
8449 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8450 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8451/* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8452 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8453/* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8454 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8455/* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8456 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8457/* Config. Reg. 4 (analog gain) (cr4):02 */
8458 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8459 /* Config. Reg. 5 (Version) (cr5):02 */
8460 /* Config. Reg. 6 (Reserved) (cr6):00 */
8461 /* Config. Reg. 7 (Reserved) (cr7):00 */
8462 /* ;xr Registers */
8463 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8464
8465 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8466 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8467
8468 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8469 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8470
8471 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8472/* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8473 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8474/* Ext. Reg. 4 (Cadence) (xr4):00 */
8475 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8476/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8477 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8478/* Ext. Reg. 6 (Power State) (xr6):00 */
8479 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8480/* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8481 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8482 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8483 /* 12,33,5A,C3 ; 770 Hz */
8484 /* 13,3C,5B,32 ; 852 Hz */
8485 /* 1D,1B,5C,CC ; 941 Hz */
8486
8487 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8488 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8489 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8490 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8491/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8492 /* EC,1D,52,22 ; 1336 Hz */
8493 /* AA,AC,51,D2 ; 1477 Hz */
8494 /* 9B,3B,51,25 ; 1633 Hz */
8495 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8496 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8497 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8498 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8499}
8500
8501
8502static void DAA_Coeff_Australia(IXJ *j)
8503{
8504 int i;
8505
8506 j->daa_country = DAA_AUSTRALIA;
8507 /*----------------------------------------------- */
8508 /* CAO */
8509 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8510 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8511 }
8512
8513/* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8514 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8515 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8516 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8517 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8518 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8519 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8520 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8521 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8522/* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8523 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8524 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8525 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8526 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8527 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8528 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8529 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8530 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8531/* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8532 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8533 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8534 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8535 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8536 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8537 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8538 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8539 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8540/* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8541 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8542 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8543 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8544 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8545 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8546 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8547 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8548 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8549/* Bytes for AX-filter (0A): CB,45,DD,CA */
8550 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8551 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8552 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8553 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8554/* Bytes for AR-filter (09): 1B,67,10,D6 */
8555 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8556 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8557 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8558 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8559/* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8560 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8561 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8562 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8563 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8564 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8565 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8566 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8567 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8568/* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8569 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8570 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8571 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8572 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8573 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8574 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8575 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8576 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8577/* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8578 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8579 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8580 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8581 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8582 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8583 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8584 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8585 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8586/* ; idle */
8587 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8588 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8589 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8590 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8591 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8592 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8593 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8594 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8595 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8596/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8597 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8598 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8599 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8600 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8601 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8602 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8603 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8604 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8605/* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8606 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8607 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8608 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8609 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8610/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8611 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8612 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8613 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8614 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8615 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8616 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8617 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8618 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8619/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8620 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8621 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8622 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8623 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8624 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8625 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8626 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8627 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8628/* ;CR Registers */
8629 /* Config. Reg. 0 (filters) (cr0):FF */
8630 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8631/* Config. Reg. 1 (dialing) (cr1):05 */
8632 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8633/* Config. Reg. 2 (caller ID) (cr2):04 */
8634 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8635/* Config. Reg. 3 (testloops) (cr3):00 ; */
8636 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8637/* Config. Reg. 4 (analog gain) (cr4):02 */
8638 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8639 /* Config. Reg. 5 (Version) (cr5):02 */
8640 /* Config. Reg. 6 (Reserved) (cr6):00 */
8641 /* Config. Reg. 7 (Reserved) (cr7):00 */
8642 /* ;xr Registers */
8643 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8644
8645 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8646 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8647
8648 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8649 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8650
8651 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8652/* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8653 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8654/* Ext. Reg. 4 (Cadence) (xr4):00 */
8655 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8656/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8657 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8658/* Ext. Reg. 6 (Power State) (xr6):00 */
8659 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8660/* Ext. Reg. 7 (Vdd) (xr7):40 */
8661 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8662
8663 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8664 /* 12,33,5A,C3 ; 770 Hz */
8665 /* 13,3C,5B,32 ; 852 Hz */
8666 /* 1D,1B,5C,CC ; 941 Hz */
8667 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8668 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8669 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8670 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8671
8672 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8673 /* EC,1D,52,22 ; 1336 Hz */
8674 /* AA,AC,51,D2 ; 1477 Hz */
8675 /* 9B,3B,51,25 ; 1633 Hz */
8676 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8677 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8678 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8679 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8680}
8681
8682static void DAA_Coeff_Japan(IXJ *j)
8683{
8684 int i;
8685
8686 j->daa_country = DAA_JAPAN;
8687 /*----------------------------------------------- */
8688 /* CAO */
8689 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8690 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8691 }
8692
8693/* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8694 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8695 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8696 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8697 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8698 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8699 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8700 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8701 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8702/* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8703 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8704 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8705 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8706 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8707 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8708 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8709 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8710 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8711/* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8712 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8713 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8714 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8715 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8716 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8717 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8718 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8719 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8720/* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8721 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8722 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8723 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8724 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8725 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8726 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8727 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8728 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8729/* Bytes for AX-filter (0A): 51,C5,DD,CA */
8730 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8731 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8732 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8733 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8734/* Bytes for AR-filter (09): 25,A7,10,D6 */
8735 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8736 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8737 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8738 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8739/* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8740 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8741 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8742 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8743 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8744 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8745 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8746 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8747 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8748/* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8749 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8750 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8751 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8752 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8753 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8754 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8755 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8756 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8757/* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8758 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8759 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8760 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8761 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8762 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8763 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8764 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8765 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8766/* ; idle */
8767 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8768 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8769 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8770 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8771 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8772 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8773 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8774 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8775 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8776/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8777 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8778 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8779 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8780 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8781 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8782 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8783 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8784 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8785/* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8786 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8787 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8788 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8789 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8790/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8791 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8792 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8793 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8794 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8795 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8796 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8797 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8798 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8799/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8800 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8801 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8802 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8803 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8804 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8805 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8806 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8807 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8808/* ;CR Registers */
8809 /* Config. Reg. 0 (filters) (cr0):FF */
8810 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8811/* Config. Reg. 1 (dialing) (cr1):05 */
8812 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8813/* Config. Reg. 2 (caller ID) (cr2):04 */
8814 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8815/* Config. Reg. 3 (testloops) (cr3):00 ; */
8816 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8817/* Config. Reg. 4 (analog gain) (cr4):02 */
8818 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8819 /* Config. Reg. 5 (Version) (cr5):02 */
8820 /* Config. Reg. 6 (Reserved) (cr6):00 */
8821 /* Config. Reg. 7 (Reserved) (cr7):00 */
8822 /* ;xr Registers */
8823 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8824
8825 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8826 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8827
8828 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8829 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8830
8831 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8832/* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8833 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8834/* Ext. Reg. 4 (Cadence) (xr4):00 */
8835 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8836/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8837 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8838/* Ext. Reg. 6 (Power State) (xr6):00 */
8839 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8840/* Ext. Reg. 7 (Vdd) (xr7):40 */
8841 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8842 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8843 /* 12,33,5A,C3 ; 770 Hz */
8844 /* 13,3C,5B,32 ; 852 Hz */
8845 /* 1D,1B,5C,CC ; 941 Hz */
8846
8847 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8848 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8849 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8850 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8851/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8852 /* EC,1D,52,22 ; 1336 Hz */
8853 /* AA,AC,51,D2 ; 1477 Hz */
8854 /* 9B,3B,51,25 ; 1633 Hz */
8855 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8856 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8857 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8858 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8859}
8860
8861static s16 tone_table[][19] =
8862{
8863 { /* f20_50[] 11 */
8864 32538, /* A1 = 1.985962 */
8865 -32325, /* A2 = -0.986511 */
8866 -343, /* B2 = -0.010493 */
8867 0, /* B1 = 0 */
8868 343, /* B0 = 0.010493 */
8869 32619, /* A1 = 1.990906 */
8870 -32520, /* A2 = -0.992462 */
8871 19179, /* B2 = 0.585327 */
8872 -19178, /* B1 = -1.170593 */
8873 19179, /* B0 = 0.585327 */
8874 32723, /* A1 = 1.997314 */
8875 -32686, /* A2 = -0.997528 */
8876 9973, /* B2 = 0.304352 */
8877 -9955, /* B1 = -0.607605 */
8878 9973, /* B0 = 0.304352 */
8879 7, /* Internal filter scaling */
8880 159, /* Minimum in-band energy threshold */
8881 21, /* 21/32 in-band to broad-band ratio */
8882 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8883 },
8884 { /* f133_200[] 12 */
8885 32072, /* A1 = 1.95752 */
8886 -31896, /* A2 = -0.973419 */
8887 -435, /* B2 = -0.013294 */
8888 0, /* B1 = 0 */
8889 435, /* B0 = 0.013294 */
8890 32188, /* A1 = 1.9646 */
8891 -32400, /* A2 = -0.98877 */
8892 15139, /* B2 = 0.462036 */
8893 -14882, /* B1 = -0.908356 */
8894 15139, /* B0 = 0.462036 */
8895 32473, /* A1 = 1.981995 */
8896 -32524, /* A2 = -0.992584 */
8897 23200, /* B2 = 0.708008 */
8898 -23113, /* B1 = -1.410706 */
8899 23200, /* B0 = 0.708008 */
8900 7, /* Internal filter scaling */
8901 159, /* Minimum in-band energy threshold */
8902 21, /* 21/32 in-band to broad-band ratio */
8903 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8904 },
8905 { /* f300 13 */
8906 31769, /* A1 = -1.939026 */
8907 -32584, /* A2 = 0.994385 */
8908 -475, /* B2 = -0.014522 */
8909 0, /* B1 = 0.000000 */
8910 475, /* B0 = 0.014522 */
8911 31789, /* A1 = -1.940247 */
8912 -32679, /* A2 = 0.997284 */
8913 17280, /* B2 = 0.527344 */
8914 -16865, /* B1 = -1.029358 */
8915 17280, /* B0 = 0.527344 */
8916 31841, /* A1 = -1.943481 */
8917 -32681, /* A2 = 0.997345 */
8918 543, /* B2 = 0.016579 */
8919 -525, /* B1 = -0.032097 */
8920 543, /* B0 = 0.016579 */
8921 5, /* Internal filter scaling */
8922 159, /* Minimum in-band energy threshold */
8923 21, /* 21/32 in-band to broad-band ratio */
8924 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8925 },
8926 { /* f300_420[] 14 */
8927 30750, /* A1 = 1.876892 */
8928 -31212, /* A2 = -0.952515 */
8929 -804, /* B2 = -0.024541 */
8930 0, /* B1 = 0 */
8931 804, /* B0 = 0.024541 */
8932 30686, /* A1 = 1.872925 */
8933 -32145, /* A2 = -0.980988 */
8934 14747, /* B2 = 0.450043 */
8935 -13703, /* B1 = -0.836395 */
8936 14747, /* B0 = 0.450043 */
8937 31651, /* A1 = 1.931824 */
8938 -32321, /* A2 = -0.986389 */
8939 24425, /* B2 = 0.745422 */
8940 -23914, /* B1 = -1.459595 */
8941 24427, /* B0 = 0.745483 */
8942 7, /* Internal filter scaling */
8943 159, /* Minimum in-band energy threshold */
8944 21, /* 21/32 in-band to broad-band ratio */
8945 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8946 },
8947 { /* f330 15 */
8948 31613, /* A1 = -1.929565 */
8949 -32646, /* A2 = 0.996277 */
8950 -185, /* B2 = -0.005657 */
8951 0, /* B1 = 0.000000 */
8952 185, /* B0 = 0.005657 */
8953 31620, /* A1 = -1.929932 */
8954 -32713, /* A2 = 0.998352 */
8955 19253, /* B2 = 0.587585 */
8956 -18566, /* B1 = -1.133179 */
8957 19253, /* B0 = 0.587585 */
8958 31674, /* A1 = -1.933228 */
8959 -32715, /* A2 = 0.998413 */
8960 2575, /* B2 = 0.078590 */
8961 -2495, /* B1 = -0.152283 */
8962 2575, /* B0 = 0.078590 */
8963 5, /* Internal filter scaling */
8964 159, /* Minimum in-band energy threshold */
8965 21, /* 21/32 in-band to broad-band ratio */
8966 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8967 },
8968 { /* f300_425[] 16 */
8969 30741, /* A1 = 1.876282 */
8970 -31475, /* A2 = -0.960541 */
8971 -703, /* B2 = -0.021484 */
8972 0, /* B1 = 0 */
8973 703, /* B0 = 0.021484 */
8974 30688, /* A1 = 1.873047 */
8975 -32248, /* A2 = -0.984161 */
8976 14542, /* B2 = 0.443787 */
8977 -13523, /* B1 = -0.825439 */
8978 14542, /* B0 = 0.443817 */
8979 31494, /* A1 = 1.922302 */
8980 -32366, /* A2 = -0.987762 */
8981 21577, /* B2 = 0.658508 */
8982 -21013, /* B1 = -1.282532 */
8983 21577, /* B0 = 0.658508 */
8984 7, /* Internal filter scaling */
8985 159, /* Minimum in-band energy threshold */
8986 21, /* 21/32 in-band to broad-band ratio */
8987 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8988 },
8989 { /* f330_440[] 17 */
8990 30627, /* A1 = 1.869324 */
8991 -31338, /* A2 = -0.95636 */
8992 -843, /* B2 = -0.025749 */
8993 0, /* B1 = 0 */
8994 843, /* B0 = 0.025749 */
8995 30550, /* A1 = 1.864685 */
8996 -32221, /* A2 = -0.983337 */
8997 13594, /* B2 = 0.414886 */
8998 -12589, /* B1 = -0.768402 */
8999 13594, /* B0 = 0.414886 */
9000 31488, /* A1 = 1.921936 */
9001 -32358, /* A2 = -0.987518 */
9002 24684, /* B2 = 0.753296 */
9003 -24029, /* B1 = -1.466614 */
9004 24684, /* B0 = 0.753296 */
9005 7, /* Internal filter scaling */
9006 159, /* Minimum in-band energy threshold */
9007 21, /* 21/32 in-band to broad-band ratio */
9008 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9009 },
9010 { /* f340 18 */
9011 31546, /* A1 = -1.925476 */
9012 -32646, /* A2 = 0.996277 */
9013 -445, /* B2 = -0.013588 */
9014 0, /* B1 = 0.000000 */
9015 445, /* B0 = 0.013588 */
9016 31551, /* A1 = -1.925781 */
9017 -32713, /* A2 = 0.998352 */
9018 23884, /* B2 = 0.728882 */
9019 -22979, /* B1 = -1.402527 */
9020 23884, /* B0 = 0.728882 */
9021 31606, /* A1 = -1.929138 */
9022 -32715, /* A2 = 0.998413 */
9023 863, /* B2 = 0.026367 */
9024 -835, /* B1 = -0.050985 */
9025 863, /* B0 = 0.026367 */
9026 5, /* Internal filter scaling */
9027 159, /* Minimum in-band energy threshold */
9028 21, /* 21/32 in-band to broad-band ratio */
9029 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9030 },
9031 { /* f350_400[] 19 */
9032 31006, /* A1 = 1.892517 */
9033 -32029, /* A2 = -0.977448 */
9034 -461, /* B2 = -0.014096 */
9035 0, /* B1 = 0 */
9036 461, /* B0 = 0.014096 */
9037 30999, /* A1 = 1.892029 */
9038 -32487, /* A2 = -0.991455 */
9039 11325, /* B2 = 0.345612 */
9040 -10682, /* B1 = -0.651978 */
9041 11325, /* B0 = 0.345612 */
9042 31441, /* A1 = 1.919067 */
9043 -32526, /* A2 = -0.992615 */
9044 24324, /* B2 = 0.74231 */
9045 -23535, /* B1 = -1.436523 */
9046 24324, /* B0 = 0.74231 */
9047 7, /* Internal filter scaling */
9048 159, /* Minimum in-band energy threshold */
9049 21, /* 21/32 in-band to broad-band ratio */
9050 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9051 },
9052 { /* f350_440[] */
9053 30634, /* A1 = 1.869751 */
9054 -31533, /* A2 = -0.962341 */
9055 -680, /* B2 = -0.020782 */
9056 0, /* B1 = 0 */
9057 680, /* B0 = 0.020782 */
9058 30571, /* A1 = 1.865906 */
9059 -32277, /* A2 = -0.985016 */
9060 12894, /* B2 = 0.393524 */
9061 -11945, /* B1 = -0.729065 */
9062 12894, /* B0 = 0.393524 */
9063 31367, /* A1 = 1.91449 */
9064 -32379, /* A2 = -0.988129 */
9065 23820, /* B2 = 0.726929 */
9066 -23104, /* B1 = -1.410217 */
9067 23820, /* B0 = 0.726929 */
9068 7, /* Internal filter scaling */
9069 159, /* Minimum in-band energy threshold */
9070 21, /* 21/32 in-band to broad-band ratio */
9071 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9072 },
9073 { /* f350_450[] */
9074 30552, /* A1 = 1.864807 */
9075 -31434, /* A2 = -0.95929 */
9076 -690, /* B2 = -0.021066 */
9077 0, /* B1 = 0 */
9078 690, /* B0 = 0.021066 */
9079 30472, /* A1 = 1.859924 */
9080 -32248, /* A2 = -0.984161 */
9081 13385, /* B2 = 0.408478 */
9082 -12357, /* B1 = -0.754242 */
9083 13385, /* B0 = 0.408478 */
9084 31358, /* A1 = 1.914001 */
9085 -32366, /* A2 = -0.987732 */
9086 26488, /* B2 = 0.80835 */
9087 -25692, /* B1 = -1.568176 */
9088 26490, /* B0 = 0.808411 */
9089 7, /* Internal filter scaling */
9090 159, /* Minimum in-band energy threshold */
9091 21, /* 21/32 in-band to broad-band ratio */
9092 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9093 },
9094 { /* f360 */
9095 31397, /* A1 = -1.916321 */
9096 -32623, /* A2 = 0.995605 */
9097 -117, /* B2 = -0.003598 */
9098 0, /* B1 = 0.000000 */
9099 117, /* B0 = 0.003598 */
9100 31403, /* A1 = -1.916687 */
9101 -32700, /* A2 = 0.997925 */
9102 3388, /* B2 = 0.103401 */
9103 -3240, /* B1 = -0.197784 */
9104 3388, /* B0 = 0.103401 */
9105 31463, /* A1 = -1.920410 */
9106 -32702, /* A2 = 0.997986 */
9107 13346, /* B2 = 0.407288 */
9108 -12863, /* B1 = -0.785126 */
9109 13346, /* B0 = 0.407288 */
9110 5, /* Internal filter scaling */
9111 159, /* Minimum in-band energy threshold */
9112 21, /* 21/32 in-band to broad-band ratio */
9113 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9114 },
9115 { /* f380_420[] */
9116 30831, /* A1 = 1.881775 */
9117 -32064, /* A2 = -0.978546 */
9118 -367, /* B2 = -0.01122 */
9119 0, /* B1 = 0 */
9120 367, /* B0 = 0.01122 */
9121 30813, /* A1 = 1.880737 */
9122 -32456, /* A2 = -0.990509 */
9123 11068, /* B2 = 0.337769 */
9124 -10338, /* B1 = -0.631042 */
9125 11068, /* B0 = 0.337769 */
9126 31214, /* A1 = 1.905212 */
9127 -32491, /* A2 = -0.991577 */
9128 16374, /* B2 = 0.499695 */
9129 -15781, /* B1 = -0.963196 */
9130 16374, /* B0 = 0.499695 */
9131 7, /* Internal filter scaling */
9132 159, /* Minimum in-band energy threshold */
9133 21, /* 21/32 in-band to broad-band ratio */
9134 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9135 },
9136 { /* f392 */
9137 31152, /* A1 = -1.901428 */
9138 -32613, /* A2 = 0.995300 */
9139 -314, /* B2 = -0.009605 */
9140 0, /* B1 = 0.000000 */
9141 314, /* B0 = 0.009605 */
9142 31156, /* A1 = -1.901672 */
9143 -32694, /* A2 = 0.997742 */
9144 28847, /* B2 = 0.880371 */
9145 -2734, /* B1 = -0.166901 */
9146 28847, /* B0 = 0.880371 */
9147 31225, /* A1 = -1.905823 */
9148 -32696, /* A2 = 0.997803 */
9149 462, /* B2 = 0.014108 */
9150 -442, /* B1 = -0.027019 */
9151 462, /* B0 = 0.014108 */
9152 5, /* Internal filter scaling */
9153 159, /* Minimum in-band energy threshold */
9154 21, /* 21/32 in-band to broad-band ratio */
9155 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9156 },
9157 { /* f400_425[] */
9158 30836, /* A1 = 1.882141 */
9159 -32296, /* A2 = -0.985596 */
9160 -324, /* B2 = -0.009903 */
9161 0, /* B1 = 0 */
9162 324, /* B0 = 0.009903 */
9163 30825, /* A1 = 1.881409 */
9164 -32570, /* A2 = -0.993958 */
9165 16847, /* B2 = 0.51416 */
9166 -15792, /* B1 = -0.963898 */
9167 16847, /* B0 = 0.51416 */
9168 31106, /* A1 = 1.89856 */
9169 -32584, /* A2 = -0.994415 */
9170 9579, /* B2 = 0.292328 */
9171 -9164, /* B1 = -0.559357 */
9172 9579, /* B0 = 0.292328 */
9173 7, /* Internal filter scaling */
9174 159, /* Minimum in-band energy threshold */
9175 21, /* 21/32 in-band to broad-band ratio */
9176 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9177 },
9178 { /* f400_440[] */
9179 30702, /* A1 = 1.873962 */
9180 -32134, /* A2 = -0.980682 */
9181 -517, /* B2 = -0.015793 */
9182 0, /* B1 = 0 */
9183 517, /* B0 = 0.015793 */
9184 30676, /* A1 = 1.872375 */
9185 -32520, /* A2 = -0.992462 */
9186 8144, /* B2 = 0.24855 */
9187 -7596, /* B1 = -0.463684 */
9188 8144, /* B0 = 0.24855 */
9189 31084, /* A1 = 1.897217 */
9190 -32547, /* A2 = -0.993256 */
9191 22713, /* B2 = 0.693176 */
9192 -21734, /* B1 = -1.326599 */
9193 22713, /* B0 = 0.693176 */
9194 7, /* Internal filter scaling */
9195 159, /* Minimum in-band energy threshold */
9196 21, /* 21/32 in-band to broad-band ratio */
9197 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9198 },
9199 { /* f400_450[] */
9200 30613, /* A1 = 1.86853 */
9201 -32031, /* A2 = -0.977509 */
9202 -618, /* B2 = -0.018866 */
9203 0, /* B1 = 0 */
9204 618, /* B0 = 0.018866 */
9205 30577, /* A1 = 1.866272 */
9206 -32491, /* A2 = -0.991577 */
9207 9612, /* B2 = 0.293335 */
9208 -8935, /* B1 = -0.54541 */
9209 9612, /* B0 = 0.293335 */
9210 31071, /* A1 = 1.896484 */
9211 -32524, /* A2 = -0.992584 */
9212 21596, /* B2 = 0.659058 */
9213 -20667, /* B1 = -1.261414 */
9214 21596, /* B0 = 0.659058 */
9215 7, /* Internal filter scaling */
9216 159, /* Minimum in-band energy threshold */
9217 21, /* 21/32 in-band to broad-band ratio */
9218 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9219 },
9220 { /* f420 */
9221 30914, /* A1 = -1.886841 */
9222 -32584, /* A2 = 0.994385 */
9223 -426, /* B2 = -0.013020 */
9224 0, /* B1 = 0.000000 */
9225 426, /* B0 = 0.013020 */
9226 30914, /* A1 = -1.886841 */
9227 -32679, /* A2 = 0.997314 */
9228 17520, /* B2 = 0.534668 */
9229 -16471, /* B1 = -1.005310 */
9230 17520, /* B0 = 0.534668 */
9231 31004, /* A1 = -1.892334 */
9232 -32683, /* A2 = 0.997406 */
9233 819, /* B2 = 0.025023 */
9234 -780, /* B1 = -0.047619 */
9235 819, /* B0 = 0.025023 */
9236 5, /* Internal filter scaling */
9237 159, /* Minimum in-band energy threshold */
9238 21, /* 21/32 in-band to broad-band ratio */
9239 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9240 },
9241#if 0
9242 { /* f425 */
9243 30881, /* A1 = -1.884827 */
9244 -32603, /* A2 = 0.994965 */
9245 -496, /* B2 = -0.015144 */
9246 0, /* B1 = 0.000000 */
9247 496, /* B0 = 0.015144 */
9248 30880, /* A1 = -1.884766 */
9249 -32692, /* A2 = 0.997711 */
9250 24767, /* B2 = 0.755859 */
9251 -23290, /* B1 = -1.421509 */
9252 24767, /* B0 = 0.755859 */
9253 30967, /* A1 = -1.890076 */
9254 -32694, /* A2 = 0.997772 */
9255 728, /* B2 = 0.022232 */
9256 -691, /* B1 = -0.042194 */
9257 728, /* B0 = 0.022232 */
9258 5, /* Internal filter scaling */
9259 159, /* Minimum in-band energy threshold */
9260 21, /* 21/32 in-band to broad-band ratio */
9261 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9262 },
9263#else
9264 {
9265 30850,
9266 -32534,
9267 -504,
9268 0,
9269 504,
9270 30831,
9271 -32669,
9272 24303,
9273 -22080,
9274 24303,
9275 30994,
9276 -32673,
9277 1905,
9278 -1811,
9279 1905,
9280 5,
9281 129,
9282 17,
9283 0xff5
9284 },
9285#endif
9286 { /* f425_450[] */
9287 30646, /* A1 = 1.870544 */
9288 -32327, /* A2 = -0.986572 */
9289 -287, /* B2 = -0.008769 */
9290 0, /* B1 = 0 */
9291 287, /* B0 = 0.008769 */
9292 30627, /* A1 = 1.869324 */
9293 -32607, /* A2 = -0.995087 */
9294 13269, /* B2 = 0.404968 */
9295 -12376, /* B1 = -0.755432 */
9296 13269, /* B0 = 0.404968 */
9297 30924, /* A1 = 1.887512 */
9298 -32619, /* A2 = -0.995453 */
9299 19950, /* B2 = 0.608826 */
9300 -18940, /* B1 = -1.156006 */
9301 19950, /* B0 = 0.608826 */
9302 7, /* Internal filter scaling */
9303 159, /* Minimum in-band energy threshold */
9304 21, /* 21/32 in-band to broad-band ratio */
9305 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9306 },
9307 { /* f425_475[] */
9308 30396, /* A1 = 1.855225 */
9309 -32014, /* A2 = -0.97699 */
9310 -395, /* B2 = -0.012055 */
9311 0, /* B1 = 0 */
9312 395, /* B0 = 0.012055 */
9313 30343, /* A1 = 1.85199 */
9314 -32482, /* A2 = -0.991302 */
9315 17823, /* B2 = 0.543945 */
9316 -16431, /* B1 = -1.002869 */
9317 17823, /* B0 = 0.543945 */
9318 30872, /* A1 = 1.884338 */
9319 -32516, /* A2 = -0.99231 */
9320 18124, /* B2 = 0.553101 */
9321 -17246, /* B1 = -1.052673 */
9322 18124, /* B0 = 0.553101 */
9323 7, /* Internal filter scaling */
9324 159, /* Minimum in-band energy threshold */
9325 21, /* 21/32 in-band to broad-band ratio */
9326 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9327 },
9328 { /* f435 */
9329 30796, /* A1 = -1.879639 */
9330 -32603, /* A2 = 0.994965 */
9331 -254, /* B2 = -0.007762 */
9332 0, /* B1 = 0.000000 */
9333 254, /* B0 = 0.007762 */
9334 30793, /* A1 = -1.879456 */
9335 -32692, /* A2 = 0.997711 */
9336 18934, /* B2 = 0.577820 */
9337 -17751, /* B1 = -1.083496 */
9338 18934, /* B0 = 0.577820 */
9339 30882, /* A1 = -1.884888 */
9340 -32694, /* A2 = 0.997772 */
9341 1858, /* B2 = 0.056713 */
9342 -1758, /* B1 = -0.107357 */
9343 1858, /* B0 = 0.056713 */
9344 5, /* Internal filter scaling */
9345 159, /* Minimum in-band energy threshold */
9346 21, /* 21/32 in-band to broad-band ratio */
9347 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9348 },
9349 { /* f440_450[] */
9350 30641, /* A1 = 1.870239 */
9351 -32458, /* A2 = -0.99057 */
9352 -155, /* B2 = -0.004735 */
9353 0, /* B1 = 0 */
9354 155, /* B0 = 0.004735 */
9355 30631, /* A1 = 1.869568 */
9356 -32630, /* A2 = -0.995789 */
9357 11453, /* B2 = 0.349548 */
9358 -10666, /* B1 = -0.651001 */
9359 11453, /* B0 = 0.349548 */
9360 30810, /* A1 = 1.880554 */
9361 -32634, /* A2 = -0.995941 */
9362 12237, /* B2 = 0.373474 */
9363 -11588, /* B1 = -0.707336 */
9364 12237, /* B0 = 0.373474 */
9365 7, /* Internal filter scaling */
9366 159, /* Minimum in-band energy threshold */
9367 21, /* 21/32 in-band to broad-band ratio */
9368 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9369 },
9370 { /* f440_480[] */
9371 30367, /* A1 = 1.853455 */
9372 -32147, /* A2 = -0.981079 */
9373 -495, /* B2 = -0.015113 */
9374 0, /* B1 = 0 */
9375 495, /* B0 = 0.015113 */
9376 30322, /* A1 = 1.850769 */
9377 -32543, /* A2 = -0.993134 */
9378 10031, /* B2 = 0.306152 */
9379 -9252, /* B1 = -0.564728 */
9380 10031, /* B0 = 0.306152 */
9381 30770, /* A1 = 1.878052 */
9382 -32563, /* A2 = -0.993774 */
9383 22674, /* B2 = 0.691956 */
9384 -21465, /* B1 = -1.31012 */
9385 22674, /* B0 = 0.691956 */
9386 7, /* Internal filter scaling */
9387 159, /* Minimum in-band energy threshold */
9388 21, /* 21/32 in-band to broad-band ratio */
9389 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9390 },
9391 { /* f445 */
9392 30709, /* A1 = -1.874329 */
9393 -32603, /* A2 = 0.994965 */
9394 -83, /* B2 = -0.002545 */
9395 0, /* B1 = 0.000000 */
9396 83, /* B0 = 0.002545 */
9397 30704, /* A1 = -1.874084 */
9398 -32692, /* A2 = 0.997711 */
9399 10641, /* B2 = 0.324738 */
9400 -9947, /* B1 = -0.607147 */
9401 10641, /* B0 = 0.324738 */
9402 30796, /* A1 = -1.879639 */
9403 -32694, /* A2 = 0.997772 */
9404 10079, /* B2 = 0.307587 */
9405 9513, /* B1 = 0.580688 */
9406 10079, /* B0 = 0.307587 */
9407 5, /* Internal filter scaling */
9408 159, /* Minimum in-band energy threshold */
9409 21, /* 21/32 in-band to broad-band ratio */
9410 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9411 },
9412 { /* f450 */
9413 30664, /* A1 = -1.871643 */
9414 -32603, /* A2 = 0.994965 */
9415 -164, /* B2 = -0.005029 */
9416 0, /* B1 = 0.000000 */
9417 164, /* B0 = 0.005029 */
9418 30661, /* A1 = -1.871399 */
9419 -32692, /* A2 = 0.997711 */
9420 15294, /* B2 = 0.466736 */
9421 -14275, /* B1 = -0.871307 */
9422 15294, /* B0 = 0.466736 */
9423 30751, /* A1 = -1.876953 */
9424 -32694, /* A2 = 0.997772 */
9425 3548, /* B2 = 0.108284 */
9426 -3344, /* B1 = -0.204155 */
9427 3548, /* B0 = 0.108284 */
9428 5, /* Internal filter scaling */
9429 159, /* Minimum in-band energy threshold */
9430 21, /* 21/32 in-band to broad-band ratio */
9431 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9432 },
9433 { /* f452 */
9434 30653, /* A1 = -1.870911 */
9435 -32615, /* A2 = 0.995361 */
9436 -209, /* B2 = -0.006382 */
9437 0, /* B1 = 0.000000 */
9438 209, /* B0 = 0.006382 */
9439 30647, /* A1 = -1.870605 */
9440 -32702, /* A2 = 0.997986 */
9441 18971, /* B2 = 0.578979 */
9442 -17716, /* B1 = -1.081299 */
9443 18971, /* B0 = 0.578979 */
9444 30738, /* A1 = -1.876099 */
9445 -32702, /* A2 = 0.998016 */
9446 2967, /* B2 = 0.090561 */
9447 -2793, /* B1 = -0.170502 */
9448 2967, /* B0 = 0.090561 */
9449 5, /* Internal filter scaling */
9450 159, /* Minimum in-band energy threshold */
9451 21, /* 21/32 in-band to broad-band ratio */
9452 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9453 },
9454 { /* f475 */
9455 30437, /* A1 = -1.857727 */
9456 -32603, /* A2 = 0.994965 */
9457 -264, /* B2 = -0.008062 */
9458 0, /* B1 = 0.000000 */
9459 264, /* B0 = 0.008062 */
9460 30430, /* A1 = -1.857300 */
9461 -32692, /* A2 = 0.997711 */
9462 21681, /* B2 = 0.661682 */
9463 -20082, /* B1 = -1.225708 */
9464 21681, /* B0 = 0.661682 */
9465 30526, /* A1 = -1.863220 */
9466 -32694, /* A2 = 0.997742 */
9467 1559, /* B2 = 0.047600 */
9468 -1459, /* B1 = -0.089096 */
9469 1559, /* B0 = 0.047600 */
9470 5, /* Internal filter scaling */
9471 159, /* Minimum in-band energy threshold */
9472 21, /* 21/32 in-band to broad-band ratio */
9473 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9474 },
9475 { /* f480_620[] */
9476 28975, /* A1 = 1.768494 */
9477 -30955, /* A2 = -0.944672 */
9478 -1026, /* B2 = -0.03133 */
9479 0, /* B1 = 0 */
9480 1026, /* B0 = 0.03133 */
9481 28613, /* A1 = 1.746399 */
9482 -32089, /* A2 = -0.979309 */
9483 14214, /* B2 = 0.433807 */
9484 -12202, /* B1 = -0.744812 */
9485 14214, /* B0 = 0.433807 */
9486 30243, /* A1 = 1.845947 */
9487 -32238, /* A2 = -0.983856 */
9488 24825, /* B2 = 0.757629 */
9489 -23402, /* B1 = -1.428345 */
9490 24825, /* B0 = 0.757629 */
9491 7, /* Internal filter scaling */
9492 159, /* Minimum in-band energy threshold */
9493 21, /* 21/32 in-band to broad-band ratio */
9494 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9495 },
9496 { /* f494 */
9497 30257, /* A1 = -1.846741 */
9498 -32605, /* A2 = 0.995056 */
9499 -249, /* B2 = -0.007625 */
9500 0, /* B1 = 0.000000 */
9501 249, /* B0 = 0.007625 */
9502 30247, /* A1 = -1.846191 */
9503 -32694, /* A2 = 0.997772 */
9504 18088, /* B2 = 0.552002 */
9505 -16652, /* B1 = -1.016418 */
9506 18088, /* B0 = 0.552002 */
9507 30348, /* A1 = -1.852295 */
9508 -32696, /* A2 = 0.997803 */
9509 2099, /* B2 = 0.064064 */
9510 -1953, /* B1 = -0.119202 */
9511 2099, /* B0 = 0.064064 */
9512 5, /* Internal filter scaling */
9513 159, /* Minimum in-band energy threshold */
9514 21, /* 21/32 in-band to broad-band ratio */
9515 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9516 },
9517 { /* f500 */
9518 30202, /* A1 = -1.843431 */
9519 -32624, /* A2 = 0.995622 */
9520 -413, /* B2 = -0.012622 */
9521 0, /* B1 = 0.000000 */
9522 413, /* B0 = 0.012622 */
9523 30191, /* A1 = -1.842721 */
9524 -32714, /* A2 = 0.998364 */
9525 25954, /* B2 = 0.792057 */
9526 -23890, /* B1 = -1.458131 */
9527 25954, /* B0 = 0.792057 */
9528 30296, /* A1 = -1.849172 */
9529 -32715, /* A2 = 0.998397 */
9530 2007, /* B2 = 0.061264 */
9531 -1860, /* B1 = -0.113568 */
9532 2007, /* B0 = 0.061264 */
9533 5, /* Internal filter scaling */
9534 159, /* Minimum in-band energy threshold */
9535 21, /* 21/32 in-band to broad-band ratio */
9536 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9537 },
9538 { /* f520 */
9539 30001, /* A1 = -1.831116 */
9540 -32613, /* A2 = 0.995270 */
9541 -155, /* B2 = -0.004750 */
9542 0, /* B1 = 0.000000 */
9543 155, /* B0 = 0.004750 */
9544 29985, /* A1 = -1.830200 */
9545 -32710, /* A2 = 0.998260 */
9546 6584, /* B2 = 0.200928 */
9547 -6018, /* B1 = -0.367355 */
9548 6584, /* B0 = 0.200928 */
9549 30105, /* A1 = -1.837524 */
9550 -32712, /* A2 = 0.998291 */
9551 23812, /* B2 = 0.726685 */
9552 -21936, /* B1 = -1.338928 */
9553 23812, /* B0 = 0.726685 */
9554 5, /* Internal filter scaling */
9555 159, /* Minimum in-band energy threshold */
9556 21, /* 21/32 in-band to broad-band ratio */
9557 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9558 },
9559 { /* f523 */
9560 29964, /* A1 = -1.828918 */
9561 -32601, /* A2 = 0.994904 */
9562 -101, /* B2 = -0.003110 */
9563 0, /* B1 = 0.000000 */
9564 101, /* B0 = 0.003110 */
9565 29949, /* A1 = -1.827942 */
9566 -32700, /* A2 = 0.997925 */
9567 11041, /* B2 = 0.336975 */
9568 -10075, /* B1 = -0.614960 */
9569 11041, /* B0 = 0.336975 */
9570 30070, /* A1 = -1.835388 */
9571 -32702, /* A2 = 0.997986 */
9572 16762, /* B2 = 0.511536 */
9573 -15437, /* B1 = -0.942230 */
9574 16762, /* B0 = 0.511536 */
9575 5, /* Internal filter scaling */
9576 159, /* Minimum in-band energy threshold */
9577 21, /* 21/32 in-band to broad-band ratio */
9578 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9579 },
9580 { /* f525 */
9581 29936, /* A1 = -1.827209 */
9582 -32584, /* A2 = 0.994415 */
9583 -91, /* B2 = -0.002806 */
9584 0, /* B1 = 0.000000 */
9585 91, /* B0 = 0.002806 */
9586 29921, /* A1 = -1.826233 */
9587 -32688, /* A2 = 0.997559 */
9588 11449, /* B2 = 0.349396 */
9589 -10426, /* B1 = -0.636383 */
9590 11449, /* B0 = 0.349396 */
9591 30045, /* A1 = -1.833862 */
9592 -32688, /* A2 = 0.997589 */
9593 13055, /* B2 = 0.398407 */
9594 -12028, /* B1 = -0.734161 */
9595 13055, /* B0 = 0.398407 */
9596 5, /* Internal filter scaling */
9597 159, /* Minimum in-band energy threshold */
9598 21, /* 21/32 in-band to broad-band ratio */
9599 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9600 },
9601 { /* f540_660[] */
9602 28499, /* A1 = 1.739441 */
9603 -31129, /* A2 = -0.949982 */
9604 -849, /* B2 = -0.025922 */
9605 0, /* B1 = 0 */
9606 849, /* B0 = 0.025922 */
9607 28128, /* A1 = 1.716797 */
9608 -32130, /* A2 = -0.98056 */
9609 14556, /* B2 = 0.444214 */
9610 -12251, /* B1 = -0.747772 */
9611 14556, /* B0 = 0.444244 */
9612 29667, /* A1 = 1.81073 */
9613 -32244, /* A2 = -0.984039 */
9614 23038, /* B2 = 0.703064 */
9615 -21358, /* B1 = -1.303589 */
9616 23040, /* B0 = 0.703125 */
9617 7, /* Internal filter scaling */
9618 159, /* Minimum in-band energy threshold */
9619 21, /* 21/32 in-band to broad-band ratio */
9620 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9621 },
9622 { /* f587 */
9623 29271, /* A1 = -1.786560 */
9624 -32599, /* A2 = 0.994873 */
9625 -490, /* B2 = -0.014957 */
9626 0, /* B1 = 0.000000 */
9627 490, /* B0 = 0.014957 */
9628 29246, /* A1 = -1.785095 */
9629 -32700, /* A2 = 0.997925 */
9630 28961, /* B2 = 0.883850 */
9631 -25796, /* B1 = -1.574463 */
9632 28961, /* B0 = 0.883850 */
9633 29383, /* A1 = -1.793396 */
9634 -32700, /* A2 = 0.997955 */
9635 1299, /* B2 = 0.039650 */
9636 -1169, /* B1 = -0.071396 */
9637 1299, /* B0 = 0.039650 */
9638 5, /* Internal filter scaling */
9639 159, /* Minimum in-band energy threshold */
9640 21, /* 21/32 in-band to broad-band ratio */
9641 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9642 },
9643 { /* f590 */
9644 29230, /* A1 = -1.784058 */
9645 -32584, /* A2 = 0.994415 */
9646 -418, /* B2 = -0.012757 */
9647 0, /* B1 = 0.000000 */
9648 418, /* B0 = 0.012757 */
9649 29206, /* A1 = -1.782593 */
9650 -32688, /* A2 = 0.997559 */
9651 36556, /* B2 = 1.115601 */
9652 -32478, /* B1 = -1.982300 */
9653 36556, /* B0 = 1.115601 */
9654 29345, /* A1 = -1.791077 */
9655 -32688, /* A2 = 0.997589 */
9656 897, /* B2 = 0.027397 */
9657 -808, /* B1 = -0.049334 */
9658 897, /* B0 = 0.027397 */
9659 5, /* Internal filter scaling */
9660 159, /* Minimum in-band energy threshold */
9661 21, /* 21/32 in-band to broad-band ratio */
9662 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9663 },
9664 { /* f600 */
9665 29116, /* A1 = -1.777100 */
9666 -32603, /* A2 = 0.994965 */
9667 -165, /* B2 = -0.005039 */
9668 0, /* B1 = 0.000000 */
9669 165, /* B0 = 0.005039 */
9670 29089, /* A1 = -1.775452 */
9671 -32708, /* A2 = 0.998199 */
9672 6963, /* B2 = 0.212494 */
9673 -6172, /* B1 = -0.376770 */
9674 6963, /* B0 = 0.212494 */
9675 29237, /* A1 = -1.784485 */
9676 -32710, /* A2 = 0.998230 */
9677 24197, /* B2 = 0.738464 */
9678 -21657, /* B1 = -1.321899 */
9679 24197, /* B0 = 0.738464 */
9680 5, /* Internal filter scaling */
9681 159, /* Minimum in-band energy threshold */
9682 21, /* 21/32 in-band to broad-band ratio */
9683 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9684 },
9685 { /* f660 */
9686 28376, /* A1 = -1.731934 */
9687 -32567, /* A2 = 0.993896 */
9688 -363, /* B2 = -0.011102 */
9689 0, /* B1 = 0.000000 */
9690 363, /* B0 = 0.011102 */
9691 28337, /* A1 = -1.729614 */
9692 -32683, /* A2 = 0.997434 */
9693 21766, /* B2 = 0.664246 */
9694 -18761, /* B1 = -1.145081 */
9695 21766, /* B0 = 0.664246 */
9696 28513, /* A1 = -1.740356 */
9697 -32686, /* A2 = 0.997498 */
9698 2509, /* B2 = 0.076584 */
9699 -2196, /* B1 = -0.134041 */
9700 2509, /* B0 = 0.076584 */
9701 5, /* Internal filter scaling */
9702 159, /* Minimum in-band energy threshold */
9703 21, /* 21/32 in-band to broad-band ratio */
9704 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9705 },
9706 { /* f700 */
9707 27844, /* A1 = -1.699463 */
9708 -32563, /* A2 = 0.993744 */
9709 -366, /* B2 = -0.011187 */
9710 0, /* B1 = 0.000000 */
9711 366, /* B0 = 0.011187 */
9712 27797, /* A1 = -1.696655 */
9713 -32686, /* A2 = 0.997498 */
9714 22748, /* B2 = 0.694214 */
9715 -19235, /* B1 = -1.174072 */
9716 22748, /* B0 = 0.694214 */
9717 27995, /* A1 = -1.708740 */
9718 -32688, /* A2 = 0.997559 */
9719 2964, /* B2 = 0.090477 */
9720 -2546, /* B1 = -0.155449 */
9721 2964, /* B0 = 0.090477 */
9722 5, /* Internal filter scaling */
9723 159, /* Minimum in-band energy threshold */
9724 21, /* 21/32 in-band to broad-band ratio */
9725 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9726 },
9727 { /* f740 */
9728 27297, /* A1 = -1.666077 */
9729 -32551, /* A2 = 0.993408 */
9730 -345, /* B2 = -0.010540 */
9731 0, /* B1 = 0.000000 */
9732 345, /* B0 = 0.010540 */
9733 27240, /* A1 = -1.662598 */
9734 -32683, /* A2 = 0.997406 */
9735 22560, /* B2 = 0.688477 */
9736 -18688, /* B1 = -1.140625 */
9737 22560, /* B0 = 0.688477 */
9738 27461, /* A1 = -1.676147 */
9739 -32684, /* A2 = 0.997467 */
9740 3541, /* B2 = 0.108086 */
9741 -2985, /* B1 = -0.182220 */
9742 3541, /* B0 = 0.108086 */
9743 5, /* Internal filter scaling */
9744 159, /* Minimum in-band energy threshold */
9745 21, /* 21/32 in-band to broad-band ratio */
9746 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9747 },
9748 { /* f750 */
9749 27155, /* A1 = -1.657410 */
9750 -32551, /* A2 = 0.993408 */
9751 -462, /* B2 = -0.014117 */
9752 0, /* B1 = 0.000000 */
9753 462, /* B0 = 0.014117 */
9754 27097, /* A1 = -1.653870 */
9755 -32683, /* A2 = 0.997406 */
9756 32495, /* B2 = 0.991699 */
9757 -26776, /* B1 = -1.634338 */
9758 32495, /* B0 = 0.991699 */
9759 27321, /* A1 = -1.667542 */
9760 -32684, /* A2 = 0.997467 */
9761 1835, /* B2 = 0.056007 */
9762 -1539, /* B1 = -0.093948 */
9763 1835, /* B0 = 0.056007 */
9764 5, /* Internal filter scaling */
9765 159, /* Minimum in-band energy threshold */
9766 21, /* 21/32 in-band to broad-band ratio */
9767 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9768 },
9769 { /* f750_1450[] */
9770 19298, /* A1 = 1.177917 */
9771 -24471, /* A2 = -0.746796 */
9772 -4152, /* B2 = -0.126709 */
9773 0, /* B1 = 0 */
9774 4152, /* B0 = 0.126709 */
9775 12902, /* A1 = 0.787476 */
9776 -29091, /* A2 = -0.887817 */
9777 12491, /* B2 = 0.38121 */
9778 -1794, /* B1 = -0.109528 */
9779 12494, /* B0 = 0.381317 */
9780 26291, /* A1 = 1.604736 */
9781 -30470, /* A2 = -0.929901 */
9782 28859, /* B2 = 0.880737 */
9783 -26084, /* B1 = -1.592102 */
9784 28861, /* B0 = 0.880798 */
9785 7, /* Internal filter scaling */
9786 159, /* Minimum in-band energy threshold */
9787 21, /* 21/32 in-band to broad-band ratio */
9788 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9789 },
9790 { /* f770 */
9791 26867, /* A1 = -1.639832 */
9792 -32551, /* A2 = 0.993408 */
9793 -123, /* B2 = -0.003755 */
9794 0, /* B1 = 0.000000 */
9795 123, /* B0 = 0.003755 */
9796 26805, /* A1 = -1.636108 */
9797 -32683, /* A2 = 0.997406 */
9798 17297, /* B2 = 0.527863 */
9799 -14096, /* B1 = -0.860382 */
9800 17297, /* B0 = 0.527863 */
9801 27034, /* A1 = -1.650085 */
9802 -32684, /* A2 = 0.997467 */
9803 12958, /* B2 = 0.395477 */
9804 -10756, /* B1 = -0.656525 */
9805 12958, /* B0 = 0.395477 */
9806 5, /* Internal filter scaling */
9807 159, /* Minimum in-band energy threshold */
9808 21, /* 21/32 in-band to broad-band ratio */
9809 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9810 },
9811 { /* f800 */
9812 26413, /* A1 = -1.612122 */
9813 -32547, /* A2 = 0.993286 */
9814 -223, /* B2 = -0.006825 */
9815 0, /* B1 = 0.000000 */
9816 223, /* B0 = 0.006825 */
9817 26342, /* A1 = -1.607849 */
9818 -32686, /* A2 = 0.997498 */
9819 6391, /* B2 = 0.195053 */
9820 -5120, /* B1 = -0.312531 */
9821 6391, /* B0 = 0.195053 */
9822 26593, /* A1 = -1.623108 */
9823 -32688, /* A2 = 0.997559 */
9824 23681, /* B2 = 0.722717 */
9825 -19328, /* B1 = -1.179688 */
9826 23681, /* B0 = 0.722717 */
9827 5, /* Internal filter scaling */
9828 159, /* Minimum in-band energy threshold */
9829 21, /* 21/32 in-band to broad-band ratio */
9830 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9831 },
9832 { /* f816 */
9833 26168, /* A1 = -1.597209 */
9834 -32528, /* A2 = 0.992706 */
9835 -235, /* B2 = -0.007182 */
9836 0, /* B1 = 0.000000 */
9837 235, /* B0 = 0.007182 */
9838 26092, /* A1 = -1.592590 */
9839 -32675, /* A2 = 0.997192 */
9840 20823, /* B2 = 0.635498 */
9841 -16510, /* B1 = -1.007751 */
9842 20823, /* B0 = 0.635498 */
9843 26363, /* A1 = -1.609070 */
9844 -32677, /* A2 = 0.997253 */
9845 6739, /* B2 = 0.205688 */
9846 -5459, /* B1 = -0.333206 */
9847 6739, /* B0 = 0.205688 */
9848 5, /* Internal filter scaling */
9849 159, /* Minimum in-band energy threshold */
9850 21, /* 21/32 in-band to broad-band ratio */
9851 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9852 },
9853 { /* f850 */
9854 25641, /* A1 = -1.565063 */
9855 -32536, /* A2 = 0.992950 */
9856 -121, /* B2 = -0.003707 */
9857 0, /* B1 = 0.000000 */
9858 121, /* B0 = 0.003707 */
9859 25560, /* A1 = -1.560059 */
9860 -32684, /* A2 = 0.997437 */
9861 18341, /* B2 = 0.559753 */
9862 -14252, /* B1 = -0.869904 */
9863 18341, /* B0 = 0.559753 */
9864 25837, /* A1 = -1.577026 */
9865 -32684, /* A2 = 0.997467 */
9866 16679, /* B2 = 0.509003 */
9867 -13232, /* B1 = -0.807648 */
9868 16679, /* B0 = 0.509003 */
9869 5, /* Internal filter scaling */
9870 159, /* Minimum in-band energy threshold */
9871 21, /* 21/32 in-band to broad-band ratio */
9872 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9873 },
9874 { /* f857_1645[] */
9875 16415, /* A1 = 1.001953 */
9876 -23669, /* A2 = -0.722321 */
9877 -4549, /* B2 = -0.138847 */
9878 0, /* B1 = 0 */
9879 4549, /* B0 = 0.138847 */
9880 8456, /* A1 = 0.516174 */
9881 -28996, /* A2 = -0.884918 */
9882 13753, /* B2 = 0.419724 */
9883 -12, /* B1 = -0.000763 */
9884 13757, /* B0 = 0.419846 */
9885 24632, /* A1 = 1.503418 */
9886 -30271, /* A2 = -0.923828 */
9887 29070, /* B2 = 0.887146 */
9888 -25265, /* B1 = -1.542114 */
9889 29073, /* B0 = 0.887268 */
9890 7, /* Internal filter scaling */
9891 159, /* Minimum in-band energy threshold */
9892 21, /* 21/32 in-band to broad-band ratio */
9893 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9894 },
9895 { /* f900 */
9896 24806, /* A1 = -1.514099 */
9897 -32501, /* A2 = 0.991852 */
9898 -326, /* B2 = -0.009969 */
9899 0, /* B1 = 0.000000 */
9900 326, /* B0 = 0.009969 */
9901 24709, /* A1 = -1.508118 */
9902 -32659, /* A2 = 0.996674 */
9903 20277, /* B2 = 0.618835 */
9904 -15182, /* B1 = -0.926636 */
9905 20277, /* B0 = 0.618835 */
9906 25022, /* A1 = -1.527222 */
9907 -32661, /* A2 = 0.996735 */
9908 4320, /* B2 = 0.131836 */
9909 -3331, /* B1 = -0.203339 */
9910 4320, /* B0 = 0.131836 */
9911 5, /* Internal filter scaling */
9912 159, /* Minimum in-band energy threshold */
9913 21, /* 21/32 in-band to broad-band ratio */
9914 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9915 },
9916 { /* f900_1300[] */
9917 19776, /* A1 = 1.207092 */
9918 -27437, /* A2 = -0.837341 */
9919 -2666, /* B2 = -0.081371 */
9920 0, /* B1 = 0 */
9921 2666, /* B0 = 0.081371 */
9922 16302, /* A1 = 0.995026 */
9923 -30354, /* A2 = -0.926361 */
9924 10389, /* B2 = 0.317062 */
9925 -3327, /* B1 = -0.203064 */
9926 10389, /* B0 = 0.317062 */
9927 24299, /* A1 = 1.483154 */
9928 -30930, /* A2 = -0.943909 */
9929 25016, /* B2 = 0.763428 */
9930 -21171, /* B1 = -1.292236 */
9931 25016, /* B0 = 0.763428 */
9932 7, /* Internal filter scaling */
9933 159, /* Minimum in-band energy threshold */
9934 21, /* 21/32 in-band to broad-band ratio */
9935 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9936 },
9937 { /* f935_1215[] */
9938 20554, /* A1 = 1.254517 */
9939 -28764, /* A2 = -0.877838 */
9940 -2048, /* B2 = -0.062515 */
9941 0, /* B1 = 0 */
9942 2048, /* B0 = 0.062515 */
9943 18209, /* A1 = 1.11145 */
9944 -30951, /* A2 = -0.94458 */
9945 9390, /* B2 = 0.286575 */
9946 -3955, /* B1 = -0.241455 */
9947 9390, /* B0 = 0.286575 */
9948 23902, /* A1 = 1.458923 */
9949 -31286, /* A2 = -0.954803 */
9950 23252, /* B2 = 0.709595 */
9951 -19132, /* B1 = -1.167725 */
9952 23252, /* B0 = 0.709595 */
9953 7, /* Internal filter scaling */
9954 159, /* Minimum in-band energy threshold */
9955 21, /* 21/32 in-band to broad-band ratio */
9956 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9957 },
9958 { /* f941_1477[] */
9959 17543, /* A1 = 1.07074 */
9960 -26220, /* A2 = -0.800201 */
9961 -3298, /* B2 = -0.100647 */
9962 0, /* B1 = 0 */
9963 3298, /* B0 = 0.100647 */
9964 12423, /* A1 = 0.75827 */
9965 -30036, /* A2 = -0.916626 */
9966 12651, /* B2 = 0.386078 */
9967 -2444, /* B1 = -0.14917 */
9968 12653, /* B0 = 0.386154 */
9969 23518, /* A1 = 1.435425 */
9970 -30745, /* A2 = -0.938293 */
9971 27282, /* B2 = 0.832581 */
9972 -22529, /* B1 = -1.375122 */
9973 27286, /* B0 = 0.832703 */
9974 7, /* Internal filter scaling */
9975 159, /* Minimum in-band energy threshold */
9976 21, /* 21/32 in-band to broad-band ratio */
9977 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9978 },
9979 { /* f942 */
9980 24104, /* A1 = -1.471252 */
9981 -32507, /* A2 = 0.992065 */
9982 -351, /* B2 = -0.010722 */
9983 0, /* B1 = 0.000000 */
9984 351, /* B0 = 0.010722 */
9985 23996, /* A1 = -1.464600 */
9986 -32671, /* A2 = 0.997040 */
9987 22848, /* B2 = 0.697266 */
9988 -16639, /* B1 = -1.015564 */
9989 22848, /* B0 = 0.697266 */
9990 24332, /* A1 = -1.485168 */
9991 -32673, /* A2 = 0.997101 */
9992 4906, /* B2 = 0.149727 */
9993 -3672, /* B1 = -0.224174 */
9994 4906, /* B0 = 0.149727 */
9995 5, /* Internal filter scaling */
9996 159, /* Minimum in-band energy threshold */
9997 21, /* 21/32 in-band to broad-band ratio */
9998 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9999 },
10000 { /* f950 */
10001 23967, /* A1 = -1.462830 */
10002 -32507, /* A2 = 0.992065 */
10003 -518, /* B2 = -0.015821 */
10004 0, /* B1 = 0.000000 */
10005 518, /* B0 = 0.015821 */
10006 23856, /* A1 = -1.456055 */
10007 -32671, /* A2 = 0.997040 */
10008 26287, /* B2 = 0.802246 */
10009 -19031, /* B1 = -1.161560 */
10010 26287, /* B0 = 0.802246 */
10011 24195, /* A1 = -1.476746 */
10012 -32673, /* A2 = 0.997101 */
10013 2890, /* B2 = 0.088196 */
10014 -2151, /* B1 = -0.131317 */
10015 2890, /* B0 = 0.088196 */
10016 5, /* Internal filter scaling */
10017 159, /* Minimum in-band energy threshold */
10018 21, /* 21/32 in-band to broad-band ratio */
10019 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10020 },
10021 { /* f950_1400[] */
10022 18294, /* A1 = 1.116638 */
10023 -26962, /* A2 = -0.822845 */
10024 -2914, /* B2 = -0.088936 */
10025 0, /* B1 = 0 */
10026 2914, /* B0 = 0.088936 */
10027 14119, /* A1 = 0.861786 */
10028 -30227, /* A2 = -0.922455 */
10029 11466, /* B2 = 0.349945 */
10030 -2833, /* B1 = -0.172943 */
10031 11466, /* B0 = 0.349945 */
10032 23431, /* A1 = 1.430115 */
10033 -30828, /* A2 = -0.940796 */
10034 25331, /* B2 = 0.773071 */
10035 -20911, /* B1 = -1.276367 */
10036 25331, /* B0 = 0.773071 */
10037 7, /* Internal filter scaling */
10038 159, /* Minimum in-band energy threshold */
10039 21, /* 21/32 in-band to broad-band ratio */
10040 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10041 },
10042 { /* f975 */
10043 23521, /* A1 = -1.435608 */
10044 -32489, /* A2 = 0.991516 */
10045 -193, /* B2 = -0.005915 */
10046 0, /* B1 = 0.000000 */
10047 193, /* B0 = 0.005915 */
10048 23404, /* A1 = -1.428467 */
10049 -32655, /* A2 = 0.996582 */
10050 17740, /* B2 = 0.541412 */
10051 -12567, /* B1 = -0.767029 */
10052 17740, /* B0 = 0.541412 */
10053 23753, /* A1 = -1.449829 */
10054 -32657, /* A2 = 0.996613 */
10055 9090, /* B2 = 0.277405 */
10056 -6662, /* B1 = -0.406647 */
10057 9090, /* B0 = 0.277405 */
10058 5, /* Internal filter scaling */
10059 159, /* Minimum in-band energy threshold */
10060 21, /* 21/32 in-band to broad-band ratio */
10061 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10062 },
10063 { /* f1000 */
10064 23071, /* A1 = -1.408203 */
10065 -32489, /* A2 = 0.991516 */
10066 -293, /* B2 = -0.008965 */
10067 0, /* B1 = 0.000000 */
10068 293, /* B0 = 0.008965 */
10069 22951, /* A1 = -1.400818 */
10070 -32655, /* A2 = 0.996582 */
10071 5689, /* B2 = 0.173645 */
10072 -3951, /* B1 = -0.241150 */
10073 5689, /* B0 = 0.173645 */
10074 23307, /* A1 = -1.422607 */
10075 -32657, /* A2 = 0.996613 */
10076 18692, /* B2 = 0.570435 */
10077 -13447, /* B1 = -0.820770 */
10078 18692, /* B0 = 0.570435 */
10079 5, /* Internal filter scaling */
10080 159, /* Minimum in-band energy threshold */
10081 21, /* 21/32 in-band to broad-band ratio */
10082 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10083 },
10084 { /* f1020 */
10085 22701, /* A1 = -1.385620 */
10086 -32474, /* A2 = 0.991058 */
10087 -292, /* B2 = -0.008933 */
10088 0, /*163840 , B1 = 10.000000 */
10089 292, /* B0 = 0.008933 */
10090 22564, /* A1 = -1.377258 */
10091 -32655, /* A2 = 0.996552 */
10092 20756, /* B2 = 0.633423 */
10093 -14176, /* B1 = -0.865295 */
10094 20756, /* B0 = 0.633423 */
10095 22960, /* A1 = -1.401428 */
10096 -32657, /* A2 = 0.996613 */
10097 6520, /* B2 = 0.198990 */
10098 -4619, /* B1 = -0.281937 */
10099 6520, /* B0 = 0.198990 */
10100 5, /* Internal filter scaling */
10101 159, /* Minimum in-band energy threshold */
10102 21, /* 21/32 in-band to broad-band ratio */
10103 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10104 },
10105 { /* f1050 */
10106 22142, /* A1 = -1.351501 */
10107 -32474, /* A2 = 0.991058 */
10108 -147, /* B2 = -0.004493 */
10109 0, /* B1 = 0.000000 */
10110 147, /* B0 = 0.004493 */
10111 22000, /* A1 = -1.342834 */
10112 -32655, /* A2 = 0.996552 */
10113 15379, /* B2 = 0.469360 */
10114 -10237, /* B1 = -0.624847 */
10115 15379, /* B0 = 0.469360 */
10116 22406, /* A1 = -1.367554 */
10117 -32657, /* A2 = 0.996613 */
10118 17491, /* B2 = 0.533783 */
10119 -12096, /* B1 = -0.738312 */
10120 17491, /* B0 = 0.533783 */
10121 5, /* Internal filter scaling */
10122 159, /* Minimum in-band energy threshold */
10123 21, /* 21/32 in-band to broad-band ratio */
10124 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10125 },
10126 { /* f1100_1750[] */
10127 12973, /* A1 = 0.79184 */
10128 -24916, /* A2 = -0.760376 */
10129 6655, /* B2 = 0.203102 */
10130 367, /* B1 = 0.0224 */
10131 6657, /* B0 = 0.203171 */
10132 5915, /* A1 = 0.361053 */
10133 -29560, /* A2 = -0.90213 */
10134 -7777, /* B2 = -0.23735 */
10135 0, /* B1 = 0 */
10136 7777, /* B0 = 0.23735 */
10137 20510, /* A1 = 1.251892 */
10138 -30260, /* A2 = -0.923462 */
10139 26662, /* B2 = 0.81366 */
10140 -20573, /* B1 = -1.255737 */
10141 26668, /* B0 = 0.813843 */
10142 7, /* Internal filter scaling */
10143 159, /* Minimum in-band energy threshold */
10144 21, /* 21/32 in-band to broad-band ratio */
10145 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10146 },
10147 { /* f1140 */
10148 20392, /* A1 = -1.244629 */
10149 -32460, /* A2 = 0.990601 */
10150 -270, /* B2 = -0.008240 */
10151 0, /* B1 = 0.000000 */
10152 270, /* B0 = 0.008240 */
10153 20218, /* A1 = -1.234009 */
10154 -32655, /* A2 = 0.996582 */
10155 21337, /* B2 = 0.651154 */
10156 -13044, /* B1 = -0.796143 */
10157 21337, /* B0 = 0.651154 */
10158 20684, /* A1 = -1.262512 */
10159 -32657, /* A2 = 0.996643 */
10160 8572, /* B2 = 0.261612 */
10161 -5476, /* B1 = -0.334244 */
10162 8572, /* B0 = 0.261612 */
10163 5, /* Internal filter scaling */
10164 159, /* Minimum in-band energy threshold */
10165 21, /* 21/32 in-band to broad-band ratio */
10166 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10167 },
10168 { /* f1200 */
10169 19159, /* A1 = -1.169373 */
10170 -32456, /* A2 = 0.990509 */
10171 -335, /* B2 = -0.010252 */
10172 0, /* B1 = 0.000000 */
10173 335, /* B0 = 0.010252 */
10174 18966, /* A1 = -1.157593 */
10175 -32661, /* A2 = 0.996735 */
10176 6802, /* B2 = 0.207588 */
10177 -3900, /* B1 = -0.238098 */
10178 6802, /* B0 = 0.207588 */
10179 19467, /* A1 = -1.188232 */
10180 -32661, /* A2 = 0.996765 */
10181 25035, /* B2 = 0.764008 */
10182 -15049, /* B1 = -0.918579 */
10183 25035, /* B0 = 0.764008 */
10184 5, /* Internal filter scaling */
10185 159, /* Minimum in-band energy threshold */
10186 21, /* 21/32 in-band to broad-band ratio */
10187 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10188 },
10189 { /* f1209 */
10190 18976, /* A1 = -1.158264 */
10191 -32439, /* A2 = 0.989990 */
10192 -183, /* B2 = -0.005588 */
10193 0, /* B1 = 0.000000 */
10194 183, /* B0 = 0.005588 */
10195 18774, /* A1 = -1.145874 */
10196 -32650, /* A2 = 0.996429 */
10197 15468, /* B2 = 0.472076 */
10198 -8768, /* B1 = -0.535217 */
10199 15468, /* B0 = 0.472076 */
10200 19300, /* A1 = -1.177979 */
10201 -32652, /* A2 = 0.996490 */
10202 19840, /* B2 = 0.605499 */
10203 -11842, /* B1 = -0.722809 */
10204 19840, /* B0 = 0.605499 */
10205 5, /* Internal filter scaling */
10206 159, /* Minimum in-band energy threshold */
10207 21, /* 21/32 in-band to broad-band ratio */
10208 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10209 },
10210 { /* f1330 */
10211 16357, /* A1 = -0.998413 */
10212 -32368, /* A2 = 0.987793 */
10213 -217, /* B2 = -0.006652 */
10214 0, /* B1 = 0.000000 */
10215 217, /* B0 = 0.006652 */
10216 16107, /* A1 = -0.983126 */
10217 -32601, /* A2 = 0.994904 */
10218 11602, /* B2 = 0.354065 */
10219 -5555, /* B1 = -0.339111 */
10220 11602, /* B0 = 0.354065 */
10221 16722, /* A1 = -1.020630 */
10222 -32603, /* A2 = 0.994965 */
10223 15574, /* B2 = 0.475311 */
10224 -8176, /* B1 = -0.499069 */
10225 15574, /* B0 = 0.475311 */
10226 5, /* Internal filter scaling */
10227 159, /* Minimum in-band energy threshold */
10228 21, /* 21/32 in-band to broad-band ratio */
10229 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10230 },
10231 { /* f1336 */
10232 16234, /* A1 = -0.990875 */
10233 32404, /* A2 = -0.988922 */
10234 -193, /* B2 = -0.005908 */
10235 0, /* B1 = 0.000000 */
10236 193, /* B0 = 0.005908 */
10237 15986, /* A1 = -0.975769 */
10238 -32632, /* A2 = 0.995880 */
10239 18051, /* B2 = 0.550903 */
10240 -8658, /* B1 = -0.528473 */
10241 18051, /* B0 = 0.550903 */
10242 16591, /* A1 = -1.012695 */
10243 -32634, /* A2 = 0.995941 */
10244 15736, /* B2 = 0.480240 */
10245 -8125, /* B1 = -0.495926 */
10246 15736, /* B0 = 0.480240 */
10247 5, /* Internal filter scaling */
10248 159, /* Minimum in-band energy threshold */
10249 21, /* 21/32 in-band to broad-band ratio */
10250 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10251 },
10252 { /* f1366 */
10253 15564, /* A1 = -0.949982 */
10254 -32404, /* A2 = 0.988922 */
10255 -269, /* B2 = -0.008216 */
10256 0, /* B1 = 0.000000 */
10257 269, /* B0 = 0.008216 */
10258 15310, /* A1 = -0.934479 */
10259 -32632, /* A2 = 0.995880 */
10260 10815, /* B2 = 0.330063 */
10261 -4962, /* B1 = -0.302887 */
10262 10815, /* B0 = 0.330063 */
10263 15924, /* A1 = -0.971924 */
10264 -32634, /* A2 = 0.995941 */
10265 18880, /* B2 = 0.576172 */
10266 -9364, /* B1 = -0.571594 */
10267 18880, /* B0 = 0.576172 */
10268 5, /* Internal filter scaling */
10269 159, /* Minimum in-band energy threshold */
10270 21, /* 21/32 in-band to broad-band ratio */
10271 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10272 },
10273 { /* f1380 */
10274 15247, /* A1 = -0.930603 */
10275 -32397, /* A2 = 0.988708 */
10276 -244, /* B2 = -0.007451 */
10277 0, /* B1 = 0.000000 */
10278 244, /* B0 = 0.007451 */
10279 14989, /* A1 = -0.914886 */
10280 -32627, /* A2 = 0.995697 */
10281 18961, /* B2 = 0.578644 */
10282 -8498, /* B1 = -0.518707 */
10283 18961, /* B0 = 0.578644 */
10284 15608, /* A1 = -0.952667 */
10285 -32628, /* A2 = 0.995758 */
10286 11145, /* B2 = 0.340134 */
10287 -5430, /* B1 = -0.331467 */
10288 11145, /* B0 = 0.340134 */
10289 5, /* Internal filter scaling */
10290 159, /* Minimum in-band energy threshold */
10291 21, /* 21/32 in-band to broad-band ratio */
10292 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10293 },
10294 { /* f1400 */
10295 14780, /* A1 = -0.902130 */
10296 -32393, /* A2 = 0.988586 */
10297 -396, /* B2 = -0.012086 */
10298 0, /* B1 = 0.000000 */
10299 396, /* B0 = 0.012086 */
10300 14510, /* A1 = -0.885651 */
10301 -32630, /* A2 = 0.995819 */
10302 6326, /* B2 = 0.193069 */
10303 -2747, /* B1 = -0.167671 */
10304 6326, /* B0 = 0.193069 */
10305 15154, /* A1 = -0.924957 */
10306 -32632, /* A2 = 0.995850 */
10307 23235, /* B2 = 0.709076 */
10308 -10983, /* B1 = -0.670380 */
10309 23235, /* B0 = 0.709076 */
10310 5, /* Internal filter scaling */
10311 159, /* Minimum in-band energy threshold */
10312 21, /* 21/32 in-band to broad-band ratio */
10313 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10314 },
10315 { /* f1477 */
10316 13005, /* A1 = -0.793793 */
10317 -32368, /* A2 = 0.987823 */
10318 -500, /* B2 = -0.015265 */
10319 0, /* B1 = 0.000000 */
10320 500, /* B0 = 0.015265 */
10321 12708, /* A1 = -0.775665 */
10322 -32615, /* A2 = 0.995331 */
10323 11420, /* B2 = 0.348526 */
10324 -4306, /* B1 = -0.262833 */
10325 11420, /* B0 = 0.348526 */
10326 13397, /* A1 = -0.817688 */
10327 -32615, /* A2 = 0.995361 */
10328 9454, /* B2 = 0.288528 */
10329 -3981, /* B1 = -0.243027 */
10330 9454, /* B0 = 0.288528 */
10331 5, /* Internal filter scaling */
10332 159, /* Minimum in-band energy threshold */
10333 21, /* 21/32 in-band to broad-band ratio */
10334 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10335 },
10336 { /* f1600 */
10337 10046, /* A1 = -0.613190 */
10338 -32331, /* A2 = 0.986694 */
10339 -455, /* B2 = -0.013915 */
10340 0, /* B1 = 0.000000 */
10341 455, /* B0 = 0.013915 */
10342 9694, /* A1 = -0.591705 */
10343 -32601, /* A2 = 0.994934 */
10344 6023, /* B2 = 0.183815 */
10345 -1708, /* B1 = -0.104279 */
10346 6023, /* B0 = 0.183815 */
10347 10478, /* A1 = -0.639587 */
10348 -32603, /* A2 = 0.994965 */
10349 22031, /* B2 = 0.672333 */
10350 -7342, /* B1 = -0.448151 */
10351 22031, /* B0 = 0.672333 */
10352 5, /* Internal filter scaling */
10353 159, /* Minimum in-band energy threshold */
10354 21, /* 21/32 in-band to broad-band ratio */
10355 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10356 },
10357 { /* f1633_1638[] */
10358 9181, /* A1 = 0.560394 */
10359 -32256, /* A2 = -0.984375 */
10360 -556, /* B2 = -0.016975 */
10361 0, /* B1 = 0 */
10362 556, /* B0 = 0.016975 */
10363 8757, /* A1 = 0.534515 */
10364 -32574, /* A2 = -0.99408 */
10365 8443, /* B2 = 0.25769 */
10366 -2135, /* B1 = -0.130341 */
10367 8443, /* B0 = 0.25769 */
10368 9691, /* A1 = 0.591522 */
10369 -32574, /* A2 = -0.99411 */
10370 15446, /* B2 = 0.471375 */
10371 -4809, /* B1 = -0.293579 */
10372 15446, /* B0 = 0.471375 */
10373 7, /* Internal filter scaling */
10374 159, /* Minimum in-band energy threshold */
10375 21, /* 21/32 in-band to broad-band ratio */
10376 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10377 },
10378 { /* f1800 */
10379 5076, /* A1 = -0.309875 */
10380 -32304, /* A2 = 0.985840 */
10381 -508, /* B2 = -0.015503 */
10382 0, /* B1 = 0.000000 */
10383 508, /* B0 = 0.015503 */
10384 4646, /* A1 = -0.283600 */
10385 -32605, /* A2 = 0.995026 */
10386 6742, /* B2 = 0.205780 */
10387 -878, /* B1 = -0.053635 */
10388 6742, /* B0 = 0.205780 */
10389 5552, /* A1 = -0.338928 */
10390 -32605, /* A2 = 0.995056 */
10391 23667, /* B2 = 0.722260 */
10392 -4297, /* B1 = -0.262329 */
10393 23667, /* B0 = 0.722260 */
10394 5, /* Internal filter scaling */
10395 159, /* Minimum in-band energy threshold */
10396 21, /* 21/32 in-band to broad-band ratio */
10397 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10398 },
10399 { /* f1860 */
10400 3569, /* A1 = -0.217865 */
10401 -32292, /* A2 = 0.985504 */
10402 -239, /* B2 = -0.007322 */
10403 0, /* B1 = 0.000000 */
10404 239, /* B0 = 0.007322 */
10405 3117, /* A1 = -0.190277 */
10406 -32603, /* A2 = 0.994965 */
10407 18658, /* B2 = 0.569427 */
10408 -1557, /* B1 = -0.095032 */
10409 18658, /* B0 = 0.569427 */
10410 4054, /* A1 = -0.247437 */
10411 -32603, /* A2 = 0.994965 */
10412 18886, /* B2 = 0.576385 */
10413 -2566, /* B1 = -0.156647 */
10414 18886, /* B0 = 0.576385 */
10415 5, /* Internal filter scaling */
10416 159, /* Minimum in-band energy threshold */
10417 21, /* 21/32 in-band to broad-band ratio */
10418 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10419 },
10420};
10421static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10422{
10423 unsigned short cmd;
10424 int cnt, max;
10425
10426 if (jf->filter > 3) {
10427 return -1;
10428 }
10429 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10430
10431 return -1;
10432 if (!jf->enable) {
10433 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10434
10435 return -1;
10436 else
10437 return 0;
10438 } else {
10439 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10440
10441 return -1;
10442 /* Select the filter (f0 - f3) to use. */
10443 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10444 return -1;
10445 }
10446 if (jf->freq < 12 && jf->freq > 3) {
10447 /* Select the frequency for the selected filter. */
10448 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10449 return -1;
10450 } else if (jf->freq > 11) {
10451 /* We need to load a programmable filter set for undefined */
10452 /* frequencies. So we will point the filter to a programmable set. */
10453 /* Since there are only 4 filters and 4 programmable sets, we will */
10454 /* just point the filter to the same number set and program it for the */
10455 /* frequency we want. */
10456 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10457 return -1;
10458 if (j->ver.low != 0x12) {
10459 cmd = 0x515B;
10460 max = 19;
10461 } else {
10462 cmd = 0x515E;
10463 max = 15;
10464 }
10465 if (ixj_WriteDSPCommand(cmd, j))
10466 return -1;
10467 for (cnt = 0; cnt < max; cnt++) {
10468 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10469 return -1;
10470 }
10471 }
10472 j->filter_en[jf->filter] = jf->enable;
10473 return 0;
10474}
10475
10476static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10477{
10478 unsigned short cmd;
10479 int cnt, max;
10480 if (jfr->filter > 3) {
10481 return -1;
10482 }
10483 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10484 return -1;
10485
10486 if (!jfr->enable) {
10487 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10488 return -1;
10489 else
10490 return 0;
10491 } else {
10492 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10493 return -1;
10494 /* Select the filter (f0 - f3) to use. */
10495 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10496 return -1;
10497 }
10498 /* We need to load a programmable filter set for undefined */
10499 /* frequencies. So we will point the filter to a programmable set. */
10500 /* Since there are only 4 filters and 4 programmable sets, we will */
10501 /* just point the filter to the same number set and program it for the */
10502 /* frequency we want. */
10503 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10504 return -1;
10505 if (j->ver.low != 0x12) {
10506 cmd = 0x515B;
10507 max = 19;
10508 } else {
10509 cmd = 0x515E;
10510 max = 15;
10511 }
10512 if (ixj_WriteDSPCommand(cmd, j))
10513 return -1;
10514 for (cnt = 0; cnt < max; cnt++) {
10515 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10516 return -1;
10517 }
10518 j->filter_en[jfr->filter] = jfr->enable;
10519 return 0;
10520}
10521
10522static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10523{
10524 int freq0, freq1;
10525 unsigned short data;
10526 if (ti->freq0) {
10527 freq0 = ti->freq0;
10528 } else {
10529 freq0 = 0x7FFF;
10530 }
10531
10532 if (ti->freq1) {
10533 freq1 = ti->freq1;
10534 } else {
10535 freq1 = 0x7FFF;
10536 }
10537
10538 if(ti->tone_index > 12 && ti->tone_index < 28)
10539 {
10540 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10541 return -1;
10542 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10543 return -1;
10544 data = freq0;
10545 if (ixj_WriteDSPCommand(data, j))
10546 return -1;
10547 data = freq1;
10548 if (ixj_WriteDSPCommand(data, j))
10549 return -1;
10550 }
10551 return freq0;
10552}
10553