Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / kernel / msm / 613655fa39ff6957754fa8ceb8559980920eb8ee / . / drivers / telephony / ixj.c
blob: b1e469983b1dde5d6b2a63f5f80af2015b8113ff [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;
6584 retval = ixj_init_filter(j, &jf);
6585 break;
6586 case IXJCTL_SET_FILTER_RAW:
6587 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6588 retval = -EFAULT;
6589 else
6590 retval = ixj_init_filter_raw(j, &jfr);
6591 break;
6592 case IXJCTL_GET_FILTER_HIST:
6593 if(arg<0||arg>3)
6594 retval = -EINVAL;
6595 else
6596 retval = j->filter_hist[arg];
6597 break;
6598 case IXJCTL_INIT_TONE:
6599 if (copy_from_user(&ti, argp, sizeof(ti)))
6600 retval = -EFAULT;
6601 else
6602 retval = ixj_init_tone(j, &ti);
6603 break;
6604 case IXJCTL_TONE_CADENCE:
6605 retval = ixj_build_cadence(j, argp);
6606 break;
6607 case IXJCTL_FILTER_CADENCE:
6608 retval = ixj_build_filter_cadence(j, argp);
6609 break;
6610 case IXJCTL_SIGCTL:
6611 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6612 retval = -EFAULT;
6613 break;
6614 }
6615 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6616 if(j->sigdef.event < 33) {
6617 raise = 1;
6618 for(mant = 0; mant < j->sigdef.event; mant++){
6619 raise *= 2;
6620 }
6621 if(j->sigdef.signal)
6622 j->ex_sig.bytes |= raise;
6623 else
6624 j->ex_sig.bytes &= (raise^0xffff);
6625 }
6626 break;
6627 case IXJCTL_INTERCOM_STOP:
6628 if(arg < 0 || arg >= IXJMAX)
6629 return -EINVAL;
6630 j->intercom = -1;
6631 ixj_record_stop(j);
6632 ixj_play_stop(j);
6633 idle(j);
6634 get_ixj(arg)->intercom = -1;
6635 ixj_record_stop(get_ixj(arg));
6636 ixj_play_stop(get_ixj(arg));
6637 idle(get_ixj(arg));
6638 break;
6639 case IXJCTL_INTERCOM_START:
6640 if(arg < 0 || arg >= IXJMAX)
6641 return -EINVAL;
6642 j->intercom = arg;
6643 ixj_record_start(j);
6644 ixj_play_start(j);
6645 get_ixj(arg)->intercom = board;
6646 ixj_play_start(get_ixj(arg));
6647 ixj_record_start(get_ixj(arg));
6648 break;
6649 }
6650 if (ixjdebug & 0x0040)
6651 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6652 clear_bit(board, &j->busyflags);
6653 return retval;
6654}
6655
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6656static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6657{
6658 long ret;
Arnd Bergmann613655f2010-06-02 14:28:52 +0200[diff] [blame^]6659 mutex_lock(&ixj_mutex);
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6660 ret = do_ixj_ioctl(file_p, cmd, arg);
Arnd Bergmann613655f2010-06-02 14:28:52 +0200[diff] [blame^]6661 mutex_unlock(&ixj_mutex);
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6662 return ret;
6663}
6664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6665static int ixj_fasync(int fd, struct file *file_p, int mode)
6666{
Josef Sipekd1f22972006-12-08 02:37:14 -0800[diff] [blame]6667 IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6668
6669 return fasync_helper(fd, file_p, mode, &j->async_queue);
6670}
6671
Arjan van de Ven00977a52007-02-12 00:55:34 -0800[diff] [blame]6672static const struct file_operations ixj_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6673{
6674 .owner = THIS_MODULE,
6675 .read = ixj_enhanced_read,
6676 .write = ixj_enhanced_write,
6677 .poll = ixj_poll,
Alan Coxe05e9f72008-07-25 01:48:16 -0700[diff] [blame]6678 .unlocked_ioctl = ixj_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6679 .release = ixj_release,
6680 .fasync = ixj_fasync
6681};
6682
6683static int ixj_linetest(IXJ *j)
6684{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6685 j->flags.pstncheck = 1; /* Testing */
6686 j->flags.pstn_present = 0; /* Assume the line is not there */
6687
6688 daa_int_read(j); /*Clear DAA Interrupt flags */
6689 /* */
6690 /* Hold all relays in the normally de-energized position. */
6691 /* */
6692
6693 j->pld_slicw.bits.rly1 = 0;
6694 j->pld_slicw.bits.rly2 = 0;
6695 j->pld_slicw.bits.rly3 = 0;
6696 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6697 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6698
6699 outb_p(j->pld_scrw.byte, j->XILINXbase);
6700 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6701 if (j->pld_slicr.bits.potspstn) {
6702 j->flags.pots_pstn = 1;
6703 j->flags.pots_correct = 0;
6704 LED_SetState(0x4, j);
6705 } else {
6706 j->flags.pots_pstn = 0;
6707 j->pld_slicw.bits.rly1 = 0;
6708 j->pld_slicw.bits.rly2 = 0;
6709 j->pld_slicw.bits.rly3 = 1;
6710 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6711 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6712
6713 outb_p(j->pld_scrw.byte, j->XILINXbase);
6714 daa_set_mode(j, SOP_PU_CONVERSATION);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6715 msleep(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6716 daa_int_read(j);
6717 daa_set_mode(j, SOP_PU_RESET);
6718 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6719 j->flags.pots_correct = 0; /* Should not be line voltage on POTS port. */
6720 LED_SetState(0x4, j);
6721 j->pld_slicw.bits.rly3 = 0;
6722 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6723 } else {
6724 j->flags.pots_correct = 1;
6725 LED_SetState(0x8, j);
6726 j->pld_slicw.bits.rly1 = 1;
6727 j->pld_slicw.bits.rly2 = 0;
6728 j->pld_slicw.bits.rly3 = 0;
6729 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6730 }
6731 }
6732 j->pld_slicw.bits.rly3 = 0;
6733 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6734 daa_set_mode(j, SOP_PU_CONVERSATION);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6735 msleep(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6736 daa_int_read(j);
6737 daa_set_mode(j, SOP_PU_RESET);
6738 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6739 j->pstn_sleeptil = jiffies + (hertz / 4);
6740 j->flags.pstn_present = 1;
6741 } else {
6742 j->flags.pstn_present = 0;
6743 }
6744 if (j->flags.pstn_present) {
6745 if (j->flags.pots_correct) {
6746 LED_SetState(0xA, j);
6747 } else {
6748 LED_SetState(0x6, j);
6749 }
6750 } else {
6751 if (j->flags.pots_correct) {
6752 LED_SetState(0x9, j);
6753 } else {
6754 LED_SetState(0x5, j);
6755 }
6756 }
6757 j->flags.pstncheck = 0; /* Testing */
6758 return j->flags.pstn_present;
6759}
6760
6761static int ixj_selfprobe(IXJ *j)
6762{
6763 unsigned short cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6764 int cnt;
6765 BYTES bytes;
6766
6767 init_waitqueue_head(&j->poll_q);
6768 init_waitqueue_head(&j->read_q);
6769 init_waitqueue_head(&j->write_q);
6770
6771 while(atomic_read(&j->DSPWrite) > 0)
6772 atomic_dec(&j->DSPWrite);
6773 if (ixjdebug & 0x0002)
6774 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6775 ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6776
6777 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
6778 return -1;
6779/* The read values of the SSR should be 0x00 for the IDLE command */
6780 if (j->ssr.low || j->ssr.high)
6781 return -1;
6782 if (ixjdebug & 0x0002)
6783 printk(KERN_INFO "Get Device ID Code\n");
6784 if (ixj_WriteDSPCommand(0x3400, j)) /* Get Device ID Code */
6785 return -1;
6786 j->dsp.low = j->ssr.low;
6787 j->dsp.high = j->ssr.high;
6788 if (ixjdebug & 0x0002)
6789 printk(KERN_INFO "Get Device Version Code\n");
6790 if (ixj_WriteDSPCommand(0x3800, j)) /* Get Device Version Code */
6791 return -1;
6792 j->ver.low = j->ssr.low;
6793 j->ver.high = j->ssr.high;
6794 if (!j->cardtype) {
6795 if (j->dsp.low == 0x21) {
6796 bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6797 outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6798/* Test for Internet LineJACK or Internet PhoneJACK Lite */
6799 bytes.low = inb_p(j->XILINXbase + 0x02);
6800 if (bytes.low == bytes.high) /* Register is read only on */
6801 /* Internet PhoneJack Lite */
6802 {
6803 j->cardtype = QTI_PHONEJACK_LITE;
6804 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6805 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6806 return -1;
6807 }
6808 j->pld_slicw.pcib.e1 = 1;
6809 outb_p(j->pld_slicw.byte, j->XILINXbase);
6810 } else {
6811 j->cardtype = QTI_LINEJACK;
6812
6813 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6814 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6815 return -1;
6816 }
6817 }
6818 } else if (j->dsp.low == 0x22) {
6819 j->cardtype = QTI_PHONEJACK_PCI;
6820 request_region(j->XILINXbase, 4, "ixj control");
6821 j->pld_slicw.pcib.e1 = 1;
6822 outb_p(j->pld_slicw.byte, j->XILINXbase);
6823 } else
6824 j->cardtype = QTI_PHONEJACK;
6825 } else {
6826 switch (j->cardtype) {
6827 case QTI_PHONEJACK:
6828 if (!j->dsp.low != 0x20) {
6829 j->dsp.high = 0x80;
6830 j->dsp.low = 0x20;
6831 ixj_WriteDSPCommand(0x3800, j);
6832 j->ver.low = j->ssr.low;
6833 j->ver.high = j->ssr.high;
6834 }
6835 break;
6836 case QTI_LINEJACK:
6837 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6838 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6839 return -1;
6840 }
6841 break;
6842 case QTI_PHONEJACK_LITE:
6843 case QTI_PHONEJACK_PCI:
6844 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6845 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6846 return -1;
6847 }
6848 j->pld_slicw.pcib.e1 = 1;
6849 outb_p(j->pld_slicw.byte, j->XILINXbase);
6850 break;
6851 case QTI_PHONECARD:
6852 break;
6853 }
6854 }
6855 if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6856 if (ixjdebug & 0x0002)
6857 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6858 if (ixj_WriteDSPCommand(0xC462, j)) /* Write CODEC config to Software Control Register */
6859 return -1;
6860 if (ixjdebug & 0x0002)
6861 printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6862 if (j->cardtype == QTI_PHONEJACK) {
6863 cmd = 0x9FF2;
6864 } else {
6865 cmd = 0x9FF5;
6866 }
6867 if (ixj_WriteDSPCommand(cmd, j)) /* Write CODEC timing to Software Control Register */
6868 return -1;
6869 } else {
6870 if (set_base_frame(j, 30) != 30)
6871 return -1;
6872 if (ixjdebug & 0x0002)
6873 printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6874 if (j->cardtype == QTI_PHONECARD) {
6875 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6876 return -1;
6877 }
6878 if (j->cardtype == QTI_LINEJACK) {
6879 if (ixj_WriteDSPCommand(0xC528, j)) /* Write CODEC config to Software Control Register */
6880 return -1;
6881 if (ixjdebug & 0x0002)
6882 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6883 j->pld_clock.byte = 0;
6884 outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6885 }
6886 }
6887
6888 if (j->dsp.low == 0x20) {
6889 if (ixjdebug & 0x0002)
6890 printk(KERN_INFO "Configure GPIO pins\n");
6891 j->gpio.bytes.high = 0x09;
6892/* bytes.low = 0xEF; 0xF7 */
6893 j->gpio.bits.gpio1 = 1;
6894 j->gpio.bits.gpio2 = 1;
6895 j->gpio.bits.gpio3 = 0;
6896 j->gpio.bits.gpio4 = 1;
6897 j->gpio.bits.gpio5 = 1;
6898 j->gpio.bits.gpio6 = 1;
6899 j->gpio.bits.gpio7 = 1;
6900 ixj_WriteDSPCommand(j->gpio.word, j); /* Set GPIO pin directions */
6901 if (ixjdebug & 0x0002)
6902 printk(KERN_INFO "Enable SLIC\n");
6903 j->gpio.bytes.high = 0x0B;
6904 j->gpio.bytes.low = 0x00;
6905 j->gpio.bits.gpio1 = 0;
6906 j->gpio.bits.gpio2 = 1;
6907 j->gpio.bits.gpio5 = 0;
6908 ixj_WriteDSPCommand(j->gpio.word, j); /* send the ring stop signal */
6909 j->port = PORT_POTS;
6910 } else {
6911 if (j->cardtype == QTI_LINEJACK) {
6912 LED_SetState(0x1, j);
Nishanth Aravamudanf4c99252005-09-10 00:26:50 -0700[diff] [blame]6913 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]6914 LED_SetState(0x2, 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(0x4, 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(0x8, 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(0x0, j);
6921 daa_get_version(j);
6922 if (ixjdebug & 0x0002)
6923 printk("Loading DAA Coefficients\n");
6924 DAA_Coeff_US(j);
6925 if (!ixj_daa_write(j)) {
6926 printk("DAA write failed on board %d\n", j->board);
6927 return -1;
6928 }
6929 if(!ixj_daa_cid_reset(j)) {
6930 printk("DAA CID reset failed on board %d\n", j->board);
6931 return -1;
6932 }
6933 j->flags.pots_correct = 0;
6934 j->flags.pstn_present = 0;
6935 ixj_linetest(j);
6936 if (j->flags.pots_correct) {
6937 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
6938
6939 outb_p(j->pld_scrw.byte, j->XILINXbase);
6940 j->pld_slicw.bits.rly1 = 1;
6941 j->pld_slicw.bits.spken = 1;
6942 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6943 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6944/* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6945 j->port = PORT_POTS;
6946 }
6947 ixj_set_port(j, PORT_PSTN);
6948 ixj_set_pots(j, 1);
6949 if (ixjdebug & 0x0002)
6950 printk(KERN_INFO "Enable Mixer\n");
6951 ixj_mixer(0x0000, j); /*Master Volume Left unmute 0db */
6952 ixj_mixer(0x0100, j); /*Master Volume Right unmute 0db */
6953
6954 ixj_mixer(0x0203, j); /*Voice Left Volume unmute 6db */
6955 ixj_mixer(0x0303, j); /*Voice Right Volume unmute 6db */
6956
6957 ixj_mixer(0x0480, j); /*FM Left mute */
6958 ixj_mixer(0x0580, j); /*FM Right mute */
6959
6960 ixj_mixer(0x0680, j); /*CD Left mute */
6961 ixj_mixer(0x0780, j); /*CD Right mute */
6962
6963 ixj_mixer(0x0880, j); /*Line Left mute */
6964 ixj_mixer(0x0980, j); /*Line Right mute */
6965
6966 ixj_mixer(0x0A80, j); /*Aux left mute */
6967 ixj_mixer(0x0B80, j); /*Aux right mute */
6968
6969 ixj_mixer(0x0C00, j); /*Mono1 unmute 12db */
6970 ixj_mixer(0x0D80, j); /*Mono2 mute */
6971
6972 ixj_mixer(0x0E80, j); /*Mic mute */
6973
6974 ixj_mixer(0x0F00, j); /*Mono Out Volume unmute 0db */
6975
6976 ixj_mixer(0x1000, j); /*Voice Left and Right out only */
6977 ixj_mixer(0x110C, j);
6978
6979
6980 ixj_mixer(0x1200, j); /*Mono1 switch on mixer left */
6981 ixj_mixer(0x1401, j);
6982
6983 ixj_mixer(0x1300, j); /*Mono1 switch on mixer right */
6984 ixj_mixer(0x1501, j);
6985
6986 ixj_mixer(0x1700, j); /*Clock select */
6987
6988 ixj_mixer(0x1800, j); /*ADC input from mixer */
6989
6990 ixj_mixer(0x1901, j); /*Mic gain 30db */
6991
6992 if (ixjdebug & 0x0002)
6993 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6994 j->cadence_f[4].state = 0;
6995 j->cadence_f[4].on1 = 0; /*Cadence Filter 4 is used for PSTN ring cadence */
6996 j->cadence_f[4].off1 = 0;
6997 j->cadence_f[4].on2 = 0;
6998 j->cadence_f[4].off2 = 0;
6999 j->cadence_f[4].on3 = 0;
7000 j->cadence_f[4].off3 = 0; /* These should represent standard US ring pulse. */
7001 j->pstn_last_rmr = jiffies;
7002
7003 } else {
7004 if (j->cardtype == QTI_PHONECARD) {
7005 ixj_WriteDSPCommand(0xCF07, j);
7006 ixj_WriteDSPCommand(0x00B0, j);
7007 ixj_set_port(j, PORT_SPEAKER);
7008 } else {
7009 ixj_set_port(j, PORT_POTS);
7010 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7011/* SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7012 }
7013 }
7014 }
7015
7016 j->intercom = -1;
7017 j->framesread = j->frameswritten = 0;
7018 j->read_wait = j->write_wait = 0;
7019 j->rxreadycheck = j->txreadycheck = 0;
7020
7021 /* initialise the DTMF prescale to a sensible value */
7022 if (j->cardtype == QTI_LINEJACK) {
7023 set_dtmf_prescale(j, 0x10);
7024 } else {
7025 set_dtmf_prescale(j, 0x40);
7026 }
7027 set_play_volume(j, 0x100);
7028 set_rec_volume(j, 0x100);
7029
7030 if (ixj_WriteDSPCommand(0x0000, j)) /* Write IDLE to Software Control Register */
7031 return -1;
7032/* The read values of the SSR should be 0x00 for the IDLE command */
7033 if (j->ssr.low || j->ssr.high)
7034 return -1;
7035
7036 if (ixjdebug & 0x0002)
7037 printk(KERN_INFO "Enable Line Monitor\n");
7038
7039 if (ixjdebug & 0x0002)
7040 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7041
7042 if (ixj_WriteDSPCommand(0x7E01, j)) /* Asynchronous Line Monitor */
7043 return -1;
7044
7045 if (ixjdebug & 0x002)
7046 printk(KERN_INFO "Enable DTMF Detectors\n");
7047
7048 if (ixj_WriteDSPCommand(0x5151, j)) /* Enable DTMF detection */
7049 return -1;
7050
7051 if (ixj_WriteDSPCommand(0x6E01, j)) /* Set Asyncronous Tone Generation */
7052 return -1;
7053
7054 set_rec_depth(j, 2); /* Set Record Channel Limit to 2 frames */
7055
7056 set_play_depth(j, 2); /* Set Playback Channel Limit to 2 frames */
7057
7058 j->ex.bits.dtmf_ready = 0;
7059 j->dtmf_state = 0;
7060 j->dtmf_wp = j->dtmf_rp = 0;
7061 j->rec_mode = j->play_mode = -1;
7062 j->flags.ringing = 0;
7063 j->maxrings = MAXRINGS;
7064 j->ring_cadence = USA_RING_CADENCE;
7065 j->drybuffer = 0;
7066 j->winktime = 320;
7067 j->flags.dtmf_oob = 0;
7068 for (cnt = 0; cnt < 4; cnt++)
7069 j->cadence_f[cnt].enable = 0;
7070 /* must be a device on the specified address */
7071 ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7072
7073 /* Set up the default signals for events */
7074 for (cnt = 0; cnt < 35; cnt++)
7075 j->ixj_signals[cnt] = SIGIO;
7076
7077 /* Set the excetion signal enable flags */
7078 j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7079 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 =
7080 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;
7081#ifdef IXJ_DYN_ALLOC
7082 j->fskdata = NULL;
7083#endif
7084 j->fskdcnt = 0;
7085 j->cidcw_wait = 0;
7086
7087 /* Register with the Telephony for Linux subsystem */
7088 j->p.f_op = &ixj_fops;
7089 j->p.open = ixj_open;
7090 j->p.board = j->board;
7091 phone_register_device(&j->p, PHONE_UNIT_ANY);
7092
7093 ixj_init_timer(j);
7094 ixj_add_timer(j);
7095 return 0;
7096}
7097
7098/*
7099 * Exported service for pcmcia card handling
7100 */
7101
7102IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7103{
7104 IXJ *j = ixj_alloc();
7105
7106 j->board = 0;
7107
7108 j->DSPbase = dsp;
7109 j->XILINXbase = xilinx;
7110 j->cardtype = QTI_PHONECARD;
7111 ixj_selfprobe(j);
7112 return j;
7113}
7114
7115EXPORT_SYMBOL(ixj_pcmcia_probe); /* Fpr PCMCIA */
7116
7117static int ixj_get_status_proc(char *buf)
7118{
7119 int len;
7120 int cnt;
7121 IXJ *j;
7122 len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7123 len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7124 len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7125 len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7126 len += sprintf(buf + len, "\nUsing old telephony API");
7127 len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7128
7129 for (cnt = 0; cnt < IXJMAX; cnt++) {
7130 j = get_ixj(cnt);
7131 if(j==NULL)
7132 continue;
7133 if (j->DSPbase) {
7134 len += sprintf(buf + len, "\nCard Num %d", cnt);
7135 len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7136 if (j->cardtype != QTI_PHONEJACK)
7137 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7138 len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7139 len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7140 len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7141 switch (j->cardtype) {
7142 case (QTI_PHONEJACK):
7143 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7144 break;
7145 case (QTI_LINEJACK):
7146 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7147 if (j->flags.g729_loaded)
7148 len += sprintf(buf + len, " w/G.729 A/B");
7149 len += sprintf(buf + len, " Country = %d", j->daa_country);
7150 break;
7151 case (QTI_PHONEJACK_LITE):
7152 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7153 if (j->flags.g729_loaded)
7154 len += sprintf(buf + len, " w/G.729 A/B");
7155 break;
7156 case (QTI_PHONEJACK_PCI):
7157 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7158 if (j->flags.g729_loaded)
7159 len += sprintf(buf + len, " w/G.729 A/B");
7160 break;
7161 case (QTI_PHONECARD):
7162 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7163 if (j->flags.g729_loaded)
7164 len += sprintf(buf + len, " w/G.729 A/B");
7165 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7166 if (!j->pccr1.bits.drf)
7167 len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7168 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7169 break;
7170 default:
7171 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7172 break;
7173 }
7174 len += sprintf(buf + len, "\nReaders %d", j->readers);
7175 len += sprintf(buf + len, "\nWriters %d", j->writers);
7176 add_caps(j);
7177 len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7178 if (j->dsp.low != 0x20)
7179 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7180 if (j->flags.cidsent)
7181 len += sprintf(buf + len, "\nCaller ID data sent");
7182 else
7183 len += sprintf(buf + len, "\nCaller ID data not sent");
7184
7185 len += sprintf(buf + len, "\nPlay CODEC ");
7186 switch (j->play_codec) {
7187 case G723_63:
7188 len += sprintf(buf + len, "G.723.1 6.3");
7189 break;
7190 case G723_53:
7191 len += sprintf(buf + len, "G.723.1 5.3");
7192 break;
7193 case TS85:
7194 len += sprintf(buf + len, "TrueSpeech 8.5");
7195 break;
7196 case TS48:
7197 len += sprintf(buf + len, "TrueSpeech 4.8");
7198 break;
7199 case TS41:
7200 len += sprintf(buf + len, "TrueSpeech 4.1");
7201 break;
7202 case G728:
7203 len += sprintf(buf + len, "G.728");
7204 break;
7205 case G729:
7206 len += sprintf(buf + len, "G.729");
7207 break;
7208 case G729B:
7209 len += sprintf(buf + len, "G.729B");
7210 break;
7211 case ULAW:
7212 len += sprintf(buf + len, "uLaw");
7213 break;
7214 case ALAW:
7215 len += sprintf(buf + len, "aLaw");
7216 break;
7217 case LINEAR16:
7218 len += sprintf(buf + len, "16 bit Linear");
7219 break;
7220 case LINEAR8:
7221 len += sprintf(buf + len, "8 bit Linear");
7222 break;
7223 case WSS:
7224 len += sprintf(buf + len, "Windows Sound System");
7225 break;
7226 default:
7227 len += sprintf(buf + len, "NO CODEC CHOSEN");
7228 break;
7229 }
7230 len += sprintf(buf + len, "\nRecord CODEC ");
7231 switch (j->rec_codec) {
7232 case G723_63:
7233 len += sprintf(buf + len, "G.723.1 6.3");
7234 break;
7235 case G723_53:
7236 len += sprintf(buf + len, "G.723.1 5.3");
7237 break;
7238 case TS85:
7239 len += sprintf(buf + len, "TrueSpeech 8.5");
7240 break;
7241 case TS48:
7242 len += sprintf(buf + len, "TrueSpeech 4.8");
7243 break;
7244 case TS41:
7245 len += sprintf(buf + len, "TrueSpeech 4.1");
7246 break;
7247 case G728:
7248 len += sprintf(buf + len, "G.728");
7249 break;
7250 case G729:
7251 len += sprintf(buf + len, "G.729");
7252 break;
7253 case G729B:
7254 len += sprintf(buf + len, "G.729B");
7255 break;
7256 case ULAW:
7257 len += sprintf(buf + len, "uLaw");
7258 break;
7259 case ALAW:
7260 len += sprintf(buf + len, "aLaw");
7261 break;
7262 case LINEAR16:
7263 len += sprintf(buf + len, "16 bit Linear");
7264 break;
7265 case LINEAR8:
7266 len += sprintf(buf + len, "8 bit Linear");
7267 break;
7268 case WSS:
7269 len += sprintf(buf + len, "Windows Sound System");
7270 break;
7271 default:
7272 len += sprintf(buf + len, "NO CODEC CHOSEN");
7273 break;
7274 }
7275 len += sprintf(buf + len, "\nAEC ");
7276 switch (j->aec_level) {
7277 case AEC_OFF:
7278 len += sprintf(buf + len, "Off");
7279 break;
7280 case AEC_LOW:
7281 len += sprintf(buf + len, "Low");
7282 break;
7283 case AEC_MED:
7284 len += sprintf(buf + len, "Med");
7285 break;
7286 case AEC_HIGH:
7287 len += sprintf(buf + len, "High");
7288 break;
7289 case AEC_AUTO:
7290 len += sprintf(buf + len, "Auto");
7291 break;
7292 case AEC_AGC:
7293 len += sprintf(buf + len, "AEC/AGC");
7294 break;
7295 default:
7296 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7297 break;
7298 }
7299
7300 len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7301 len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7302 len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7303
7304 len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook); */
7305
7306 if (j->cardtype == QTI_LINEJACK) {
7307 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7308 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7309 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7310 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7311 switch (j->daa_mode) {
7312 case SOP_PU_SLEEP:
7313 len += sprintf(buf + len, "\nDAA PSTN On Hook");
7314 break;
7315 case SOP_PU_RINGING:
7316 len += sprintf(buf + len, "\nDAA PSTN Ringing");
7317 len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7318 break;
7319 case SOP_PU_CONVERSATION:
7320 len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7321 break;
7322 case SOP_PU_PULSEDIALING:
7323 len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7324 break;
7325 }
7326 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7327 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7328 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7329 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7330 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7331 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7332 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7333 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7334 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7335 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7336 }
7337 switch (j->port) {
7338 case PORT_POTS:
7339 len += sprintf(buf + len, "\nPort POTS");
7340 break;
7341 case PORT_PSTN:
7342 len += sprintf(buf + len, "\nPort PSTN");
7343 break;
7344 case PORT_SPEAKER:
7345 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7346 break;
7347 case PORT_HANDSET:
7348 len += sprintf(buf + len, "\nPort HANDSET");
7349 break;
7350 }
7351 if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7352 len += sprintf(buf + len, "\nSLIC state ");
7353 switch (SLIC_GetState(j)) {
7354 case PLD_SLIC_STATE_OC:
7355 len += sprintf(buf + len, "OC");
7356 break;
7357 case PLD_SLIC_STATE_RINGING:
7358 len += sprintf(buf + len, "RINGING");
7359 break;
7360 case PLD_SLIC_STATE_ACTIVE:
7361 len += sprintf(buf + len, "ACTIVE");
7362 break;
7363 case PLD_SLIC_STATE_OHT: /* On-hook transmit */
7364 len += sprintf(buf + len, "OHT");
7365 break;
7366 case PLD_SLIC_STATE_TIPOPEN:
7367 len += sprintf(buf + len, "TIPOPEN");
7368 break;
7369 case PLD_SLIC_STATE_STANDBY:
7370 len += sprintf(buf + len, "STANDBY");
7371 break;
7372 case PLD_SLIC_STATE_APR: /* Active polarity reversal */
7373 len += sprintf(buf + len, "APR");
7374 break;
7375 case PLD_SLIC_STATE_OHTPR: /* OHT polarity reversal */
7376 len += sprintf(buf + len, "OHTPR");
7377 break;
7378 default:
7379 len += sprintf(buf + len, "%d", SLIC_GetState(j));
7380 break;
7381 }
7382 }
7383 len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7384 len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7385#ifdef PERFMON_STATS
7386 len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7387 len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7388 len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7389 len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7390 len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7391 len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7392 len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7393 len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7394 len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7395 len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7396 len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7397 len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7398 len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7399 len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7400
7401#endif
7402 len += sprintf(buf + len, "\n");
7403 }
7404 }
7405 return len;
7406}
7407
7408static int ixj_read_proc(char *page, char **start, off_t off,
7409 int count, int *eof, void *data)
7410{
7411 int len = ixj_get_status_proc(page);
7412 if (len <= off+count) *eof = 1;
7413 *start = page + off;
7414 len -= off;
7415 if (len>count) len = count;
7416 if (len<0) len = 0;
7417 return len;
7418}
7419
7420
7421static void cleanup(void)
7422{
7423 int cnt;
7424 IXJ *j;
7425
7426 for (cnt = 0; cnt < IXJMAX; cnt++) {
7427 j = get_ixj(cnt);
7428 if(j != NULL && j->DSPbase) {
7429 if (ixjdebug & 0x0002)
7430 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7431 del_timer(&j->timer);
7432 if (j->cardtype == QTI_LINEJACK) {
7433 j->pld_scrw.bits.daafsyncen = 0; /* Turn off DAA Frame Sync */
7434
7435 outb_p(j->pld_scrw.byte, j->XILINXbase);
7436 j->pld_slicw.bits.rly1 = 0;
7437 j->pld_slicw.bits.rly2 = 0;
7438 j->pld_slicw.bits.rly3 = 0;
7439 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7440 LED_SetState(0x0, j);
7441 if (ixjdebug & 0x0002)
7442 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7443 release_region(j->XILINXbase, 8);
7444 } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7445 if (ixjdebug & 0x0002)
7446 printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7447 release_region(j->XILINXbase, 4);
7448 }
Jesper Juhl0159f762005-06-25 14:59:14 -0700[diff] [blame]7449 kfree(j->read_buffer);
7450 kfree(j->write_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7451 if (j->dev)
7452 pnp_device_detach(j->dev);
7453 if (ixjdebug & 0x0002)
7454 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7455 phone_unregister_device(&j->p);
7456 if (ixjdebug & 0x0002)
7457 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7458 release_region(j->DSPbase, 16);
7459#ifdef IXJ_DYN_ALLOC
7460 if (ixjdebug & 0x0002)
7461 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7462 kfree(j);
7463 ixj[cnt] = NULL;
7464#endif
7465 }
7466 }
7467 if (ixjdebug & 0x0002)
7468 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7469 remove_proc_entry ("ixj", NULL);
7470}
7471
7472/* Typedefs */
7473typedef struct {
7474 BYTE length;
7475 DWORD bits;
7476} DATABLOCK;
7477
7478static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7479{
7480 lastLCC = lastLCC & 0xfb;
7481 lastLCC = lastLCC | (byData ? 4 : 0);
7482 outb(lastLCC, wEEPROMAddress); /*set data out bit as appropriate */
7483
7484 mdelay(1);
7485 lastLCC = lastLCC | 0x01;
7486 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7487
7488 byData = byData << 1;
7489 lastLCC = lastLCC & 0xfe;
7490 mdelay(1);
7491 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7492
7493}
7494
7495static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7496{
7497 mdelay(1);
7498 lastLCC = lastLCC | 0x01;
7499 outb(lastLCC, wEEPROMAddress); /*SK rising edge */
7500
7501 lastLCC = lastLCC & 0xfe;
7502 mdelay(1);
7503 outb(lastLCC, wEEPROMAddress); /*after delay, SK falling edge */
7504
7505 return ((inb(wEEPROMAddress) >> 3) & 1);
7506}
7507
Richard Knutssone13df2c2007-02-12 00:52:33 -0800[diff] [blame]7508static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7509{
7510 BYTE lastLCC;
7511 WORD wEEPROMAddress = wAddress + 3;
7512 DWORD i;
7513 BYTE byResult;
7514 *pwResult = 0;
7515 lastLCC = inb(wEEPROMAddress);
7516 lastLCC = lastLCC | 0x02;
7517 lastLCC = lastLCC & 0xfe;
7518 outb(lastLCC, wEEPROMAddress); /* CS hi, SK lo */
7519
7520 mdelay(1); /* delay */
7521
7522 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7523 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7524 PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7525 for (i = 0; i < 8; i++) {
7526 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7527 wLoc <<= 1;
7528 }
7529
7530 for (i = 0; i < 16; i++) {
7531 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7532 *pwResult = (*pwResult << 1) | byResult;
7533 }
7534
7535 mdelay(1); /* another delay */
7536
7537 lastLCC = lastLCC & 0xfd;
7538 outb(lastLCC, wEEPROMAddress); /* negate CS */
7539
7540 return 0;
7541}
7542
7543static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7544{
7545 WORD wLo, wHi;
7546 if (PCIEE_ReadWord(wAddress, 62, &wLo))
7547 return 0;
7548 if (PCIEE_ReadWord(wAddress, 63, &wHi))
7549 return 0;
7550 return (((DWORD) wHi << 16) | wLo);
7551}
7552
7553static int dspio[IXJMAX + 1] =
7554{
7555 0,
7556};
7557static int xio[IXJMAX + 1] =
7558{
7559 0,
7560};
7561
7562module_param_array(dspio, int, NULL, 0);
7563module_param_array(xio, int, NULL, 0);
7564MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7565MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7566MODULE_LICENSE("GPL");
7567
7568static void __exit ixj_exit(void)
7569{
7570 cleanup();
7571}
7572
7573static IXJ *new_ixj(unsigned long port)
7574{
7575 IXJ *res;
7576 if (!request_region(port, 16, "ixj DSP")) {
7577 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7578 return NULL;
7579 }
7580 res = ixj_alloc();
7581 if (!res) {
7582 release_region(port, 16);
7583 printk(KERN_INFO "ixj: out of memory\n");
7584 return NULL;
7585 }
7586 res->DSPbase = port;
7587 return res;
7588}
7589
7590static int __init ixj_probe_isapnp(int *cnt)
7591{
7592 int probe = 0;
7593 int func = 0x110;
7594 struct pnp_dev *dev = NULL, *old_dev = NULL;
7595
7596 while (1) {
7597 do {
7598 IXJ *j;
7599 int result;
7600
7601 old_dev = dev;
7602 dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7603 ISAPNP_FUNCTION(func), old_dev);
7604 if (!dev || !dev->card)
7605 break;
7606 result = pnp_device_attach(dev);
7607 if (result < 0) {
7608 printk("pnp attach failed %d \n", result);
7609 break;
7610 }
7611 if (pnp_activate_dev(dev) < 0) {
7612 printk("pnp activate failed (out of resources?)\n");
7613 pnp_device_detach(dev);
7614 return -ENOMEM;
7615 }
7616
7617 if (!pnp_port_valid(dev, 0)) {
7618 pnp_device_detach(dev);
7619 return -ENODEV;
7620 }
7621
7622 j = new_ixj(pnp_port_start(dev, 0));
7623 if (!j)
7624 break;
7625
7626 if (func != 0x110)
7627 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7628
7629 switch (func) {
7630 case (0x110):
7631 j->cardtype = QTI_PHONEJACK;
7632 break;
7633 case (0x310):
7634 j->cardtype = QTI_LINEJACK;
7635 break;
7636 case (0x410):
7637 j->cardtype = QTI_PHONEJACK_LITE;
7638 break;
7639 }
7640 j->board = *cnt;
7641 probe = ixj_selfprobe(j);
7642 if(!probe) {
7643 j->serial = dev->card->serial;
7644 j->dev = dev;
7645 switch (func) {
7646 case 0x110:
7647 printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7648 break;
7649 case 0x310:
7650 printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7651 break;
7652 case 0x410:
7653 printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7654 break;
7655 }
7656 }
7657 ++*cnt;
7658 } while (dev);
7659 if (func == 0x410)
7660 break;
7661 if (func == 0x310)
7662 func = 0x410;
7663 if (func == 0x110)
7664 func = 0x310;
7665 dev = NULL;
7666 }
7667 return probe;
7668}
7669
7670static int __init ixj_probe_isa(int *cnt)
7671{
7672 int i, probe;
7673
7674 /* Use passed parameters for older kernels without PnP */
7675 for (i = 0; i < IXJMAX; i++) {
7676 if (dspio[i]) {
7677 IXJ *j = new_ixj(dspio[i]);
7678
7679 if (!j)
7680 break;
7681
7682 j->XILINXbase = xio[i];
7683 j->cardtype = 0;
7684
7685 j->board = *cnt;
7686 probe = ixj_selfprobe(j);
7687 j->dev = NULL;
7688 ++*cnt;
7689 }
7690 }
7691 return 0;
7692}
7693
7694static int __init ixj_probe_pci(int *cnt)
7695{
7696 struct pci_dev *pci = NULL;
7697 int i, probe = 0;
7698 IXJ *j = NULL;
7699
7700 for (i = 0; i < IXJMAX - *cnt; i++) {
Surya6de2d202007-05-08 00:25:57 -0700[diff] [blame]7701 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
Ben Collinsd77f09e2006-10-18 08:45:30 -0400[diff] [blame]7702 PCI_DEVICE_ID_QUICKNET_XJ, pci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7703 if (!pci)
7704 break;
7705
7706 if (pci_enable_device(pci))
7707 break;
7708 j = new_ixj(pci_resource_start(pci, 0));
7709 if (!j)
7710 break;
7711
7712 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7713 j->XILINXbase = j->DSPbase + 0x10;
7714 j->cardtype = QTI_PHONEJACK_PCI;
7715 j->board = *cnt;
7716 probe = ixj_selfprobe(j);
7717 if (!probe)
7718 printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7719 ++*cnt;
7720 }
Surya6de2d202007-05-08 00:25:57 -0700[diff] [blame]7721 pci_dev_put(pci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7722 return probe;
7723}
7724
7725static int __init ixj_init(void)
7726{
7727 int cnt = 0;
7728 int probe = 0;
7729
7730 cnt = 0;
7731
7732 /* These might be no-ops, see above. */
7733 if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7734 return probe;
7735 }
7736 if ((probe = ixj_probe_isa(&cnt)) < 0) {
7737 return probe;
7738 }
7739 if ((probe = ixj_probe_pci(&cnt)) < 0) {
7740 return probe;
7741 }
Domen Puncerfba478b2005-05-05 16:16:13 -0700[diff] [blame]7742 printk(KERN_INFO "ixj driver initialized.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700[diff] [blame]7743 create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7744 return probe;
7745}
7746
7747module_init(ixj_init);
7748module_exit(ixj_exit);
7749
7750static void DAA_Coeff_US(IXJ *j)
7751{
7752 int i;
7753
7754 j->daa_country = DAA_US;
7755 /*----------------------------------------------- */
7756 /* CAO */
7757 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7758 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7759 }
7760
7761/* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7762 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7763 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7764 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7765 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7766 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7767 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7768 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7769 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7770/* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7771 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7772 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7773 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7774 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7775 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7776 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7777 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7778 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7779/* Bytes for FRX-filter (08): 03,8F,48,F2,8F,48,70,08 */
7780 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7781 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7782 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7783 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7784 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7785 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7786 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7787 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7788/* Bytes for FRR-filter (07): 04,8F,38,7F,9B,EA,B0,08 */
7789 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7790 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7791 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7792 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7793 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7794 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7795 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7796 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7797/* Bytes for AX-filter (0A): 16,55,DD,CA */
7798 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7799 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7800 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7801 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7802/* Bytes for AR-filter (09): 52,D3,11,42 */
7803 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7804 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7805 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7806 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7807/* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7808 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7809 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7810 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7811 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7812 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7813 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7814 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7815 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7816/* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7817 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7818 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7819 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7820 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7821 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7822 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7823 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7824 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7825/* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7826 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7827 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7828 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7829 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7830 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7831 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7832 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7833 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7834/* ; (10K, 0.68uF) */
7835 /* */
7836 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7837 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7838 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7839 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7840 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7841 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7842 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7843 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7844 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7845 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7846 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7847 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7848 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7849 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7850 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7851 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7852 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7853 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7854
7855 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7856 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7857 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7858 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7859 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7860
7861 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7862/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7863/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7864/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7865/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7866/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7867/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7868/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7869/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7870 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7871/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7872/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7873/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7874/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7875/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7876/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7877/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7878/* j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7879/* */
7880 /* Levelmetering Ringing (0D):B2,45,0F,8E */
7881/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7882/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7883/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7884/* j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7885
7886 /* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
7887 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7888 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7889 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7890 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7891 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7892 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7893 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7894 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7895/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
7896 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7897 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7898 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7899 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7900 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7901 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7902 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7903 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7904/* */
7905 /* ;CR Registers */
7906 /* Config. Reg. 0 (filters) (cr0):FE ; CLK gen. by crystal */
7907 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7908/* Config. Reg. 1 (dialing) (cr1):05 */
7909 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7910/* Config. Reg. 2 (caller ID) (cr2):04 */
7911 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7912/* Config. Reg. 3 (testloops) (cr3):03 ; SEL Bit==0, HP-disabled */
7913 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7914/* Config. Reg. 4 (analog gain) (cr4):02 */
7915 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7916 /* Config. Reg. 5 (Version) (cr5):02 */
7917 /* Config. Reg. 6 (Reserved) (cr6):00 */
7918 /* Config. Reg. 7 (Reserved) (cr7):00 */
7919 /* */
7920 /* ;xr Registers */
7921 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
7922
7923 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
7924 /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7925
7926 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7927/* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7928 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7929/* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off == 1 */
7930 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B; /*0x32; */
7931 /* Ext. Reg. 4 (Cadence) (xr4):00 */
7932
7933 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7934/* Ext. Reg. 5 (Ring timer) (xr5):22 */
7935 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7936/* Ext. Reg. 6 (Power State) (xr6):00 */
7937 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7938/* Ext. Reg. 7 (Vdd) (xr7):40 */
7939 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
7940 /* */
7941 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
7942 /* 12,33,5A,C3 ; 770 Hz */
7943 /* 13,3C,5B,32 ; 852 Hz */
7944 /* 1D,1B,5C,CC ; 941 Hz */
7945
7946 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7947 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7948 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7949 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7950/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
7951 /* EC,1D,52,22 ; 1336 Hz */
7952 /* AA,AC,51,D2 ; 1477 Hz */
7953 /* 9B,3B,51,25 ; 1633 Hz */
7954 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7955 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7956 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7957 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7958}
7959
7960static void DAA_Coeff_UK(IXJ *j)
7961{
7962 int i;
7963
7964 j->daa_country = DAA_UK;
7965 /*----------------------------------------------- */
7966 /* CAO */
7967 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7968 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7969 }
7970
7971/* Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7972 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7973 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7974 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7975 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7976 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7977 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7978 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7979 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7980/* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7981 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7982 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7983 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7984 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7985 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7986 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7987 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7988 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7989/* Bytes for FRX-filter (08): 07,9B,ED,24,B2,A2,A0,08 */
7990 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7991 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7992 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7993 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7994 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7995 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7996 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7997 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7998/* Bytes for FRR-filter (07): 0F,92,F2,B2,87,D2,30,08 */
7999 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8000 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8001 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8002 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8003 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8004 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8005 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8006 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8007/* Bytes for AX-filter (0A): 1B,A5,DD,CA */
8008 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8009 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8010 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8011 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8012/* Bytes for AR-filter (09): E2,27,10,D6 */
8013 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8014 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8015 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8016 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8017/* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8018 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8019 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8020 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8021 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8022 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8023 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8024 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8025 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8026/* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8027 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8028 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8029 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8030 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8031 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8032 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8033 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8034 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8035/* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8036 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8037 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8038 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8039 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8040 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8041 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8042 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8043 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8044/* ; idle */
8045 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8046 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8047 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8048 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8049 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8050 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8051 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8052 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8053 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8054/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8055 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8056 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8057 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8058 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8059 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8060 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8061 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8062 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8063/* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V less possible? */
8064 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8065 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8066 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8067 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8068/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8069 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8070 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8071 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8072 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8073 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8074 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8075 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8076 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8077/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8078 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8079 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8080 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8081 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8082 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8083 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8084 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8085 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8086/* ;CR Registers */
8087 /* Config. Reg. 0 (filters) (cr0):FF */
8088 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8089/* Config. Reg. 1 (dialing) (cr1):05 */
8090 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8091/* Config. Reg. 2 (caller ID) (cr2):04 */
8092 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8093/* Config. Reg. 3 (testloops) (cr3):00 ; */
8094 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8095/* Config. Reg. 4 (analog gain) (cr4):02 */
8096 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8097 /* Config. Reg. 5 (Version) (cr5):02 */
8098 /* Config. Reg. 6 (Reserved) (cr6):00 */
8099 /* Config. Reg. 7 (Reserved) (cr7):00 */
8100 /* ;xr Registers */
8101 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8102
8103 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8104 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8105
8106 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8107 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8108
8109 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8110/* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8111 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8112/* Ext. Reg. 4 (Cadence) (xr4):00 */
8113 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8114/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8115 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8116/* Ext. Reg. 6 (Power State) (xr6):00 */
8117 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8118/* Ext. Reg. 7 (Vdd) (xr7):46 */
8119 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8120 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8121 /* 12,33,5A,C3 ; 770 Hz */
8122 /* 13,3C,5B,32 ; 852 Hz */
8123 /* 1D,1B,5C,CC ; 941 Hz */
8124
8125 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8126 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8127 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8128 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8129/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8130 /* EC,1D,52,22 ; 1336 Hz */
8131 /* AA,AC,51,D2 ; 1477 Hz */
8132 /* 9B,3B,51,25 ; 1633 Hz */
8133 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8134 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8135 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8136 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8137}
8138
8139
8140static void DAA_Coeff_France(IXJ *j)
8141{
8142 int i;
8143
8144 j->daa_country = DAA_FRANCE;
8145 /*----------------------------------------------- */
8146 /* CAO */
8147 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8148 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8149 }
8150
8151/* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8152 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8153 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8154 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8155 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8156 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8157 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8158 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8159 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8160/* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8161 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8162 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8163 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8164 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8165 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8166 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8167 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8168 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8169/* Bytes for FRX-filter (08): 07,9A,28,F6,23,4A,B0,08 */
8170 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8171 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8172 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8173 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8174 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8175 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8176 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8177 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8178/* Bytes for FRR-filter (07): 03,8F,F9,2F,9E,FA,20,08 */
8179 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8180 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8181 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8182 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8183 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8184 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8185 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8186 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8187/* Bytes for AX-filter (0A): 16,B5,DD,CA */
8188 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8189 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8190 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8191 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8192/* Bytes for AR-filter (09): 52,C7,10,D6 */
8193 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8194 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8195 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8196 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8197/* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8198 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8199 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8200 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8201 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8202 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8203 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8204 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8205 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8206/* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8207 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8208 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8209 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8210 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8211 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8212 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8213 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8214 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8215/* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8216 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8217 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8218 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8219 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8220 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8221 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8222 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8223 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8224/* ; idle */
8225 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8226 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8227 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8228 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8229 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8230 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8231 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8232 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8233 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8234/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8235 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8236 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8237 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8238 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8239 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8240 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8241 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8242 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8243/* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8244 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8245 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8246 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8247 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8248/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8249 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8250 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8251 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8252 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8253 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8254 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8255 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8256 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8257/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8258 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8259 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8260 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8261 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8262 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8263 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8264 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8265 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8266/* ;CR Registers */
8267 /* Config. Reg. 0 (filters) (cr0):FF */
8268 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8269/* Config. Reg. 1 (dialing) (cr1):05 */
8270 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8271/* Config. Reg. 2 (caller ID) (cr2):04 */
8272 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8273/* Config. Reg. 3 (testloops) (cr3):00 ; */
8274 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8275/* Config. Reg. 4 (analog gain) (cr4):02 */
8276 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8277 /* Config. Reg. 5 (Version) (cr5):02 */
8278 /* Config. Reg. 6 (Reserved) (cr6):00 */
8279 /* Config. Reg. 7 (Reserved) (cr7):00 */
8280 /* ;xr Registers */
8281 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8282
8283 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8284 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8285
8286 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8287 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8288
8289 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8290/* Ext. Reg. 3 (DC Char) (xr3):36 ; */
8291 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8292/* Ext. Reg. 4 (Cadence) (xr4):00 */
8293 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8294/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8295 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8296/* Ext. Reg. 6 (Power State) (xr6):00 */
8297 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8298/* Ext. Reg. 7 (Vdd) (xr7):46 */
8299 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46; /* 0x46 ??? Should it be 0x00? */
8300 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8301 /* 12,33,5A,C3 ; 770 Hz */
8302 /* 13,3C,5B,32 ; 852 Hz */
8303 /* 1D,1B,5C,CC ; 941 Hz */
8304
8305 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8306 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8307 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8308 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8309/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8310 /* EC,1D,52,22 ; 1336 Hz */
8311 /* AA,AC,51,D2 ; 1477 Hz */
8312 /* 9B,3B,51,25 ; 1633 Hz */
8313 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8314 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8315 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8316 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8317}
8318
8319
8320static void DAA_Coeff_Germany(IXJ *j)
8321{
8322 int i;
8323
8324 j->daa_country = DAA_GERMANY;
8325 /*----------------------------------------------- */
8326 /* CAO */
8327 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8328 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8329 }
8330
8331/* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8332 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8333 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8334 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8335 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8336 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8337 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8338 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8339 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8340/* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8341 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8342 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8343 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8344 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8345 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8346 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8347 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8348 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8349/* Bytes for FRX-filter (08): 07,AA,E2,34,24,89,20,08 */
8350 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8351 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8352 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8353 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8354 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8355 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8356 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8357 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8358/* Bytes for FRR-filter (07): 02,87,FA,37,9A,CA,B0,08 */
8359 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8360 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8361 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8362 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8363 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8364 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8365 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8366 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8367/* Bytes for AX-filter (0A): 72,D5,DD,CA */
8368 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8369 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8370 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8371 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8372/* Bytes for AR-filter (09): 72,42,13,4B */
8373 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8374 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8375 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8376 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8377/* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8378 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8379 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8380 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8381 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8382 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8383 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8384 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8385 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8386/* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8387 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8388 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8389 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8390 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8391 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8392 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8393 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8394 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8395/* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8396 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8397 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8398 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8399 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8400 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8401 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8402 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8403 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8404/* ; (10K, 0.68uF) */
8405 /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8406 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8407 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8408 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8409 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8410 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8411 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8412 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8413 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8414/* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8415 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8416 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8417 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8418 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8419 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8420 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8421 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8422 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8423/* Levelmetering Ringing (0D):B2,45,0F,8E */
8424 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8425 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8426 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8427 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8428/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8429 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8430 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8431 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8432 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8433 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8434 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8435 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8436 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8437/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8438 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8439 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8440 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8441 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8442 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8443 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8444 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8445 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8446/* ;CR Registers */
8447 /* Config. Reg. 0 (filters) (cr0):FF ; all Filters enabled, CLK from ext. source */
8448 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8449/* Config. Reg. 1 (dialing) (cr1):05 ; Manual Ring, Ring metering enabled */
8450 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8451/* Config. Reg. 2 (caller ID) (cr2):04 ; Analog Gain 0dB, FSC internal */
8452 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8453/* Config. Reg. 3 (testloops) (cr3):00 ; SEL Bit==0, HP-enabled */
8454 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8455/* Config. Reg. 4 (analog gain) (cr4):02 */
8456 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8457 /* Config. Reg. 5 (Version) (cr5):02 */
8458 /* Config. Reg. 6 (Reserved) (cr6):00 */
8459 /* Config. Reg. 7 (Reserved) (cr7):00 */
8460 /* ;xr Registers */
8461 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8462
8463 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8464 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8465
8466 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8467 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8468
8469 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8470/* Ext. Reg. 3 (DC Char) (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8471 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8472/* Ext. Reg. 4 (Cadence) (xr4):00 */
8473 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8474/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8475 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8476/* Ext. Reg. 6 (Power State) (xr6):00 */
8477 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8478/* Ext. Reg. 7 (Vdd) (xr7):40 ; VDD=4.25 V */
8479 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8480 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8481 /* 12,33,5A,C3 ; 770 Hz */
8482 /* 13,3C,5B,32 ; 852 Hz */
8483 /* 1D,1B,5C,CC ; 941 Hz */
8484
8485 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8486 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8487 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8488 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8489/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8490 /* EC,1D,52,22 ; 1336 Hz */
8491 /* AA,AC,51,D2 ; 1477 Hz */
8492 /* 9B,3B,51,25 ; 1633 Hz */
8493 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8494 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8495 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8496 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8497}
8498
8499
8500static void DAA_Coeff_Australia(IXJ *j)
8501{
8502 int i;
8503
8504 j->daa_country = DAA_AUSTRALIA;
8505 /*----------------------------------------------- */
8506 /* CAO */
8507 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8508 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8509 }
8510
8511/* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8512 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8513 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8514 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8515 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8516 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8517 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8518 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8519 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8520/* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8521 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8522 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8523 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8524 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8525 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8526 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8527 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8528 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8529/* Bytes for FRX-filter (08): 07,96,E2,34,32,9B,30,08 */
8530 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8531 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8532 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8533 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8534 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8535 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8536 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8537 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8538/* Bytes for FRR-filter (07): 0F,9A,E9,2F,22,CC,A0,08 */
8539 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8540 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8541 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8542 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8543 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8544 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8545 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8546 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8547/* Bytes for AX-filter (0A): CB,45,DD,CA */
8548 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8549 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8550 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8551 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8552/* Bytes for AR-filter (09): 1B,67,10,D6 */
8553 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8554 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8555 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8556 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8557/* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8558 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8559 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8560 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8561 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8562 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8563 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8564 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8565 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8566/* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8567 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8568 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8569 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8570 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8571 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8572 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8573 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8574 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8575/* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8576 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8577 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8578 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8579 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8580 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8581 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8582 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8583 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8584/* ; idle */
8585 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8586 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8587 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8588 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8589 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8590 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8591 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8592 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8593 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8594/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8595 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8596 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8597 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8598 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8599 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8600 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8601 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8602 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8603/* Levelmetering Ringing (0D):32,45,B5,84 ; 50Hz 20V */
8604 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8605 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8606 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8607 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8608/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8609 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8610 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8611 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8612 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8613 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8614 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8615 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8616 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8617/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8618 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8619 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8620 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8621 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8622 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8623 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8624 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8625 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8626/* ;CR Registers */
8627 /* Config. Reg. 0 (filters) (cr0):FF */
8628 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8629/* Config. Reg. 1 (dialing) (cr1):05 */
8630 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8631/* Config. Reg. 2 (caller ID) (cr2):04 */
8632 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8633/* Config. Reg. 3 (testloops) (cr3):00 ; */
8634 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8635/* Config. Reg. 4 (analog gain) (cr4):02 */
8636 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8637 /* Config. Reg. 5 (Version) (cr5):02 */
8638 /* Config. Reg. 6 (Reserved) (cr6):00 */
8639 /* Config. Reg. 7 (Reserved) (cr7):00 */
8640 /* ;xr Registers */
8641 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8642
8643 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8644 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8645
8646 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8647 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8648
8649 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8650/* Ext. Reg. 3 (DC Char) (xr3):2B ; */
8651 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8652/* Ext. Reg. 4 (Cadence) (xr4):00 */
8653 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8654/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8655 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8656/* Ext. Reg. 6 (Power State) (xr6):00 */
8657 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8658/* Ext. Reg. 7 (Vdd) (xr7):40 */
8659 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8660
8661 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8662 /* 12,33,5A,C3 ; 770 Hz */
8663 /* 13,3C,5B,32 ; 852 Hz */
8664 /* 1D,1B,5C,CC ; 941 Hz */
8665 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8666 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8667 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8668 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8669
8670 /* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8671 /* EC,1D,52,22 ; 1336 Hz */
8672 /* AA,AC,51,D2 ; 1477 Hz */
8673 /* 9B,3B,51,25 ; 1633 Hz */
8674 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8675 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8676 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8677 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8678}
8679
8680static void DAA_Coeff_Japan(IXJ *j)
8681{
8682 int i;
8683
8684 j->daa_country = DAA_JAPAN;
8685 /*----------------------------------------------- */
8686 /* CAO */
8687 for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8688 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8689 }
8690
8691/* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8692 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8693 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8694 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8695 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8696 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8697 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8698 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8699 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8700/* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8701 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8702 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8703 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8704 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8705 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8706 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8707 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8708 j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8709/* Bytes for FRX-filter (08): 02,8F,68,77,9C,58,F0,08 */
8710 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8711 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8712 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8713 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8714 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8715 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8716 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8717 j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8718/* Bytes for FRR-filter (07): 03,8F,38,73,87,EA,20,08 */
8719 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8720 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8721 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8722 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8723 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8724 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8725 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8726 j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8727/* Bytes for AX-filter (0A): 51,C5,DD,CA */
8728 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8729 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8730 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8731 j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8732/* Bytes for AR-filter (09): 25,A7,10,D6 */
8733 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8734 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8735 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8736 j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8737/* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8738 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8739 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8740 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8741 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8742 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8743 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8744 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8745 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8746/* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8747 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8748 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8749 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8750 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8751 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8752 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8753 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8754 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8755/* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8756 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8757 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8758 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8759 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8760 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8761 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8762 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8763 j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8764/* ; idle */
8765 /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8766 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8767 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8768 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8769 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8770 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8771 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8772 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8773 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8774/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8775 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8776 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8777 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8778 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8779 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8780 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8781 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8782 j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8783/* Levelmetering Ringing (0D):AA,35,0F,8E ; 25Hz 30V ????????? */
8784 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8785 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8786 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8787 j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8788/* Caller ID 1st Tone (0E):CA,0E,CA,09,99,99,99,99 */
8789 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8790 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8791 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8792 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8793 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8794 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8795 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8796 j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8797/* Caller ID 2nd Tone (0F):FD,B5,BA,07,DA,00,00,00 */
8798 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8799 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8800 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8801 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8802 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8803 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8804 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8805 j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8806/* ;CR Registers */
8807 /* Config. Reg. 0 (filters) (cr0):FF */
8808 j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8809/* Config. Reg. 1 (dialing) (cr1):05 */
8810 j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8811/* Config. Reg. 2 (caller ID) (cr2):04 */
8812 j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8813/* Config. Reg. 3 (testloops) (cr3):00 ; */
8814 j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8815/* Config. Reg. 4 (analog gain) (cr4):02 */
8816 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8817 /* Config. Reg. 5 (Version) (cr5):02 */
8818 /* Config. Reg. 6 (Reserved) (cr6):00 */
8819 /* Config. Reg. 7 (Reserved) (cr7):00 */
8820 /* ;xr Registers */
8821 /* Ext. Reg. 0 (Interrupt Reg.) (xr0):02 */
8822
8823 j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02; /* SO_1 set to '1' because it is inverted. */
8824 /* Ext. Reg. 1 (Interrupt enable) (xr1):1C */
8825
8826 j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C; /* RING, Caller ID, VDD_OK */
8827 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
8828
8829 j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8830/* Ext. Reg. 3 (DC Char) (xr3):22 ; */
8831 j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8832/* Ext. Reg. 4 (Cadence) (xr4):00 */
8833 j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8834/* Ext. Reg. 5 (Ring timer) (xr5):22 */
8835 j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8836/* Ext. Reg. 6 (Power State) (xr6):00 */
8837 j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8838/* Ext. Reg. 7 (Vdd) (xr7):40 */
8839 j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40; /* 0x40 ??? Should it be 0x00? */
8840 /* DTMF Tone 1 (0B): 11,B3,5A,2C ; 697 Hz */
8841 /* 12,33,5A,C3 ; 770 Hz */
8842 /* 13,3C,5B,32 ; 852 Hz */
8843 /* 1D,1B,5C,CC ; 941 Hz */
8844
8845 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8846 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8847 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8848 j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8849/* DTMF Tone 2 (0C): 32,32,52,B3 ; 1209 Hz */
8850 /* EC,1D,52,22 ; 1336 Hz */
8851 /* AA,AC,51,D2 ; 1477 Hz */
8852 /* 9B,3B,51,25 ; 1633 Hz */
8853 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8854 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8855 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8856 j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8857}
8858
8859static s16 tone_table[][19] =
8860{
8861 { /* f20_50[] 11 */
8862 32538, /* A1 = 1.985962 */
8863 -32325, /* A2 = -0.986511 */
8864 -343, /* B2 = -0.010493 */
8865 0, /* B1 = 0 */
8866 343, /* B0 = 0.010493 */
8867 32619, /* A1 = 1.990906 */
8868 -32520, /* A2 = -0.992462 */
8869 19179, /* B2 = 0.585327 */
8870 -19178, /* B1 = -1.170593 */
8871 19179, /* B0 = 0.585327 */
8872 32723, /* A1 = 1.997314 */
8873 -32686, /* A2 = -0.997528 */
8874 9973, /* B2 = 0.304352 */
8875 -9955, /* B1 = -0.607605 */
8876 9973, /* B0 = 0.304352 */
8877 7, /* Internal filter scaling */
8878 159, /* Minimum in-band energy threshold */
8879 21, /* 21/32 in-band to broad-band ratio */
8880 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8881 },
8882 { /* f133_200[] 12 */
8883 32072, /* A1 = 1.95752 */
8884 -31896, /* A2 = -0.973419 */
8885 -435, /* B2 = -0.013294 */
8886 0, /* B1 = 0 */
8887 435, /* B0 = 0.013294 */
8888 32188, /* A1 = 1.9646 */
8889 -32400, /* A2 = -0.98877 */
8890 15139, /* B2 = 0.462036 */
8891 -14882, /* B1 = -0.908356 */
8892 15139, /* B0 = 0.462036 */
8893 32473, /* A1 = 1.981995 */
8894 -32524, /* A2 = -0.992584 */
8895 23200, /* B2 = 0.708008 */
8896 -23113, /* B1 = -1.410706 */
8897 23200, /* B0 = 0.708008 */
8898 7, /* Internal filter scaling */
8899 159, /* Minimum in-band energy threshold */
8900 21, /* 21/32 in-band to broad-band ratio */
8901 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8902 },
8903 { /* f300 13 */
8904 31769, /* A1 = -1.939026 */
8905 -32584, /* A2 = 0.994385 */
8906 -475, /* B2 = -0.014522 */
8907 0, /* B1 = 0.000000 */
8908 475, /* B0 = 0.014522 */
8909 31789, /* A1 = -1.940247 */
8910 -32679, /* A2 = 0.997284 */
8911 17280, /* B2 = 0.527344 */
8912 -16865, /* B1 = -1.029358 */
8913 17280, /* B0 = 0.527344 */
8914 31841, /* A1 = -1.943481 */
8915 -32681, /* A2 = 0.997345 */
8916 543, /* B2 = 0.016579 */
8917 -525, /* B1 = -0.032097 */
8918 543, /* B0 = 0.016579 */
8919 5, /* Internal filter scaling */
8920 159, /* Minimum in-band energy threshold */
8921 21, /* 21/32 in-band to broad-band ratio */
8922 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8923 },
8924 { /* f300_420[] 14 */
8925 30750, /* A1 = 1.876892 */
8926 -31212, /* A2 = -0.952515 */
8927 -804, /* B2 = -0.024541 */
8928 0, /* B1 = 0 */
8929 804, /* B0 = 0.024541 */
8930 30686, /* A1 = 1.872925 */
8931 -32145, /* A2 = -0.980988 */
8932 14747, /* B2 = 0.450043 */
8933 -13703, /* B1 = -0.836395 */
8934 14747, /* B0 = 0.450043 */
8935 31651, /* A1 = 1.931824 */
8936 -32321, /* A2 = -0.986389 */
8937 24425, /* B2 = 0.745422 */
8938 -23914, /* B1 = -1.459595 */
8939 24427, /* B0 = 0.745483 */
8940 7, /* Internal filter scaling */
8941 159, /* Minimum in-band energy threshold */
8942 21, /* 21/32 in-band to broad-band ratio */
8943 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8944 },
8945 { /* f330 15 */
8946 31613, /* A1 = -1.929565 */
8947 -32646, /* A2 = 0.996277 */
8948 -185, /* B2 = -0.005657 */
8949 0, /* B1 = 0.000000 */
8950 185, /* B0 = 0.005657 */
8951 31620, /* A1 = -1.929932 */
8952 -32713, /* A2 = 0.998352 */
8953 19253, /* B2 = 0.587585 */
8954 -18566, /* B1 = -1.133179 */
8955 19253, /* B0 = 0.587585 */
8956 31674, /* A1 = -1.933228 */
8957 -32715, /* A2 = 0.998413 */
8958 2575, /* B2 = 0.078590 */
8959 -2495, /* B1 = -0.152283 */
8960 2575, /* B0 = 0.078590 */
8961 5, /* Internal filter scaling */
8962 159, /* Minimum in-band energy threshold */
8963 21, /* 21/32 in-band to broad-band ratio */
8964 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8965 },
8966 { /* f300_425[] 16 */
8967 30741, /* A1 = 1.876282 */
8968 -31475, /* A2 = -0.960541 */
8969 -703, /* B2 = -0.021484 */
8970 0, /* B1 = 0 */
8971 703, /* B0 = 0.021484 */
8972 30688, /* A1 = 1.873047 */
8973 -32248, /* A2 = -0.984161 */
8974 14542, /* B2 = 0.443787 */
8975 -13523, /* B1 = -0.825439 */
8976 14542, /* B0 = 0.443817 */
8977 31494, /* A1 = 1.922302 */
8978 -32366, /* A2 = -0.987762 */
8979 21577, /* B2 = 0.658508 */
8980 -21013, /* B1 = -1.282532 */
8981 21577, /* B0 = 0.658508 */
8982 7, /* Internal filter scaling */
8983 159, /* Minimum in-band energy threshold */
8984 21, /* 21/32 in-band to broad-band ratio */
8985 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8986 },
8987 { /* f330_440[] 17 */
8988 30627, /* A1 = 1.869324 */
8989 -31338, /* A2 = -0.95636 */
8990 -843, /* B2 = -0.025749 */
8991 0, /* B1 = 0 */
8992 843, /* B0 = 0.025749 */
8993 30550, /* A1 = 1.864685 */
8994 -32221, /* A2 = -0.983337 */
8995 13594, /* B2 = 0.414886 */
8996 -12589, /* B1 = -0.768402 */
8997 13594, /* B0 = 0.414886 */
8998 31488, /* A1 = 1.921936 */
8999 -32358, /* A2 = -0.987518 */
9000 24684, /* B2 = 0.753296 */
9001 -24029, /* B1 = -1.466614 */
9002 24684, /* B0 = 0.753296 */
9003 7, /* Internal filter scaling */
9004 159, /* Minimum in-band energy threshold */
9005 21, /* 21/32 in-band to broad-band ratio */
9006 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9007 },
9008 { /* f340 18 */
9009 31546, /* A1 = -1.925476 */
9010 -32646, /* A2 = 0.996277 */
9011 -445, /* B2 = -0.013588 */
9012 0, /* B1 = 0.000000 */
9013 445, /* B0 = 0.013588 */
9014 31551, /* A1 = -1.925781 */
9015 -32713, /* A2 = 0.998352 */
9016 23884, /* B2 = 0.728882 */
9017 -22979, /* B1 = -1.402527 */
9018 23884, /* B0 = 0.728882 */
9019 31606, /* A1 = -1.929138 */
9020 -32715, /* A2 = 0.998413 */
9021 863, /* B2 = 0.026367 */
9022 -835, /* B1 = -0.050985 */
9023 863, /* B0 = 0.026367 */
9024 5, /* Internal filter scaling */
9025 159, /* Minimum in-band energy threshold */
9026 21, /* 21/32 in-band to broad-band ratio */
9027 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9028 },
9029 { /* f350_400[] 19 */
9030 31006, /* A1 = 1.892517 */
9031 -32029, /* A2 = -0.977448 */
9032 -461, /* B2 = -0.014096 */
9033 0, /* B1 = 0 */
9034 461, /* B0 = 0.014096 */
9035 30999, /* A1 = 1.892029 */
9036 -32487, /* A2 = -0.991455 */
9037 11325, /* B2 = 0.345612 */
9038 -10682, /* B1 = -0.651978 */
9039 11325, /* B0 = 0.345612 */
9040 31441, /* A1 = 1.919067 */
9041 -32526, /* A2 = -0.992615 */
9042 24324, /* B2 = 0.74231 */
9043 -23535, /* B1 = -1.436523 */
9044 24324, /* B0 = 0.74231 */
9045 7, /* Internal filter scaling */
9046 159, /* Minimum in-band energy threshold */
9047 21, /* 21/32 in-band to broad-band ratio */
9048 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9049 },
9050 { /* f350_440[] */
9051 30634, /* A1 = 1.869751 */
9052 -31533, /* A2 = -0.962341 */
9053 -680, /* B2 = -0.020782 */
9054 0, /* B1 = 0 */
9055 680, /* B0 = 0.020782 */
9056 30571, /* A1 = 1.865906 */
9057 -32277, /* A2 = -0.985016 */
9058 12894, /* B2 = 0.393524 */
9059 -11945, /* B1 = -0.729065 */
9060 12894, /* B0 = 0.393524 */
9061 31367, /* A1 = 1.91449 */
9062 -32379, /* A2 = -0.988129 */
9063 23820, /* B2 = 0.726929 */
9064 -23104, /* B1 = -1.410217 */
9065 23820, /* B0 = 0.726929 */
9066 7, /* Internal filter scaling */
9067 159, /* Minimum in-band energy threshold */
9068 21, /* 21/32 in-band to broad-band ratio */
9069 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9070 },
9071 { /* f350_450[] */
9072 30552, /* A1 = 1.864807 */
9073 -31434, /* A2 = -0.95929 */
9074 -690, /* B2 = -0.021066 */
9075 0, /* B1 = 0 */
9076 690, /* B0 = 0.021066 */
9077 30472, /* A1 = 1.859924 */
9078 -32248, /* A2 = -0.984161 */
9079 13385, /* B2 = 0.408478 */
9080 -12357, /* B1 = -0.754242 */
9081 13385, /* B0 = 0.408478 */
9082 31358, /* A1 = 1.914001 */
9083 -32366, /* A2 = -0.987732 */
9084 26488, /* B2 = 0.80835 */
9085 -25692, /* B1 = -1.568176 */
9086 26490, /* B0 = 0.808411 */
9087 7, /* Internal filter scaling */
9088 159, /* Minimum in-band energy threshold */
9089 21, /* 21/32 in-band to broad-band ratio */
9090 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9091 },
9092 { /* f360 */
9093 31397, /* A1 = -1.916321 */
9094 -32623, /* A2 = 0.995605 */
9095 -117, /* B2 = -0.003598 */
9096 0, /* B1 = 0.000000 */
9097 117, /* B0 = 0.003598 */
9098 31403, /* A1 = -1.916687 */
9099 -32700, /* A2 = 0.997925 */
9100 3388, /* B2 = 0.103401 */
9101 -3240, /* B1 = -0.197784 */
9102 3388, /* B0 = 0.103401 */
9103 31463, /* A1 = -1.920410 */
9104 -32702, /* A2 = 0.997986 */
9105 13346, /* B2 = 0.407288 */
9106 -12863, /* B1 = -0.785126 */
9107 13346, /* B0 = 0.407288 */
9108 5, /* Internal filter scaling */
9109 159, /* Minimum in-band energy threshold */
9110 21, /* 21/32 in-band to broad-band ratio */
9111 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9112 },
9113 { /* f380_420[] */
9114 30831, /* A1 = 1.881775 */
9115 -32064, /* A2 = -0.978546 */
9116 -367, /* B2 = -0.01122 */
9117 0, /* B1 = 0 */
9118 367, /* B0 = 0.01122 */
9119 30813, /* A1 = 1.880737 */
9120 -32456, /* A2 = -0.990509 */
9121 11068, /* B2 = 0.337769 */
9122 -10338, /* B1 = -0.631042 */
9123 11068, /* B0 = 0.337769 */
9124 31214, /* A1 = 1.905212 */
9125 -32491, /* A2 = -0.991577 */
9126 16374, /* B2 = 0.499695 */
9127 -15781, /* B1 = -0.963196 */
9128 16374, /* B0 = 0.499695 */
9129 7, /* Internal filter scaling */
9130 159, /* Minimum in-band energy threshold */
9131 21, /* 21/32 in-band to broad-band ratio */
9132 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9133 },
9134 { /* f392 */
9135 31152, /* A1 = -1.901428 */
9136 -32613, /* A2 = 0.995300 */
9137 -314, /* B2 = -0.009605 */
9138 0, /* B1 = 0.000000 */
9139 314, /* B0 = 0.009605 */
9140 31156, /* A1 = -1.901672 */
9141 -32694, /* A2 = 0.997742 */
9142 28847, /* B2 = 0.880371 */
9143 -2734, /* B1 = -0.166901 */
9144 28847, /* B0 = 0.880371 */
9145 31225, /* A1 = -1.905823 */
9146 -32696, /* A2 = 0.997803 */
9147 462, /* B2 = 0.014108 */
9148 -442, /* B1 = -0.027019 */
9149 462, /* B0 = 0.014108 */
9150 5, /* Internal filter scaling */
9151 159, /* Minimum in-band energy threshold */
9152 21, /* 21/32 in-band to broad-band ratio */
9153 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9154 },
9155 { /* f400_425[] */
9156 30836, /* A1 = 1.882141 */
9157 -32296, /* A2 = -0.985596 */
9158 -324, /* B2 = -0.009903 */
9159 0, /* B1 = 0 */
9160 324, /* B0 = 0.009903 */
9161 30825, /* A1 = 1.881409 */
9162 -32570, /* A2 = -0.993958 */
9163 16847, /* B2 = 0.51416 */
9164 -15792, /* B1 = -0.963898 */
9165 16847, /* B0 = 0.51416 */
9166 31106, /* A1 = 1.89856 */
9167 -32584, /* A2 = -0.994415 */
9168 9579, /* B2 = 0.292328 */
9169 -9164, /* B1 = -0.559357 */
9170 9579, /* B0 = 0.292328 */
9171 7, /* Internal filter scaling */
9172 159, /* Minimum in-band energy threshold */
9173 21, /* 21/32 in-band to broad-band ratio */
9174 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9175 },
9176 { /* f400_440[] */
9177 30702, /* A1 = 1.873962 */
9178 -32134, /* A2 = -0.980682 */
9179 -517, /* B2 = -0.015793 */
9180 0, /* B1 = 0 */
9181 517, /* B0 = 0.015793 */
9182 30676, /* A1 = 1.872375 */
9183 -32520, /* A2 = -0.992462 */
9184 8144, /* B2 = 0.24855 */
9185 -7596, /* B1 = -0.463684 */
9186 8144, /* B0 = 0.24855 */
9187 31084, /* A1 = 1.897217 */
9188 -32547, /* A2 = -0.993256 */
9189 22713, /* B2 = 0.693176 */
9190 -21734, /* B1 = -1.326599 */
9191 22713, /* B0 = 0.693176 */
9192 7, /* Internal filter scaling */
9193 159, /* Minimum in-band energy threshold */
9194 21, /* 21/32 in-band to broad-band ratio */
9195 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9196 },
9197 { /* f400_450[] */
9198 30613, /* A1 = 1.86853 */
9199 -32031, /* A2 = -0.977509 */
9200 -618, /* B2 = -0.018866 */
9201 0, /* B1 = 0 */
9202 618, /* B0 = 0.018866 */
9203 30577, /* A1 = 1.866272 */
9204 -32491, /* A2 = -0.991577 */
9205 9612, /* B2 = 0.293335 */
9206 -8935, /* B1 = -0.54541 */
9207 9612, /* B0 = 0.293335 */
9208 31071, /* A1 = 1.896484 */
9209 -32524, /* A2 = -0.992584 */
9210 21596, /* B2 = 0.659058 */
9211 -20667, /* B1 = -1.261414 */
9212 21596, /* B0 = 0.659058 */
9213 7, /* Internal filter scaling */
9214 159, /* Minimum in-band energy threshold */
9215 21, /* 21/32 in-band to broad-band ratio */
9216 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9217 },
9218 { /* f420 */
9219 30914, /* A1 = -1.886841 */
9220 -32584, /* A2 = 0.994385 */
9221 -426, /* B2 = -0.013020 */
9222 0, /* B1 = 0.000000 */
9223 426, /* B0 = 0.013020 */
9224 30914, /* A1 = -1.886841 */
9225 -32679, /* A2 = 0.997314 */
9226 17520, /* B2 = 0.534668 */
9227 -16471, /* B1 = -1.005310 */
9228 17520, /* B0 = 0.534668 */
9229 31004, /* A1 = -1.892334 */
9230 -32683, /* A2 = 0.997406 */
9231 819, /* B2 = 0.025023 */
9232 -780, /* B1 = -0.047619 */
9233 819, /* B0 = 0.025023 */
9234 5, /* Internal filter scaling */
9235 159, /* Minimum in-band energy threshold */
9236 21, /* 21/32 in-band to broad-band ratio */
9237 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9238 },
9239#if 0
9240 { /* f425 */
9241 30881, /* A1 = -1.884827 */
9242 -32603, /* A2 = 0.994965 */
9243 -496, /* B2 = -0.015144 */
9244 0, /* B1 = 0.000000 */
9245 496, /* B0 = 0.015144 */
9246 30880, /* A1 = -1.884766 */
9247 -32692, /* A2 = 0.997711 */
9248 24767, /* B2 = 0.755859 */
9249 -23290, /* B1 = -1.421509 */
9250 24767, /* B0 = 0.755859 */
9251 30967, /* A1 = -1.890076 */
9252 -32694, /* A2 = 0.997772 */
9253 728, /* B2 = 0.022232 */
9254 -691, /* B1 = -0.042194 */
9255 728, /* B0 = 0.022232 */
9256 5, /* Internal filter scaling */
9257 159, /* Minimum in-band energy threshold */
9258 21, /* 21/32 in-band to broad-band ratio */
9259 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9260 },
9261#else
9262 {
9263 30850,
9264 -32534,
9265 -504,
9266 0,
9267 504,
9268 30831,
9269 -32669,
9270 24303,
9271 -22080,
9272 24303,
9273 30994,
9274 -32673,
9275 1905,
9276 -1811,
9277 1905,
9278 5,
9279 129,
9280 17,
9281 0xff5
9282 },
9283#endif
9284 { /* f425_450[] */
9285 30646, /* A1 = 1.870544 */
9286 -32327, /* A2 = -0.986572 */
9287 -287, /* B2 = -0.008769 */
9288 0, /* B1 = 0 */
9289 287, /* B0 = 0.008769 */
9290 30627, /* A1 = 1.869324 */
9291 -32607, /* A2 = -0.995087 */
9292 13269, /* B2 = 0.404968 */
9293 -12376, /* B1 = -0.755432 */
9294 13269, /* B0 = 0.404968 */
9295 30924, /* A1 = 1.887512 */
9296 -32619, /* A2 = -0.995453 */
9297 19950, /* B2 = 0.608826 */
9298 -18940, /* B1 = -1.156006 */
9299 19950, /* B0 = 0.608826 */
9300 7, /* Internal filter scaling */
9301 159, /* Minimum in-band energy threshold */
9302 21, /* 21/32 in-band to broad-band ratio */
9303 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9304 },
9305 { /* f425_475[] */
9306 30396, /* A1 = 1.855225 */
9307 -32014, /* A2 = -0.97699 */
9308 -395, /* B2 = -0.012055 */
9309 0, /* B1 = 0 */
9310 395, /* B0 = 0.012055 */
9311 30343, /* A1 = 1.85199 */
9312 -32482, /* A2 = -0.991302 */
9313 17823, /* B2 = 0.543945 */
9314 -16431, /* B1 = -1.002869 */
9315 17823, /* B0 = 0.543945 */
9316 30872, /* A1 = 1.884338 */
9317 -32516, /* A2 = -0.99231 */
9318 18124, /* B2 = 0.553101 */
9319 -17246, /* B1 = -1.052673 */
9320 18124, /* B0 = 0.553101 */
9321 7, /* Internal filter scaling */
9322 159, /* Minimum in-band energy threshold */
9323 21, /* 21/32 in-band to broad-band ratio */
9324 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9325 },
9326 { /* f435 */
9327 30796, /* A1 = -1.879639 */
9328 -32603, /* A2 = 0.994965 */
9329 -254, /* B2 = -0.007762 */
9330 0, /* B1 = 0.000000 */
9331 254, /* B0 = 0.007762 */
9332 30793, /* A1 = -1.879456 */
9333 -32692, /* A2 = 0.997711 */
9334 18934, /* B2 = 0.577820 */
9335 -17751, /* B1 = -1.083496 */
9336 18934, /* B0 = 0.577820 */
9337 30882, /* A1 = -1.884888 */
9338 -32694, /* A2 = 0.997772 */
9339 1858, /* B2 = 0.056713 */
9340 -1758, /* B1 = -0.107357 */
9341 1858, /* B0 = 0.056713 */
9342 5, /* Internal filter scaling */
9343 159, /* Minimum in-band energy threshold */
9344 21, /* 21/32 in-band to broad-band ratio */
9345 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9346 },
9347 { /* f440_450[] */
9348 30641, /* A1 = 1.870239 */
9349 -32458, /* A2 = -0.99057 */
9350 -155, /* B2 = -0.004735 */
9351 0, /* B1 = 0 */
9352 155, /* B0 = 0.004735 */
9353 30631, /* A1 = 1.869568 */
9354 -32630, /* A2 = -0.995789 */
9355 11453, /* B2 = 0.349548 */
9356 -10666, /* B1 = -0.651001 */
9357 11453, /* B0 = 0.349548 */
9358 30810, /* A1 = 1.880554 */
9359 -32634, /* A2 = -0.995941 */
9360 12237, /* B2 = 0.373474 */
9361 -11588, /* B1 = -0.707336 */
9362 12237, /* B0 = 0.373474 */
9363 7, /* Internal filter scaling */
9364 159, /* Minimum in-band energy threshold */
9365 21, /* 21/32 in-band to broad-band ratio */
9366 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9367 },
9368 { /* f440_480[] */
9369 30367, /* A1 = 1.853455 */
9370 -32147, /* A2 = -0.981079 */
9371 -495, /* B2 = -0.015113 */
9372 0, /* B1 = 0 */
9373 495, /* B0 = 0.015113 */
9374 30322, /* A1 = 1.850769 */
9375 -32543, /* A2 = -0.993134 */
9376 10031, /* B2 = 0.306152 */
9377 -9252, /* B1 = -0.564728 */
9378 10031, /* B0 = 0.306152 */
9379 30770, /* A1 = 1.878052 */
9380 -32563, /* A2 = -0.993774 */
9381 22674, /* B2 = 0.691956 */
9382 -21465, /* B1 = -1.31012 */
9383 22674, /* B0 = 0.691956 */
9384 7, /* Internal filter scaling */
9385 159, /* Minimum in-band energy threshold */
9386 21, /* 21/32 in-band to broad-band ratio */
9387 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9388 },
9389 { /* f445 */
9390 30709, /* A1 = -1.874329 */
9391 -32603, /* A2 = 0.994965 */
9392 -83, /* B2 = -0.002545 */
9393 0, /* B1 = 0.000000 */
9394 83, /* B0 = 0.002545 */
9395 30704, /* A1 = -1.874084 */
9396 -32692, /* A2 = 0.997711 */
9397 10641, /* B2 = 0.324738 */
9398 -9947, /* B1 = -0.607147 */
9399 10641, /* B0 = 0.324738 */
9400 30796, /* A1 = -1.879639 */
9401 -32694, /* A2 = 0.997772 */
9402 10079, /* B2 = 0.307587 */
9403 9513, /* B1 = 0.580688 */
9404 10079, /* B0 = 0.307587 */
9405 5, /* Internal filter scaling */
9406 159, /* Minimum in-band energy threshold */
9407 21, /* 21/32 in-band to broad-band ratio */
9408 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9409 },
9410 { /* f450 */
9411 30664, /* A1 = -1.871643 */
9412 -32603, /* A2 = 0.994965 */
9413 -164, /* B2 = -0.005029 */
9414 0, /* B1 = 0.000000 */
9415 164, /* B0 = 0.005029 */
9416 30661, /* A1 = -1.871399 */
9417 -32692, /* A2 = 0.997711 */
9418 15294, /* B2 = 0.466736 */
9419 -14275, /* B1 = -0.871307 */
9420 15294, /* B0 = 0.466736 */
9421 30751, /* A1 = -1.876953 */
9422 -32694, /* A2 = 0.997772 */
9423 3548, /* B2 = 0.108284 */
9424 -3344, /* B1 = -0.204155 */
9425 3548, /* B0 = 0.108284 */
9426 5, /* Internal filter scaling */
9427 159, /* Minimum in-band energy threshold */
9428 21, /* 21/32 in-band to broad-band ratio */
9429 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9430 },
9431 { /* f452 */
9432 30653, /* A1 = -1.870911 */
9433 -32615, /* A2 = 0.995361 */
9434 -209, /* B2 = -0.006382 */
9435 0, /* B1 = 0.000000 */
9436 209, /* B0 = 0.006382 */
9437 30647, /* A1 = -1.870605 */
9438 -32702, /* A2 = 0.997986 */
9439 18971, /* B2 = 0.578979 */
9440 -17716, /* B1 = -1.081299 */
9441 18971, /* B0 = 0.578979 */
9442 30738, /* A1 = -1.876099 */
9443 -32702, /* A2 = 0.998016 */
9444 2967, /* B2 = 0.090561 */
9445 -2793, /* B1 = -0.170502 */
9446 2967, /* B0 = 0.090561 */
9447 5, /* Internal filter scaling */
9448 159, /* Minimum in-band energy threshold */
9449 21, /* 21/32 in-band to broad-band ratio */
9450 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9451 },
9452 { /* f475 */
9453 30437, /* A1 = -1.857727 */
9454 -32603, /* A2 = 0.994965 */
9455 -264, /* B2 = -0.008062 */
9456 0, /* B1 = 0.000000 */
9457 264, /* B0 = 0.008062 */
9458 30430, /* A1 = -1.857300 */
9459 -32692, /* A2 = 0.997711 */
9460 21681, /* B2 = 0.661682 */
9461 -20082, /* B1 = -1.225708 */
9462 21681, /* B0 = 0.661682 */
9463 30526, /* A1 = -1.863220 */
9464 -32694, /* A2 = 0.997742 */
9465 1559, /* B2 = 0.047600 */
9466 -1459, /* B1 = -0.089096 */
9467 1559, /* B0 = 0.047600 */
9468 5, /* Internal filter scaling */
9469 159, /* Minimum in-band energy threshold */
9470 21, /* 21/32 in-band to broad-band ratio */
9471 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9472 },
9473 { /* f480_620[] */
9474 28975, /* A1 = 1.768494 */
9475 -30955, /* A2 = -0.944672 */
9476 -1026, /* B2 = -0.03133 */
9477 0, /* B1 = 0 */
9478 1026, /* B0 = 0.03133 */
9479 28613, /* A1 = 1.746399 */
9480 -32089, /* A2 = -0.979309 */
9481 14214, /* B2 = 0.433807 */
9482 -12202, /* B1 = -0.744812 */
9483 14214, /* B0 = 0.433807 */
9484 30243, /* A1 = 1.845947 */
9485 -32238, /* A2 = -0.983856 */
9486 24825, /* B2 = 0.757629 */
9487 -23402, /* B1 = -1.428345 */
9488 24825, /* B0 = 0.757629 */
9489 7, /* Internal filter scaling */
9490 159, /* Minimum in-band energy threshold */
9491 21, /* 21/32 in-band to broad-band ratio */
9492 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9493 },
9494 { /* f494 */
9495 30257, /* A1 = -1.846741 */
9496 -32605, /* A2 = 0.995056 */
9497 -249, /* B2 = -0.007625 */
9498 0, /* B1 = 0.000000 */
9499 249, /* B0 = 0.007625 */
9500 30247, /* A1 = -1.846191 */
9501 -32694, /* A2 = 0.997772 */
9502 18088, /* B2 = 0.552002 */
9503 -16652, /* B1 = -1.016418 */
9504 18088, /* B0 = 0.552002 */
9505 30348, /* A1 = -1.852295 */
9506 -32696, /* A2 = 0.997803 */
9507 2099, /* B2 = 0.064064 */
9508 -1953, /* B1 = -0.119202 */
9509 2099, /* B0 = 0.064064 */
9510 5, /* Internal filter scaling */
9511 159, /* Minimum in-band energy threshold */
9512 21, /* 21/32 in-band to broad-band ratio */
9513 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9514 },
9515 { /* f500 */
9516 30202, /* A1 = -1.843431 */
9517 -32624, /* A2 = 0.995622 */
9518 -413, /* B2 = -0.012622 */
9519 0, /* B1 = 0.000000 */
9520 413, /* B0 = 0.012622 */
9521 30191, /* A1 = -1.842721 */
9522 -32714, /* A2 = 0.998364 */
9523 25954, /* B2 = 0.792057 */
9524 -23890, /* B1 = -1.458131 */
9525 25954, /* B0 = 0.792057 */
9526 30296, /* A1 = -1.849172 */
9527 -32715, /* A2 = 0.998397 */
9528 2007, /* B2 = 0.061264 */
9529 -1860, /* B1 = -0.113568 */
9530 2007, /* B0 = 0.061264 */
9531 5, /* Internal filter scaling */
9532 159, /* Minimum in-band energy threshold */
9533 21, /* 21/32 in-band to broad-band ratio */
9534 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9535 },
9536 { /* f520 */
9537 30001, /* A1 = -1.831116 */
9538 -32613, /* A2 = 0.995270 */
9539 -155, /* B2 = -0.004750 */
9540 0, /* B1 = 0.000000 */
9541 155, /* B0 = 0.004750 */
9542 29985, /* A1 = -1.830200 */
9543 -32710, /* A2 = 0.998260 */
9544 6584, /* B2 = 0.200928 */
9545 -6018, /* B1 = -0.367355 */
9546 6584, /* B0 = 0.200928 */
9547 30105, /* A1 = -1.837524 */
9548 -32712, /* A2 = 0.998291 */
9549 23812, /* B2 = 0.726685 */
9550 -21936, /* B1 = -1.338928 */
9551 23812, /* B0 = 0.726685 */
9552 5, /* Internal filter scaling */
9553 159, /* Minimum in-band energy threshold */
9554 21, /* 21/32 in-band to broad-band ratio */
9555 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9556 },
9557 { /* f523 */
9558 29964, /* A1 = -1.828918 */
9559 -32601, /* A2 = 0.994904 */
9560 -101, /* B2 = -0.003110 */
9561 0, /* B1 = 0.000000 */
9562 101, /* B0 = 0.003110 */
9563 29949, /* A1 = -1.827942 */
9564 -32700, /* A2 = 0.997925 */
9565 11041, /* B2 = 0.336975 */
9566 -10075, /* B1 = -0.614960 */
9567 11041, /* B0 = 0.336975 */
9568 30070, /* A1 = -1.835388 */
9569 -32702, /* A2 = 0.997986 */
9570 16762, /* B2 = 0.511536 */
9571 -15437, /* B1 = -0.942230 */
9572 16762, /* B0 = 0.511536 */
9573 5, /* Internal filter scaling */
9574 159, /* Minimum in-band energy threshold */
9575 21, /* 21/32 in-band to broad-band ratio */
9576 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9577 },
9578 { /* f525 */
9579 29936, /* A1 = -1.827209 */
9580 -32584, /* A2 = 0.994415 */
9581 -91, /* B2 = -0.002806 */
9582 0, /* B1 = 0.000000 */
9583 91, /* B0 = 0.002806 */
9584 29921, /* A1 = -1.826233 */
9585 -32688, /* A2 = 0.997559 */
9586 11449, /* B2 = 0.349396 */
9587 -10426, /* B1 = -0.636383 */
9588 11449, /* B0 = 0.349396 */
9589 30045, /* A1 = -1.833862 */
9590 -32688, /* A2 = 0.997589 */
9591 13055, /* B2 = 0.398407 */
9592 -12028, /* B1 = -0.734161 */
9593 13055, /* B0 = 0.398407 */
9594 5, /* Internal filter scaling */
9595 159, /* Minimum in-band energy threshold */
9596 21, /* 21/32 in-band to broad-band ratio */
9597 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9598 },
9599 { /* f540_660[] */
9600 28499, /* A1 = 1.739441 */
9601 -31129, /* A2 = -0.949982 */
9602 -849, /* B2 = -0.025922 */
9603 0, /* B1 = 0 */
9604 849, /* B0 = 0.025922 */
9605 28128, /* A1 = 1.716797 */
9606 -32130, /* A2 = -0.98056 */
9607 14556, /* B2 = 0.444214 */
9608 -12251, /* B1 = -0.747772 */
9609 14556, /* B0 = 0.444244 */
9610 29667, /* A1 = 1.81073 */
9611 -32244, /* A2 = -0.984039 */
9612 23038, /* B2 = 0.703064 */
9613 -21358, /* B1 = -1.303589 */
9614 23040, /* B0 = 0.703125 */
9615 7, /* Internal filter scaling */
9616 159, /* Minimum in-band energy threshold */
9617 21, /* 21/32 in-band to broad-band ratio */
9618 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9619 },
9620 { /* f587 */
9621 29271, /* A1 = -1.786560 */
9622 -32599, /* A2 = 0.994873 */
9623 -490, /* B2 = -0.014957 */
9624 0, /* B1 = 0.000000 */
9625 490, /* B0 = 0.014957 */
9626 29246, /* A1 = -1.785095 */
9627 -32700, /* A2 = 0.997925 */
9628 28961, /* B2 = 0.883850 */
9629 -25796, /* B1 = -1.574463 */
9630 28961, /* B0 = 0.883850 */
9631 29383, /* A1 = -1.793396 */
9632 -32700, /* A2 = 0.997955 */
9633 1299, /* B2 = 0.039650 */
9634 -1169, /* B1 = -0.071396 */
9635 1299, /* B0 = 0.039650 */
9636 5, /* Internal filter scaling */
9637 159, /* Minimum in-band energy threshold */
9638 21, /* 21/32 in-band to broad-band ratio */
9639 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9640 },
9641 { /* f590 */
9642 29230, /* A1 = -1.784058 */
9643 -32584, /* A2 = 0.994415 */
9644 -418, /* B2 = -0.012757 */
9645 0, /* B1 = 0.000000 */
9646 418, /* B0 = 0.012757 */
9647 29206, /* A1 = -1.782593 */
9648 -32688, /* A2 = 0.997559 */
9649 36556, /* B2 = 1.115601 */
9650 -32478, /* B1 = -1.982300 */
9651 36556, /* B0 = 1.115601 */
9652 29345, /* A1 = -1.791077 */
9653 -32688, /* A2 = 0.997589 */
9654 897, /* B2 = 0.027397 */
9655 -808, /* B1 = -0.049334 */
9656 897, /* B0 = 0.027397 */
9657 5, /* Internal filter scaling */
9658 159, /* Minimum in-band energy threshold */
9659 21, /* 21/32 in-band to broad-band ratio */
9660 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9661 },
9662 { /* f600 */
9663 29116, /* A1 = -1.777100 */
9664 -32603, /* A2 = 0.994965 */
9665 -165, /* B2 = -0.005039 */
9666 0, /* B1 = 0.000000 */
9667 165, /* B0 = 0.005039 */
9668 29089, /* A1 = -1.775452 */
9669 -32708, /* A2 = 0.998199 */
9670 6963, /* B2 = 0.212494 */
9671 -6172, /* B1 = -0.376770 */
9672 6963, /* B0 = 0.212494 */
9673 29237, /* A1 = -1.784485 */
9674 -32710, /* A2 = 0.998230 */
9675 24197, /* B2 = 0.738464 */
9676 -21657, /* B1 = -1.321899 */
9677 24197, /* B0 = 0.738464 */
9678 5, /* Internal filter scaling */
9679 159, /* Minimum in-band energy threshold */
9680 21, /* 21/32 in-band to broad-band ratio */
9681 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9682 },
9683 { /* f660 */
9684 28376, /* A1 = -1.731934 */
9685 -32567, /* A2 = 0.993896 */
9686 -363, /* B2 = -0.011102 */
9687 0, /* B1 = 0.000000 */
9688 363, /* B0 = 0.011102 */
9689 28337, /* A1 = -1.729614 */
9690 -32683, /* A2 = 0.997434 */
9691 21766, /* B2 = 0.664246 */
9692 -18761, /* B1 = -1.145081 */
9693 21766, /* B0 = 0.664246 */
9694 28513, /* A1 = -1.740356 */
9695 -32686, /* A2 = 0.997498 */
9696 2509, /* B2 = 0.076584 */
9697 -2196, /* B1 = -0.134041 */
9698 2509, /* B0 = 0.076584 */
9699 5, /* Internal filter scaling */
9700 159, /* Minimum in-band energy threshold */
9701 21, /* 21/32 in-band to broad-band ratio */
9702 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9703 },
9704 { /* f700 */
9705 27844, /* A1 = -1.699463 */
9706 -32563, /* A2 = 0.993744 */
9707 -366, /* B2 = -0.011187 */
9708 0, /* B1 = 0.000000 */
9709 366, /* B0 = 0.011187 */
9710 27797, /* A1 = -1.696655 */
9711 -32686, /* A2 = 0.997498 */
9712 22748, /* B2 = 0.694214 */
9713 -19235, /* B1 = -1.174072 */
9714 22748, /* B0 = 0.694214 */
9715 27995, /* A1 = -1.708740 */
9716 -32688, /* A2 = 0.997559 */
9717 2964, /* B2 = 0.090477 */
9718 -2546, /* B1 = -0.155449 */
9719 2964, /* B0 = 0.090477 */
9720 5, /* Internal filter scaling */
9721 159, /* Minimum in-band energy threshold */
9722 21, /* 21/32 in-band to broad-band ratio */
9723 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9724 },
9725 { /* f740 */
9726 27297, /* A1 = -1.666077 */
9727 -32551, /* A2 = 0.993408 */
9728 -345, /* B2 = -0.010540 */
9729 0, /* B1 = 0.000000 */
9730 345, /* B0 = 0.010540 */
9731 27240, /* A1 = -1.662598 */
9732 -32683, /* A2 = 0.997406 */
9733 22560, /* B2 = 0.688477 */
9734 -18688, /* B1 = -1.140625 */
9735 22560, /* B0 = 0.688477 */
9736 27461, /* A1 = -1.676147 */
9737 -32684, /* A2 = 0.997467 */
9738 3541, /* B2 = 0.108086 */
9739 -2985, /* B1 = -0.182220 */
9740 3541, /* B0 = 0.108086 */
9741 5, /* Internal filter scaling */
9742 159, /* Minimum in-band energy threshold */
9743 21, /* 21/32 in-band to broad-band ratio */
9744 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9745 },
9746 { /* f750 */
9747 27155, /* A1 = -1.657410 */
9748 -32551, /* A2 = 0.993408 */
9749 -462, /* B2 = -0.014117 */
9750 0, /* B1 = 0.000000 */
9751 462, /* B0 = 0.014117 */
9752 27097, /* A1 = -1.653870 */
9753 -32683, /* A2 = 0.997406 */
9754 32495, /* B2 = 0.991699 */
9755 -26776, /* B1 = -1.634338 */
9756 32495, /* B0 = 0.991699 */
9757 27321, /* A1 = -1.667542 */
9758 -32684, /* A2 = 0.997467 */
9759 1835, /* B2 = 0.056007 */
9760 -1539, /* B1 = -0.093948 */
9761 1835, /* B0 = 0.056007 */
9762 5, /* Internal filter scaling */
9763 159, /* Minimum in-band energy threshold */
9764 21, /* 21/32 in-band to broad-band ratio */
9765 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9766 },
9767 { /* f750_1450[] */
9768 19298, /* A1 = 1.177917 */
9769 -24471, /* A2 = -0.746796 */
9770 -4152, /* B2 = -0.126709 */
9771 0, /* B1 = 0 */
9772 4152, /* B0 = 0.126709 */
9773 12902, /* A1 = 0.787476 */
9774 -29091, /* A2 = -0.887817 */
9775 12491, /* B2 = 0.38121 */
9776 -1794, /* B1 = -0.109528 */
9777 12494, /* B0 = 0.381317 */
9778 26291, /* A1 = 1.604736 */
9779 -30470, /* A2 = -0.929901 */
9780 28859, /* B2 = 0.880737 */
9781 -26084, /* B1 = -1.592102 */
9782 28861, /* B0 = 0.880798 */
9783 7, /* Internal filter scaling */
9784 159, /* Minimum in-band energy threshold */
9785 21, /* 21/32 in-band to broad-band ratio */
9786 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9787 },
9788 { /* f770 */
9789 26867, /* A1 = -1.639832 */
9790 -32551, /* A2 = 0.993408 */
9791 -123, /* B2 = -0.003755 */
9792 0, /* B1 = 0.000000 */
9793 123, /* B0 = 0.003755 */
9794 26805, /* A1 = -1.636108 */
9795 -32683, /* A2 = 0.997406 */
9796 17297, /* B2 = 0.527863 */
9797 -14096, /* B1 = -0.860382 */
9798 17297, /* B0 = 0.527863 */
9799 27034, /* A1 = -1.650085 */
9800 -32684, /* A2 = 0.997467 */
9801 12958, /* B2 = 0.395477 */
9802 -10756, /* B1 = -0.656525 */
9803 12958, /* B0 = 0.395477 */
9804 5, /* Internal filter scaling */
9805 159, /* Minimum in-band energy threshold */
9806 21, /* 21/32 in-band to broad-band ratio */
9807 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9808 },
9809 { /* f800 */
9810 26413, /* A1 = -1.612122 */
9811 -32547, /* A2 = 0.993286 */
9812 -223, /* B2 = -0.006825 */
9813 0, /* B1 = 0.000000 */
9814 223, /* B0 = 0.006825 */
9815 26342, /* A1 = -1.607849 */
9816 -32686, /* A2 = 0.997498 */
9817 6391, /* B2 = 0.195053 */
9818 -5120, /* B1 = -0.312531 */
9819 6391, /* B0 = 0.195053 */
9820 26593, /* A1 = -1.623108 */
9821 -32688, /* A2 = 0.997559 */
9822 23681, /* B2 = 0.722717 */
9823 -19328, /* B1 = -1.179688 */
9824 23681, /* B0 = 0.722717 */
9825 5, /* Internal filter scaling */
9826 159, /* Minimum in-band energy threshold */
9827 21, /* 21/32 in-band to broad-band ratio */
9828 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9829 },
9830 { /* f816 */
9831 26168, /* A1 = -1.597209 */
9832 -32528, /* A2 = 0.992706 */
9833 -235, /* B2 = -0.007182 */
9834 0, /* B1 = 0.000000 */
9835 235, /* B0 = 0.007182 */
9836 26092, /* A1 = -1.592590 */
9837 -32675, /* A2 = 0.997192 */
9838 20823, /* B2 = 0.635498 */
9839 -16510, /* B1 = -1.007751 */
9840 20823, /* B0 = 0.635498 */
9841 26363, /* A1 = -1.609070 */
9842 -32677, /* A2 = 0.997253 */
9843 6739, /* B2 = 0.205688 */
9844 -5459, /* B1 = -0.333206 */
9845 6739, /* B0 = 0.205688 */
9846 5, /* Internal filter scaling */
9847 159, /* Minimum in-band energy threshold */
9848 21, /* 21/32 in-band to broad-band ratio */
9849 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9850 },
9851 { /* f850 */
9852 25641, /* A1 = -1.565063 */
9853 -32536, /* A2 = 0.992950 */
9854 -121, /* B2 = -0.003707 */
9855 0, /* B1 = 0.000000 */
9856 121, /* B0 = 0.003707 */
9857 25560, /* A1 = -1.560059 */
9858 -32684, /* A2 = 0.997437 */
9859 18341, /* B2 = 0.559753 */
9860 -14252, /* B1 = -0.869904 */
9861 18341, /* B0 = 0.559753 */
9862 25837, /* A1 = -1.577026 */
9863 -32684, /* A2 = 0.997467 */
9864 16679, /* B2 = 0.509003 */
9865 -13232, /* B1 = -0.807648 */
9866 16679, /* B0 = 0.509003 */
9867 5, /* Internal filter scaling */
9868 159, /* Minimum in-band energy threshold */
9869 21, /* 21/32 in-band to broad-band ratio */
9870 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9871 },
9872 { /* f857_1645[] */
9873 16415, /* A1 = 1.001953 */
9874 -23669, /* A2 = -0.722321 */
9875 -4549, /* B2 = -0.138847 */
9876 0, /* B1 = 0 */
9877 4549, /* B0 = 0.138847 */
9878 8456, /* A1 = 0.516174 */
9879 -28996, /* A2 = -0.884918 */
9880 13753, /* B2 = 0.419724 */
9881 -12, /* B1 = -0.000763 */
9882 13757, /* B0 = 0.419846 */
9883 24632, /* A1 = 1.503418 */
9884 -30271, /* A2 = -0.923828 */
9885 29070, /* B2 = 0.887146 */
9886 -25265, /* B1 = -1.542114 */
9887 29073, /* B0 = 0.887268 */
9888 7, /* Internal filter scaling */
9889 159, /* Minimum in-band energy threshold */
9890 21, /* 21/32 in-band to broad-band ratio */
9891 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9892 },
9893 { /* f900 */
9894 24806, /* A1 = -1.514099 */
9895 -32501, /* A2 = 0.991852 */
9896 -326, /* B2 = -0.009969 */
9897 0, /* B1 = 0.000000 */
9898 326, /* B0 = 0.009969 */
9899 24709, /* A1 = -1.508118 */
9900 -32659, /* A2 = 0.996674 */
9901 20277, /* B2 = 0.618835 */
9902 -15182, /* B1 = -0.926636 */
9903 20277, /* B0 = 0.618835 */
9904 25022, /* A1 = -1.527222 */
9905 -32661, /* A2 = 0.996735 */
9906 4320, /* B2 = 0.131836 */
9907 -3331, /* B1 = -0.203339 */
9908 4320, /* B0 = 0.131836 */
9909 5, /* Internal filter scaling */
9910 159, /* Minimum in-band energy threshold */
9911 21, /* 21/32 in-band to broad-band ratio */
9912 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9913 },
9914 { /* f900_1300[] */
9915 19776, /* A1 = 1.207092 */
9916 -27437, /* A2 = -0.837341 */
9917 -2666, /* B2 = -0.081371 */
9918 0, /* B1 = 0 */
9919 2666, /* B0 = 0.081371 */
9920 16302, /* A1 = 0.995026 */
9921 -30354, /* A2 = -0.926361 */
9922 10389, /* B2 = 0.317062 */
9923 -3327, /* B1 = -0.203064 */
9924 10389, /* B0 = 0.317062 */
9925 24299, /* A1 = 1.483154 */
9926 -30930, /* A2 = -0.943909 */
9927 25016, /* B2 = 0.763428 */
9928 -21171, /* B1 = -1.292236 */
9929 25016, /* B0 = 0.763428 */
9930 7, /* Internal filter scaling */
9931 159, /* Minimum in-band energy threshold */
9932 21, /* 21/32 in-band to broad-band ratio */
9933 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9934 },
9935 { /* f935_1215[] */
9936 20554, /* A1 = 1.254517 */
9937 -28764, /* A2 = -0.877838 */
9938 -2048, /* B2 = -0.062515 */
9939 0, /* B1 = 0 */
9940 2048, /* B0 = 0.062515 */
9941 18209, /* A1 = 1.11145 */
9942 -30951, /* A2 = -0.94458 */
9943 9390, /* B2 = 0.286575 */
9944 -3955, /* B1 = -0.241455 */
9945 9390, /* B0 = 0.286575 */
9946 23902, /* A1 = 1.458923 */
9947 -31286, /* A2 = -0.954803 */
9948 23252, /* B2 = 0.709595 */
9949 -19132, /* B1 = -1.167725 */
9950 23252, /* B0 = 0.709595 */
9951 7, /* Internal filter scaling */
9952 159, /* Minimum in-band energy threshold */
9953 21, /* 21/32 in-band to broad-band ratio */
9954 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9955 },
9956 { /* f941_1477[] */
9957 17543, /* A1 = 1.07074 */
9958 -26220, /* A2 = -0.800201 */
9959 -3298, /* B2 = -0.100647 */
9960 0, /* B1 = 0 */
9961 3298, /* B0 = 0.100647 */
9962 12423, /* A1 = 0.75827 */
9963 -30036, /* A2 = -0.916626 */
9964 12651, /* B2 = 0.386078 */
9965 -2444, /* B1 = -0.14917 */
9966 12653, /* B0 = 0.386154 */
9967 23518, /* A1 = 1.435425 */
9968 -30745, /* A2 = -0.938293 */
9969 27282, /* B2 = 0.832581 */
9970 -22529, /* B1 = -1.375122 */
9971 27286, /* B0 = 0.832703 */
9972 7, /* Internal filter scaling */
9973 159, /* Minimum in-band energy threshold */
9974 21, /* 21/32 in-band to broad-band ratio */
9975 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9976 },
9977 { /* f942 */
9978 24104, /* A1 = -1.471252 */
9979 -32507, /* A2 = 0.992065 */
9980 -351, /* B2 = -0.010722 */
9981 0, /* B1 = 0.000000 */
9982 351, /* B0 = 0.010722 */
9983 23996, /* A1 = -1.464600 */
9984 -32671, /* A2 = 0.997040 */
9985 22848, /* B2 = 0.697266 */
9986 -16639, /* B1 = -1.015564 */
9987 22848, /* B0 = 0.697266 */
9988 24332, /* A1 = -1.485168 */
9989 -32673, /* A2 = 0.997101 */
9990 4906, /* B2 = 0.149727 */
9991 -3672, /* B1 = -0.224174 */
9992 4906, /* B0 = 0.149727 */
9993 5, /* Internal filter scaling */
9994 159, /* Minimum in-band energy threshold */
9995 21, /* 21/32 in-band to broad-band ratio */
9996 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9997 },
9998 { /* f950 */
9999 23967, /* A1 = -1.462830 */
10000 -32507, /* A2 = 0.992065 */
10001 -518, /* B2 = -0.015821 */
10002 0, /* B1 = 0.000000 */
10003 518, /* B0 = 0.015821 */
10004 23856, /* A1 = -1.456055 */
10005 -32671, /* A2 = 0.997040 */
10006 26287, /* B2 = 0.802246 */
10007 -19031, /* B1 = -1.161560 */
10008 26287, /* B0 = 0.802246 */
10009 24195, /* A1 = -1.476746 */
10010 -32673, /* A2 = 0.997101 */
10011 2890, /* B2 = 0.088196 */
10012 -2151, /* B1 = -0.131317 */
10013 2890, /* B0 = 0.088196 */
10014 5, /* Internal filter scaling */
10015 159, /* Minimum in-band energy threshold */
10016 21, /* 21/32 in-band to broad-band ratio */
10017 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10018 },
10019 { /* f950_1400[] */
10020 18294, /* A1 = 1.116638 */
10021 -26962, /* A2 = -0.822845 */
10022 -2914, /* B2 = -0.088936 */
10023 0, /* B1 = 0 */
10024 2914, /* B0 = 0.088936 */
10025 14119, /* A1 = 0.861786 */
10026 -30227, /* A2 = -0.922455 */
10027 11466, /* B2 = 0.349945 */
10028 -2833, /* B1 = -0.172943 */
10029 11466, /* B0 = 0.349945 */
10030 23431, /* A1 = 1.430115 */
10031 -30828, /* A2 = -0.940796 */
10032 25331, /* B2 = 0.773071 */
10033 -20911, /* B1 = -1.276367 */
10034 25331, /* B0 = 0.773071 */
10035 7, /* Internal filter scaling */
10036 159, /* Minimum in-band energy threshold */
10037 21, /* 21/32 in-band to broad-band ratio */
10038 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10039 },
10040 { /* f975 */
10041 23521, /* A1 = -1.435608 */
10042 -32489, /* A2 = 0.991516 */
10043 -193, /* B2 = -0.005915 */
10044 0, /* B1 = 0.000000 */
10045 193, /* B0 = 0.005915 */
10046 23404, /* A1 = -1.428467 */
10047 -32655, /* A2 = 0.996582 */
10048 17740, /* B2 = 0.541412 */
10049 -12567, /* B1 = -0.767029 */
10050 17740, /* B0 = 0.541412 */
10051 23753, /* A1 = -1.449829 */
10052 -32657, /* A2 = 0.996613 */
10053 9090, /* B2 = 0.277405 */
10054 -6662, /* B1 = -0.406647 */
10055 9090, /* B0 = 0.277405 */
10056 5, /* Internal filter scaling */
10057 159, /* Minimum in-band energy threshold */
10058 21, /* 21/32 in-band to broad-band ratio */
10059 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10060 },
10061 { /* f1000 */
10062 23071, /* A1 = -1.408203 */
10063 -32489, /* A2 = 0.991516 */
10064 -293, /* B2 = -0.008965 */
10065 0, /* B1 = 0.000000 */
10066 293, /* B0 = 0.008965 */
10067 22951, /* A1 = -1.400818 */
10068 -32655, /* A2 = 0.996582 */
10069 5689, /* B2 = 0.173645 */
10070 -3951, /* B1 = -0.241150 */
10071 5689, /* B0 = 0.173645 */
10072 23307, /* A1 = -1.422607 */
10073 -32657, /* A2 = 0.996613 */
10074 18692, /* B2 = 0.570435 */
10075 -13447, /* B1 = -0.820770 */
10076 18692, /* B0 = 0.570435 */
10077 5, /* Internal filter scaling */
10078 159, /* Minimum in-band energy threshold */
10079 21, /* 21/32 in-band to broad-band ratio */
10080 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10081 },
10082 { /* f1020 */
10083 22701, /* A1 = -1.385620 */
10084 -32474, /* A2 = 0.991058 */
10085 -292, /* B2 = -0.008933 */
10086 0, /*163840 , B1 = 10.000000 */
10087 292, /* B0 = 0.008933 */
10088 22564, /* A1 = -1.377258 */
10089 -32655, /* A2 = 0.996552 */
10090 20756, /* B2 = 0.633423 */
10091 -14176, /* B1 = -0.865295 */
10092 20756, /* B0 = 0.633423 */
10093 22960, /* A1 = -1.401428 */
10094 -32657, /* A2 = 0.996613 */
10095 6520, /* B2 = 0.198990 */
10096 -4619, /* B1 = -0.281937 */
10097 6520, /* B0 = 0.198990 */
10098 5, /* Internal filter scaling */
10099 159, /* Minimum in-band energy threshold */
10100 21, /* 21/32 in-band to broad-band ratio */
10101 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10102 },
10103 { /* f1050 */
10104 22142, /* A1 = -1.351501 */
10105 -32474, /* A2 = 0.991058 */
10106 -147, /* B2 = -0.004493 */
10107 0, /* B1 = 0.000000 */
10108 147, /* B0 = 0.004493 */
10109 22000, /* A1 = -1.342834 */
10110 -32655, /* A2 = 0.996552 */
10111 15379, /* B2 = 0.469360 */
10112 -10237, /* B1 = -0.624847 */
10113 15379, /* B0 = 0.469360 */
10114 22406, /* A1 = -1.367554 */
10115 -32657, /* A2 = 0.996613 */
10116 17491, /* B2 = 0.533783 */
10117 -12096, /* B1 = -0.738312 */
10118 17491, /* B0 = 0.533783 */
10119 5, /* Internal filter scaling */
10120 159, /* Minimum in-band energy threshold */
10121 21, /* 21/32 in-band to broad-band ratio */
10122 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10123 },
10124 { /* f1100_1750[] */
10125 12973, /* A1 = 0.79184 */
10126 -24916, /* A2 = -0.760376 */
10127 6655, /* B2 = 0.203102 */
10128 367, /* B1 = 0.0224 */
10129 6657, /* B0 = 0.203171 */
10130 5915, /* A1 = 0.361053 */
10131 -29560, /* A2 = -0.90213 */
10132 -7777, /* B2 = -0.23735 */
10133 0, /* B1 = 0 */
10134 7777, /* B0 = 0.23735 */
10135 20510, /* A1 = 1.251892 */
10136 -30260, /* A2 = -0.923462 */
10137 26662, /* B2 = 0.81366 */
10138 -20573, /* B1 = -1.255737 */
10139 26668, /* B0 = 0.813843 */
10140 7, /* Internal filter scaling */
10141 159, /* Minimum in-band energy threshold */
10142 21, /* 21/32 in-band to broad-band ratio */
10143 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10144 },
10145 { /* f1140 */
10146 20392, /* A1 = -1.244629 */
10147 -32460, /* A2 = 0.990601 */
10148 -270, /* B2 = -0.008240 */
10149 0, /* B1 = 0.000000 */
10150 270, /* B0 = 0.008240 */
10151 20218, /* A1 = -1.234009 */
10152 -32655, /* A2 = 0.996582 */
10153 21337, /* B2 = 0.651154 */
10154 -13044, /* B1 = -0.796143 */
10155 21337, /* B0 = 0.651154 */
10156 20684, /* A1 = -1.262512 */
10157 -32657, /* A2 = 0.996643 */
10158 8572, /* B2 = 0.261612 */
10159 -5476, /* B1 = -0.334244 */
10160 8572, /* B0 = 0.261612 */
10161 5, /* Internal filter scaling */
10162 159, /* Minimum in-band energy threshold */
10163 21, /* 21/32 in-band to broad-band ratio */
10164 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10165 },
10166 { /* f1200 */
10167 19159, /* A1 = -1.169373 */
10168 -32456, /* A2 = 0.990509 */
10169 -335, /* B2 = -0.010252 */
10170 0, /* B1 = 0.000000 */
10171 335, /* B0 = 0.010252 */
10172 18966, /* A1 = -1.157593 */
10173 -32661, /* A2 = 0.996735 */
10174 6802, /* B2 = 0.207588 */
10175 -3900, /* B1 = -0.238098 */
10176 6802, /* B0 = 0.207588 */
10177 19467, /* A1 = -1.188232 */
10178 -32661, /* A2 = 0.996765 */
10179 25035, /* B2 = 0.764008 */
10180 -15049, /* B1 = -0.918579 */
10181 25035, /* B0 = 0.764008 */
10182 5, /* Internal filter scaling */
10183 159, /* Minimum in-band energy threshold */
10184 21, /* 21/32 in-band to broad-band ratio */
10185 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10186 },
10187 { /* f1209 */
10188 18976, /* A1 = -1.158264 */
10189 -32439, /* A2 = 0.989990 */
10190 -183, /* B2 = -0.005588 */
10191 0, /* B1 = 0.000000 */
10192 183, /* B0 = 0.005588 */
10193 18774, /* A1 = -1.145874 */
10194 -32650, /* A2 = 0.996429 */
10195 15468, /* B2 = 0.472076 */
10196 -8768, /* B1 = -0.535217 */
10197 15468, /* B0 = 0.472076 */
10198 19300, /* A1 = -1.177979 */
10199 -32652, /* A2 = 0.996490 */
10200 19840, /* B2 = 0.605499 */
10201 -11842, /* B1 = -0.722809 */
10202 19840, /* B0 = 0.605499 */
10203 5, /* Internal filter scaling */
10204 159, /* Minimum in-band energy threshold */
10205 21, /* 21/32 in-band to broad-band ratio */
10206 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10207 },
10208 { /* f1330 */
10209 16357, /* A1 = -0.998413 */
10210 -32368, /* A2 = 0.987793 */
10211 -217, /* B2 = -0.006652 */
10212 0, /* B1 = 0.000000 */
10213 217, /* B0 = 0.006652 */
10214 16107, /* A1 = -0.983126 */
10215 -32601, /* A2 = 0.994904 */
10216 11602, /* B2 = 0.354065 */
10217 -5555, /* B1 = -0.339111 */
10218 11602, /* B0 = 0.354065 */
10219 16722, /* A1 = -1.020630 */
10220 -32603, /* A2 = 0.994965 */
10221 15574, /* B2 = 0.475311 */
10222 -8176, /* B1 = -0.499069 */
10223 15574, /* B0 = 0.475311 */
10224 5, /* Internal filter scaling */
10225 159, /* Minimum in-band energy threshold */
10226 21, /* 21/32 in-band to broad-band ratio */
10227 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10228 },
10229 { /* f1336 */
10230 16234, /* A1 = -0.990875 */
10231 32404, /* A2 = -0.988922 */
10232 -193, /* B2 = -0.005908 */
10233 0, /* B1 = 0.000000 */
10234 193, /* B0 = 0.005908 */
10235 15986, /* A1 = -0.975769 */
10236 -32632, /* A2 = 0.995880 */
10237 18051, /* B2 = 0.550903 */
10238 -8658, /* B1 = -0.528473 */
10239 18051, /* B0 = 0.550903 */
10240 16591, /* A1 = -1.012695 */
10241 -32634, /* A2 = 0.995941 */
10242 15736, /* B2 = 0.480240 */
10243 -8125, /* B1 = -0.495926 */
10244 15736, /* B0 = 0.480240 */
10245 5, /* Internal filter scaling */
10246 159, /* Minimum in-band energy threshold */
10247 21, /* 21/32 in-band to broad-band ratio */
10248 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10249 },
10250 { /* f1366 */
10251 15564, /* A1 = -0.949982 */
10252 -32404, /* A2 = 0.988922 */
10253 -269, /* B2 = -0.008216 */
10254 0, /* B1 = 0.000000 */
10255 269, /* B0 = 0.008216 */
10256 15310, /* A1 = -0.934479 */
10257 -32632, /* A2 = 0.995880 */
10258 10815, /* B2 = 0.330063 */
10259 -4962, /* B1 = -0.302887 */
10260 10815, /* B0 = 0.330063 */
10261 15924, /* A1 = -0.971924 */
10262 -32634, /* A2 = 0.995941 */
10263 18880, /* B2 = 0.576172 */
10264 -9364, /* B1 = -0.571594 */
10265 18880, /* B0 = 0.576172 */
10266 5, /* Internal filter scaling */
10267 159, /* Minimum in-band energy threshold */
10268 21, /* 21/32 in-band to broad-band ratio */
10269 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10270 },
10271 { /* f1380 */
10272 15247, /* A1 = -0.930603 */
10273 -32397, /* A2 = 0.988708 */
10274 -244, /* B2 = -0.007451 */
10275 0, /* B1 = 0.000000 */
10276 244, /* B0 = 0.007451 */
10277 14989, /* A1 = -0.914886 */
10278 -32627, /* A2 = 0.995697 */
10279 18961, /* B2 = 0.578644 */
10280 -8498, /* B1 = -0.518707 */
10281 18961, /* B0 = 0.578644 */
10282 15608, /* A1 = -0.952667 */
10283 -32628, /* A2 = 0.995758 */
10284 11145, /* B2 = 0.340134 */
10285 -5430, /* B1 = -0.331467 */
10286 11145, /* B0 = 0.340134 */
10287 5, /* Internal filter scaling */
10288 159, /* Minimum in-band energy threshold */
10289 21, /* 21/32 in-band to broad-band ratio */
10290 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10291 },
10292 { /* f1400 */
10293 14780, /* A1 = -0.902130 */
10294 -32393, /* A2 = 0.988586 */
10295 -396, /* B2 = -0.012086 */
10296 0, /* B1 = 0.000000 */
10297 396, /* B0 = 0.012086 */
10298 14510, /* A1 = -0.885651 */
10299 -32630, /* A2 = 0.995819 */
10300 6326, /* B2 = 0.193069 */
10301 -2747, /* B1 = -0.167671 */
10302 6326, /* B0 = 0.193069 */
10303 15154, /* A1 = -0.924957 */
10304 -32632, /* A2 = 0.995850 */
10305 23235, /* B2 = 0.709076 */
10306 -10983, /* B1 = -0.670380 */
10307 23235, /* B0 = 0.709076 */
10308 5, /* Internal filter scaling */
10309 159, /* Minimum in-band energy threshold */
10310 21, /* 21/32 in-band to broad-band ratio */
10311 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10312 },
10313 { /* f1477 */
10314 13005, /* A1 = -0.793793 */
10315 -32368, /* A2 = 0.987823 */
10316 -500, /* B2 = -0.015265 */
10317 0, /* B1 = 0.000000 */
10318 500, /* B0 = 0.015265 */
10319 12708, /* A1 = -0.775665 */
10320 -32615, /* A2 = 0.995331 */
10321 11420, /* B2 = 0.348526 */
10322 -4306, /* B1 = -0.262833 */
10323 11420, /* B0 = 0.348526 */
10324 13397, /* A1 = -0.817688 */
10325 -32615, /* A2 = 0.995361 */
10326 9454, /* B2 = 0.288528 */
10327 -3981, /* B1 = -0.243027 */
10328 9454, /* B0 = 0.288528 */
10329 5, /* Internal filter scaling */
10330 159, /* Minimum in-band energy threshold */
10331 21, /* 21/32 in-band to broad-band ratio */
10332 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10333 },
10334 { /* f1600 */
10335 10046, /* A1 = -0.613190 */
10336 -32331, /* A2 = 0.986694 */
10337 -455, /* B2 = -0.013915 */
10338 0, /* B1 = 0.000000 */
10339 455, /* B0 = 0.013915 */
10340 9694, /* A1 = -0.591705 */
10341 -32601, /* A2 = 0.994934 */
10342 6023, /* B2 = 0.183815 */
10343 -1708, /* B1 = -0.104279 */
10344 6023, /* B0 = 0.183815 */
10345 10478, /* A1 = -0.639587 */
10346 -32603, /* A2 = 0.994965 */
10347 22031, /* B2 = 0.672333 */
10348 -7342, /* B1 = -0.448151 */
10349 22031, /* B0 = 0.672333 */
10350 5, /* Internal filter scaling */
10351 159, /* Minimum in-band energy threshold */
10352 21, /* 21/32 in-band to broad-band ratio */
10353 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10354 },
10355 { /* f1633_1638[] */
10356 9181, /* A1 = 0.560394 */
10357 -32256, /* A2 = -0.984375 */
10358 -556, /* B2 = -0.016975 */
10359 0, /* B1 = 0 */
10360 556, /* B0 = 0.016975 */
10361 8757, /* A1 = 0.534515 */
10362 -32574, /* A2 = -0.99408 */
10363 8443, /* B2 = 0.25769 */
10364 -2135, /* B1 = -0.130341 */
10365 8443, /* B0 = 0.25769 */
10366 9691, /* A1 = 0.591522 */
10367 -32574, /* A2 = -0.99411 */
10368 15446, /* B2 = 0.471375 */
10369 -4809, /* B1 = -0.293579 */
10370 15446, /* B0 = 0.471375 */
10371 7, /* Internal filter scaling */
10372 159, /* Minimum in-band energy threshold */
10373 21, /* 21/32 in-band to broad-band ratio */
10374 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10375 },
10376 { /* f1800 */
10377 5076, /* A1 = -0.309875 */
10378 -32304, /* A2 = 0.985840 */
10379 -508, /* B2 = -0.015503 */
10380 0, /* B1 = 0.000000 */
10381 508, /* B0 = 0.015503 */
10382 4646, /* A1 = -0.283600 */
10383 -32605, /* A2 = 0.995026 */
10384 6742, /* B2 = 0.205780 */
10385 -878, /* B1 = -0.053635 */
10386 6742, /* B0 = 0.205780 */
10387 5552, /* A1 = -0.338928 */
10388 -32605, /* A2 = 0.995056 */
10389 23667, /* B2 = 0.722260 */
10390 -4297, /* B1 = -0.262329 */
10391 23667, /* B0 = 0.722260 */
10392 5, /* Internal filter scaling */
10393 159, /* Minimum in-band energy threshold */
10394 21, /* 21/32 in-band to broad-band ratio */
10395 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10396 },
10397 { /* f1860 */
10398 3569, /* A1 = -0.217865 */
10399 -32292, /* A2 = 0.985504 */
10400 -239, /* B2 = -0.007322 */
10401 0, /* B1 = 0.000000 */
10402 239, /* B0 = 0.007322 */
10403 3117, /* A1 = -0.190277 */
10404 -32603, /* A2 = 0.994965 */
10405 18658, /* B2 = 0.569427 */
10406 -1557, /* B1 = -0.095032 */
10407 18658, /* B0 = 0.569427 */
10408 4054, /* A1 = -0.247437 */
10409 -32603, /* A2 = 0.994965 */
10410 18886, /* B2 = 0.576385 */
10411 -2566, /* B1 = -0.156647 */
10412 18886, /* B0 = 0.576385 */
10413 5, /* Internal filter scaling */
10414 159, /* Minimum in-band energy threshold */
10415 21, /* 21/32 in-band to broad-band ratio */
10416 0x0FF5 /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10417 },
10418};
10419static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10420{
10421 unsigned short cmd;
10422 int cnt, max;
10423
10424 if (jf->filter > 3) {
10425 return -1;
10426 }
10427 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j)) /* Select Filter */
10428
10429 return -1;
10430 if (!jf->enable) {
10431 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10432
10433 return -1;
10434 else
10435 return 0;
10436 } else {
10437 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10438
10439 return -1;
10440 /* Select the filter (f0 - f3) to use. */
10441 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10442 return -1;
10443 }
10444 if (jf->freq < 12 && jf->freq > 3) {
10445 /* Select the frequency for the selected filter. */
10446 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10447 return -1;
10448 } else if (jf->freq > 11) {
10449 /* We need to load a programmable filter set for undefined */
10450 /* frequencies. So we will point the filter to a programmable set. */
10451 /* Since there are only 4 filters and 4 programmable sets, we will */
10452 /* just point the filter to the same number set and program it for the */
10453 /* frequency we want. */
10454 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10455 return -1;
10456 if (j->ver.low != 0x12) {
10457 cmd = 0x515B;
10458 max = 19;
10459 } else {
10460 cmd = 0x515E;
10461 max = 15;
10462 }
10463 if (ixj_WriteDSPCommand(cmd, j))
10464 return -1;
10465 for (cnt = 0; cnt < max; cnt++) {
10466 if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10467 return -1;
10468 }
10469 }
10470 j->filter_en[jf->filter] = jf->enable;
10471 return 0;
10472}
10473
10474static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10475{
10476 unsigned short cmd;
10477 int cnt, max;
10478 if (jfr->filter > 3) {
10479 return -1;
10480 }
10481 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j)) /* Select Filter */
10482 return -1;
10483
10484 if (!jfr->enable) {
10485 if (ixj_WriteDSPCommand(0x5152, j)) /* Disable Filter */
10486 return -1;
10487 else
10488 return 0;
10489 } else {
10490 if (ixj_WriteDSPCommand(0x5153, j)) /* Enable Filter */
10491 return -1;
10492 /* Select the filter (f0 - f3) to use. */
10493 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10494 return -1;
10495 }
10496 /* We need to load a programmable filter set for undefined */
10497 /* frequencies. So we will point the filter to a programmable set. */
10498 /* Since there are only 4 filters and 4 programmable sets, we will */
10499 /* just point the filter to the same number set and program it for the */
10500 /* frequency we want. */
10501 if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10502 return -1;
10503 if (j->ver.low != 0x12) {
10504 cmd = 0x515B;
10505 max = 19;
10506 } else {
10507 cmd = 0x515E;
10508 max = 15;
10509 }
10510 if (ixj_WriteDSPCommand(cmd, j))
10511 return -1;
10512 for (cnt = 0; cnt < max; cnt++) {
10513 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10514 return -1;
10515 }
10516 j->filter_en[jfr->filter] = jfr->enable;
10517 return 0;
10518}
10519
10520static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10521{
10522 int freq0, freq1;
10523 unsigned short data;
10524 if (ti->freq0) {
10525 freq0 = ti->freq0;
10526 } else {
10527 freq0 = 0x7FFF;
10528 }
10529
10530 if (ti->freq1) {
10531 freq1 = ti->freq1;
10532 } else {
10533 freq1 = 0x7FFF;
10534 }
10535
10536 if(ti->tone_index > 12 && ti->tone_index < 28)
10537 {
10538 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10539 return -1;
10540 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10541 return -1;
10542 data = freq0;
10543 if (ixj_WriteDSPCommand(data, j))
10544 return -1;
10545 data = freq1;
10546 if (ixj_WriteDSPCommand(data, j))
10547 return -1;
10548 }
10549 return freq0;
10550}
10551