开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
ixj.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：219k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

ixj.c：源码内容
  1. /*
  2.  *    ixj.c
  3.  *
  4.  *    Device Driver for the Internet PhoneJACK and
  5.  *    Internet LineJACK Telephony Cards.
  6.  *
  7.  *    (c) Copyright 1999 Quicknet Technologies, Inc.
  8.  *
  9.  *    This program is free software; you can redistribute it and/or
  10.  *    modify it under the terms of the GNU General Public License
  11.  *    as published by the Free Software Foundation; either version
  12.  *    2 of the License, or (at your option) any later version.
  13.  *
  14.  * Author:          Ed Okerson, <eokerson@quicknet.net>
  15.  *    
  16.  * Contributors:    Greg Herlein, <gherlein@quicknet.net>
  17.  *                  David W. Erhart, <derhart@quicknet.net>
  18.  *                  John Sellers, <jsellers@quicknet.net>
  19.  *                  Mike Preston, <mpreston@quicknet.net>
  20.  *
  21.  * Fixes:
  22.  *
  23.  * More information about the hardware related to this driver can be found
  24.  * at our website:    http://www.quicknet.net
  25.  *
  26.  * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
  27.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  28.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
  29.  * TECHNOLOGIES, INC.HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30.  *
  31.  * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  32.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  33.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  34.  * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION 
  35.  * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  36.  */
  38. #ifndef __KERNEL__
  39. #define __KERNEL__
  40. #endif
  41. #ifndef MODULE
  42. #define MODULE
  43. #endif
  45. static char ixj_c_rcsid[] = "$Id: ixj.c,v 1.1 2000/01/07 22:49:59 ctam Exp $";
  47. //#define PERFMON_STATS
  48. #define IXJDEBUG 1
  49. #define MAXRINGS 5
  51. #include <linux/module.h>
  53. #include <linux/sched.h>
  54. #include <linux/kernel.h> /* printk() */
  55. #include <linux/fs.h> /* everything... */
  56. #include <linux/errno.h> /* error codes */
  57. #include <linux/malloc.h>
  58. #include <linux/mm.h>
  59. #include <linux/ioport.h>
  60. #include <linux/interrupt.h>
  61. #include <linux/tqueue.h>
  62. #include <linux/proc_fs.h>
  63. #include <linux/poll.h>
  64. #include <linux/timer.h>
  65. #include <linux/delay.h>
  66. #include <linux/pci.h>
  68. #include <asm/io.h>
  69. #include <asm/segment.h>
  70. #include <asm/uaccess.h>
  72. #ifdef CONFIG_ISAPNP
  73. #include "isapnp/pnpio.h"
  74. #include "isapnp/isapnp.h"
  75. #endif
  77. #include "ixj.h"
  79. #define TYPE(dev) (MINOR(dev) >> 4)
  80. #define NUM(dev) (MINOR(dev) & 0xf)
  82. static int ixjdebug = 0;
  83. static int hertz = HZ;
  84. static int samplerate = 100;
  86. MODULE_PARM(ixjdebug, "i");
  88. //static int ixj_major = 159;
  89. //static struct wait_queue *ixj_queue;
  91. static IXJ ixj[IXJMAX];
  93. static struct timer_list ixj_timer;
  95. int ixj_convert_loaded = 0;
  97. /************************************************************************
  98. *
  99. * These are function definitions to allow external modules to register
  100. * enhanced functionality call backs.
  101. *
  102. ************************************************************************/
  104. static int Stub(IXJ * J, unsigned long arg)
  105. {
  106. return 0;
  107. }
  109. static IXJ_REGFUNC ixj_DownloadG729 = &Stub;
  110. static IXJ_REGFUNC ixj_DownloadTS85 = &Stub;
  111. static IXJ_REGFUNC ixj_PreRead = &Stub;
  112. static IXJ_REGFUNC ixj_PostRead = &Stub;
  113. static IXJ_REGFUNC ixj_PreWrite = &Stub;
  114. static IXJ_REGFUNC ixj_PostWrite = &Stub;
  115. static IXJ_REGFUNC ixj_PreIoctl = &Stub;
  116. static IXJ_REGFUNC ixj_PostIoctl = &Stub;
  118. static void ixj_read_frame(int board);
  119. static void ixj_write_frame(int board);
  120. static void ixj_init_timer(void);
  121. static void ixj_timeout(unsigned long ptr);
  122. static int read_filters(int board);
  123. static int LineMonitor(int board);
  124. static int ixj_fasync(int fd, struct file *, int mode);
  125. static int ixj_hookstate(int board);
  126. static int ixj_record_start(int board);
  127. static void ixj_record_stop(int board);
  128. static int ixj_play_start(int board);
  129. static void ixj_play_stop(int board);
  130. static int ixj_set_tone_on(unsigned short arg, int board);
  131. static int ixj_set_tone_off(unsigned short, int board);
  132. static int ixj_play_tone(int board, char tone);
  133. static int idle(int board);
  134. static void ixj_ring_on(int board);
  135. static void ixj_ring_off(int board);
  136. static void aec_stop(int board);
  137. static void ixj_ringback(int board);
  138. static void ixj_busytone(int board);
  139. static void ixj_dialtone(int board);
  140. static void ixj_cpt_stop(int board);
  141. static char daa_int_read(int board);
  142. static int daa_set_mode(int board, int mode);
  143. static int ixj_linetest(int board);
  144. static int ixj_daa_cid_read(int board);
  145. static void DAA_Coeff_US(int board);
  146. static void DAA_Coeff_UK(int board);
  147. static void DAA_Coeff_France(int board);
  148. static void DAA_Coeff_Germany(int board);
  149. static void DAA_Coeff_Australia(int board);
  150. static void DAA_Coeff_Japan(int board);
  151. static int ixj_init_filter(int board, IXJ_FILTER * jf);
  152. static int ixj_init_tone(int board, IXJ_TONE * ti);
  153. static int ixj_build_cadence(int board, IXJ_CADENCE * cp);
  154. // Serial Control Interface funtions
  155. static int SCI_Control(int board, int control);
  156. static int SCI_Prepare(int board);
  157. static int SCI_WaitHighSCI(int board);
  158. static int SCI_WaitLowSCI(int board);
  159. static DWORD PCIEE_GetSerialNumber(WORD wAddress);
  161. /************************************************************************
  162. CT8020/CT8021 Host Programmers Model
  163. Host address Function Access
  164. DSPbase +
  165. 0-1 Aux Software Status Register (reserved) Read Only
  166. 2-3 Software Status Register Read Only
  167. 4-5 Aux Software Control Register (reserved) Read Write
  168. 6-7 Software Control Register Read Write
  169. 8-9 Hardware Status Register Read Only
  170. A-B Hardware Control Register Read Write
  171. C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
  172. E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
  173. ************************************************************************/
  175. extern __inline__ void ixj_read_HSR(board)
  176. {
  177. ixj[board].hsr.bytes.low = inb_p(ixj[board].DSPbase + 8);
  178. ixj[board].hsr.bytes.high = inb_p(ixj[board].DSPbase + 9);
  179. }
  180. extern __inline__ int IsControlReady(int board)
  181. {
  182. ixj_read_HSR(board);
  183. return ixj[board].hsr.bits.controlrdy ? 1 : 0;
  184. }
  186. extern __inline__ int IsStatusReady(int board)
  187. {
  188. ixj_read_HSR(board);
  189. return ixj[board].hsr.bits.statusrdy ? 1 : 0;
  190. }
  192. extern __inline__ int IsRxReady(int board)
  193. {
  194. ixj_read_HSR(board);
  195. return ixj[board].hsr.bits.rxrdy ? 1 : 0;
  196. }
  198. extern __inline__ int IsTxReady(int board)
  199. {
  200. ixj_read_HSR(board);
  201. return ixj[board].hsr.bits.txrdy ? 1 : 0;
  202. }
  204. extern __inline__ BYTE SLIC_GetState(int board)
  205. {
  206. IXJ *j = &ixj[board];
  208. j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
  210. return j->pld_slicr.bits.state;
  211. }
  213. static BOOL SLIC_SetState(BYTE byState, int board)
  214. {
  215. BOOL fRetVal = FALSE;
  216. IXJ *j = &ixj[board];
  218. // Set the C1, C2, C3 & B2EN signals.
  219. switch (byState) {
  220. case PLD_SLIC_STATE_OC:
  221. j->pld_slicw.bits.c1 = 0;
  222. j->pld_slicw.bits.c2 = 0;
  223. j->pld_slicw.bits.c3 = 0;
  224. j->pld_slicw.bits.b2en = 0;
  225. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  226. fRetVal = TRUE;
  227. break;
  228. case PLD_SLIC_STATE_RINGING:
  229. j->pld_slicw.bits.c1 = 1;
  230. j->pld_slicw.bits.c2 = 0;
  231. j->pld_slicw.bits.c3 = 0;
  232. j->pld_slicw.bits.b2en = 1;
  233. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  234. fRetVal = TRUE;
  235. break;
  236. case PLD_SLIC_STATE_ACTIVE:
  237. j->pld_slicw.bits.c1 = 0;
  238. j->pld_slicw.bits.c2 = 1;
  239. j->pld_slicw.bits.c3 = 0;
  240. j->pld_slicw.bits.b2en = 0;
  241. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  242. fRetVal = TRUE;
  243. break;
  244. case PLD_SLIC_STATE_OHT: // On-hook transmit
  246. j->pld_slicw.bits.c1 = 1;
  247. j->pld_slicw.bits.c2 = 1;
  248. j->pld_slicw.bits.c3 = 0;
  249. j->pld_slicw.bits.b2en = 0;
  250. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  251. fRetVal = TRUE;
  252. break;
  253. case PLD_SLIC_STATE_TIPOPEN:
  254. j->pld_slicw.bits.c1 = 0;
  255. j->pld_slicw.bits.c2 = 0;
  256. j->pld_slicw.bits.c3 = 1;
  257. j->pld_slicw.bits.b2en = 0;
  258. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  259. fRetVal = TRUE;
  260. break;
  261. case PLD_SLIC_STATE_STANDBY:
  262. j->pld_slicw.bits.c1 = 1;
  263. j->pld_slicw.bits.c2 = 0;
  264. j->pld_slicw.bits.c3 = 1;
  265. j->pld_slicw.bits.b2en = 1;
  266. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  267. fRetVal = TRUE;
  268. break;
  269. case PLD_SLIC_STATE_APR: // Active polarity reversal
  271. j->pld_slicw.bits.c1 = 0;
  272. j->pld_slicw.bits.c2 = 1;
  273. j->pld_slicw.bits.c3 = 1;
  274. j->pld_slicw.bits.b2en = 0;
  275. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  276. fRetVal = TRUE;
  277. break;
  278. case PLD_SLIC_STATE_OHTPR: // OHT polarity reversal
  280. j->pld_slicw.bits.c1 = 1;
  281. j->pld_slicw.bits.c2 = 1;
  282. j->pld_slicw.bits.c3 = 1;
  283. j->pld_slicw.bits.b2en = 0;
  284. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  285. fRetVal = TRUE;
  286. break;
  287. default:
  288. fRetVal = FALSE;
  289. break;
  290. }
  292. return fRetVal;
  293. }
  295. int ixj_register(int index, IXJ_REGFUNC regfunc)
  296. {
  297. int cnt;
  298. int retval = 0;
  299. switch (index) {
  300. case G729LOADER:
  301. ixj_DownloadG729 = regfunc;
  302. for (cnt = 0; cnt < IXJMAX; cnt++)
  303. ixj_DownloadG729(&ixj[cnt], 0L);
  304. break;
  305. case TS85LOADER:
  306. ixj_DownloadTS85 = regfunc;
  307. for (cnt = 0; cnt < IXJMAX; cnt++)
  308. ixj_DownloadTS85(&ixj[cnt], 0L);
  309. break;
  310. case PRE_READ:
  311. ixj_PreRead = regfunc;
  312. break;
  313. case POST_READ:
  314. ixj_PostRead = regfunc;
  315. break;
  316. case PRE_WRITE:
  317. ixj_PreWrite = regfunc;
  318. break;
  319. case POST_WRITE:
  320. ixj_PostWrite = regfunc;
  321. break;
  322. case PRE_IOCTL:
  323. ixj_PreIoctl = regfunc;
  324. break;
  325. case POST_IOCTL:
  326. ixj_PostIoctl = regfunc;
  327. break;
  328. default:
  329. retval = 1;
  330. }
  331. return retval;
  332. }
  334. int ixj_unregister(int index)
  335. {
  336. int retval = 0;
  337. switch (index) {
  338. case G729LOADER:
  339. ixj_DownloadG729 = &Stub;
  340. break;
  341. case TS85LOADER:
  342. ixj_DownloadTS85 = &Stub;
  343. break;
  344. case PRE_READ:
  345. ixj_PreRead = &Stub;
  346. break;
  347. case POST_READ:
  348. ixj_PostRead = &Stub;
  349. break;
  350. case PRE_WRITE:
  351. ixj_PreWrite = &Stub;
  352. break;
  353. case POST_WRITE:
  354. ixj_PostWrite = &Stub;
  355. break;
  356. case PRE_IOCTL:
  357. ixj_PreIoctl = &Stub;
  358. break;
  359. case POST_IOCTL:
  360. ixj_PostIoctl = &Stub;
  361. break;
  362. default:
  363. retval = 1;
  364. }
  365. return retval;
  366. }
  368. void ixj_init_timer(void)
  369. {
  370. init_timer(&ixj_timer);
  371. ixj_timer.function = ixj_timeout;
  372. ixj_timer.data = (int) NULL;
  373. ixj_timer.expires = jiffies + (hertz / samplerate);
  374. add_timer(&ixj_timer);
  375. }
  377. static void ixj_timeout(unsigned long ptr)
  378. {
  379. int board;
  380. unsigned long jifon;
  381. IXJ *j;
  382. IXJ_TONE ti;
  383. static int mutex = 0;
  385. /* What is this trying to do ?? */
  386. /* This is a safeguard in case the loop does not complete before the
  387.    next timer tick.  Since all the work is done during this timer loop,
  388.    we do not want the next iteration of the loop to start before the
  389.    last one finished. */
  391. if (!mutex) {
  392. mutex++;
  393. for (board = 0; board < IXJMAX; board++) {
  394. j = &ixj[board];
  396. if (j->DSPbase) {
  397. #ifdef PERFMON_STATS
  398. j->timerchecks++;
  399. #endif
  400. if (j->tone_state) {
  402. if (!ixj_hookstate(board)) {
  403. ixj_cpt_stop(board);
  404. if (j->m_hook) {
  405. j->m_hook = 0;
  406. j->ex.bits.hookstate = 1;
  407. if (j->async_queue)
  408. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  410. }
  411. goto timer_end;
  412. }
  413. if (j->tone_state == 1)
  414. jifon = (hertz * j->tone_on_time * 25 / 100000);
  415. else
  416. jifon = (hertz * j->tone_on_time * 25 / 100000) +
  417.     (hertz * j->tone_off_time * 25 / 100000);
  418. if (jiffies < j->tone_start_jif + jifon) {
  419. if (j->tone_state == 1) {
  420. ixj_play_tone(board, j->tone_index);
  421. if (j->dsp.low == 0x20) {
  422. goto timer_end;
  423. }
  424. } else {
  425. ixj_play_tone(board, 0);
  426. if (j->dsp.low == 0x20) {
  427. goto timer_end;
  428. }
  429. }
  430. } else {
  431. j->tone_state++;
  432. if (j->tone_state == 3) {
  433. j->tone_state = 0;
  434. if (j->cadence_t) {
  435. j->tone_cadence_state++;
  436. if (j->tone_cadence_state == j->cadence_t->elements_used) {
  437. switch (j->cadence_t->termination) {
  438. case PLAY_ONCE:
  439. ixj_cpt_stop(board);
  440. break;
  441. case REPEAT_LAST_ELEMENT:
  442. j->tone_cadence_state--;
  443. ixj_play_tone(board, j->cadence_t->ce[j->tone_cadence_state].index);
  444. break;
  445. case REPEAT_ALL:
  446. j->tone_cadence_state = 0;
  447. if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
  448. ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
  449. ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
  450. ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
  451. ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
  452. ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
  453. ixj_init_tone(board, &ti);
  454. }
  455. ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, board);
  456. ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, board);
  457. ixj_play_tone(board, j->cadence_t->ce[0].index);
  458. break;
  459. }
  460. } else {
  461. if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
  462. ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
  463. ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
  464. ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
  465. ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
  466. ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
  467. ixj_init_tone(board, &ti);
  468. }
  469. ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, board);
  470. ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, board);
  471. ixj_play_tone(board, j->cadence_t->ce[j->tone_cadence_state].index);
  472. }
  473. }
  474. }
  475. if (j->flags.dialtone) {
  476. ixj_dialtone(board);
  477. }
  478. if (j->flags.busytone) {
  479. ixj_busytone(board);
  480. if (j->dsp.low == 0x20) {
  481. goto timer_end;
  482. }
  483. }
  484. if (j->flags.ringback) {
  485. ixj_ringback(board);
  486. if (j->dsp.low == 0x20) {
  487. goto timer_end;
  488. }
  489. }
  490. if (!j->tone_state) {
  491. if (j->dsp.low == 0x20 || (j->play_mode == -1 && j->rec_mode == -1))
  492. idle(board);
  493. if (j->dsp.low == 0x20 && j->play_mode != -1)
  494. ixj_play_start(board);
  495. if (j->dsp.low == 0x20 && j->rec_mode != -1)
  496. ixj_record_start(board);
  497. }
  498. }
  499. }
  500. if (!j->tone_state || j->dsp.low != 0x20) {
  501. if (IsRxReady(board)) {
  502. ixj_read_frame(board);
  503. }
  504. if (IsTxReady(board)) {
  505. ixj_write_frame(board);
  506. }
  507. }
  508. if (j->flags.cringing) {
  509. if (ixj_hookstate(board) & 1) {
  510. j->flags.cringing = 0;
  511. ixj_ring_off(board);
  512. } else {
  513. if (jiffies - j->ring_cadence_jif >= (.5 * hertz)) {
  514. j->ring_cadence_t--;
  515. if (j->ring_cadence_t == -1)
  516. j->ring_cadence_t = 15;
  517. j->ring_cadence_jif = jiffies;
  518. }
  519. if (j->ring_cadence & 1 << j->ring_cadence_t) {
  520. ixj_ring_on(board);
  521. } else {
  522. ixj_ring_off(board);
  523. }
  524. goto timer_end;
  525. }
  526. }
  527. if (!j->flags.ringing) {
  528. if (ixj_hookstate(board)) {
  529. if (j->dsp.low == 0x21 &&
  530.     j->pld_slicr.bits.state != PLD_SLIC_STATE_ACTIVE)
  531.                 // Internet LineJACK
  532.  {
  533. SLIC_SetState(PLD_SLIC_STATE_ACTIVE, board);
  534. }
  535. LineMonitor(board);
  536. read_filters(board);
  537. ixj_WriteDSPCommand(0x511B, board);
  538. j->proc_load = j->ssr.high << 8 | j->ssr.low;
  539. if (!j->m_hook) {
  540. j->m_hook = j->ex.bits.hookstate = 1;
  541. if (j->async_queue)
  542. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  544. }
  545. } else {
  546. if (j->dsp.low == 0x21 &&
  547.     j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE)
  548.                 // Internet LineJACK
  549.  {
  550. SLIC_SetState(PLD_SLIC_STATE_STANDBY, board);
  551. }
  552. if (j->ex.bits.dtmf_ready) {
  553. j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
  554. }
  555. if (j->m_hook) {
  556. j->m_hook = 0;
  557. j->ex.bits.hookstate = 1;
  558. if (j->async_queue)
  559. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  561. }
  562. }
  563. }
  564. if (j->cardtype == 300) {
  565. if (j->flags.pstn_present) {
  566. j->pld_scrr.byte = inb_p(j->XILINXbase);
  567. if (jiffies >= j->pstn_sleeptil && j->pld_scrr.bits.daaflag) {
  568. daa_int_read(board);
  569. if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
  570. if (!j->flags.pstn_ringing) {
  571. j->flags.pstn_ringing = 1;
  572. if (j->daa_mode != SOP_PU_RINGING)
  573. daa_set_mode(board, SOP_PU_RINGING);
  574. }
  575. }
  576. if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
  577. j->pstn_winkstart = 0;
  578. if (j->flags.pstn_ringing && !j->pstn_envelope) {
  579. j->ex.bits.pstn_ring = 0;
  580. j->pstn_envelope = 1;
  581. j->pstn_ring_start = jiffies;
  582. }
  583. } else {
  584. if (j->flags.pstn_ringing && j->pstn_envelope &&
  585.     jiffies > j->pstn_ring_start + ((hertz * 15) / 10)) {
  586. j->ex.bits.pstn_ring = 1;
  587. j->pstn_envelope = 0;
  588. } else if (j->daa_mode == SOP_PU_CONVERSATION) {
  589. if (!j->pstn_winkstart) {
  590. j->pstn_winkstart = jiffies;
  591. } else if (jiffies > j->pstn_winkstart + (hertz * j->winktime / 1000)) {
  592. daa_set_mode(board, SOP_PU_SLEEP);
  593. j->pstn_winkstart = 0;
  594. j->ex.bits.pstn_wink = 1;
  595. }
  596. } else {
  597. j->ex.bits.pstn_ring = 0;
  598. }
  599. }
  600. if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
  601. if (j->daa_mode == SOP_PU_RINGING) {
  602. daa_set_mode(board, SOP_PU_SLEEP);
  603. j->flags.pstn_ringing = 0;
  604. j->ex.bits.pstn_ring = 0;
  605. }
  606. }
  607. if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
  608. if (j->daa_mode == SOP_PU_RINGING && j->flags.pstn_ringing) {
  609. j->pstn_cid_intr = 1;
  610. j->pstn_cid_recieved = jiffies;
  611. }
  612. }
  613. } else {
  614. if (j->pld_scrr.bits.daaflag) {
  615. daa_int_read(board);
  616. }
  617. j->ex.bits.pstn_ring = 0;
  618. if (j->pstn_cid_intr && jiffies > j->pstn_cid_recieved + (hertz * 3)) {
  619. if (j->daa_mode == SOP_PU_RINGING) {
  620. ixj_daa_cid_read(board);
  621. j->ex.bits.caller_id = 1;
  622. }
  623. j->pstn_cid_intr = 0;
  624. } else {
  625. j->ex.bits.caller_id = 0;
  626. }
  627. if (!j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
  628. if (j->flags.pstn_ringing && j->pstn_envelope) {
  629. j->ex.bits.pstn_ring = 1;
  630. j->pstn_envelope = 0;
  631. } else if (j->daa_mode == SOP_PU_CONVERSATION) {
  632. if (!j->pstn_winkstart) {
  633. j->pstn_winkstart = jiffies;
  634. } else if (jiffies > j->pstn_winkstart + (hertz * 320 / 1000)) {
  635. daa_set_mode(board, SOP_PU_SLEEP);
  636. j->pstn_winkstart = 0;
  637. j->ex.bits.pstn_wink = 1;
  638. }
  639. }
  640. }
  641. }
  642. }
  643. }
  644. if ((j->ex.bits.f0 || j->ex.bits.f1 || j->ex.bits.f2 || j->ex.bits.f3)
  645.     && j->filter_cadence) {
  646. }
  647. if (j->ex.bytes) {
  648. wake_up_interruptible(&j->poll_q); // Wake any blocked selects
  650. if (j->async_queue)
  651. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  653. }
  654. } else {
  655. break;
  656. }
  657. }
  658. }
  659.       timer_end:
  660. if (mutex == 1) {
  661. ixj_init_timer();
  662. mutex--;
  663. }
  664. }
  666. static int ixj_status_wait(int board)
  667. {
  668. unsigned long jif;
  670. jif = jiffies;
  671. while (!IsStatusReady(board)) {
  672. if (jiffies - jif > (60 * (hertz / 100))) {
  673. return -1;
  674. }
  675. }
  676. return 0;
  677. }
  679. int ixj_WriteDSPCommand(unsigned short cmd, int board)
  680. {
  681. BYTES bytes;
  682. unsigned long jif;
  684. bytes.high = (cmd & 0xFF00) >> 8;
  685. bytes.low = cmd & 0x00FF;
  686. jif = jiffies;
  687. while (!IsControlReady(board)) {
  688. if (jiffies - jif > (60 * (hertz / 100))) {
  689. return -1;
  690. }
  691. }
  692. outb_p(bytes.low, ixj[board].DSPbase + 6);
  693. outb_p(bytes.high, ixj[board].DSPbase + 7);
  695. if (ixj_status_wait(board)) {
  696. ixj[board].ssr.low = 0xFF;
  697. ixj[board].ssr.high = 0xFF;
  698. return -1;
  699. }
  700. /* Read Software Status Register */
  701. ixj[board].ssr.low = inb_p(ixj[board].DSPbase + 2);
  702. ixj[board].ssr.high = inb_p(ixj[board].DSPbase + 3);
  703. return 0;
  704. }
  706. /***************************************************************************
  707. *
  708. *  General Purpose IO Register read routine
  709. *
  710. ***************************************************************************/
  711. extern __inline__ int ixj_gpio_read(board)
  712. {
  713. if (ixj_WriteDSPCommand(0x5143, board))
  714. return -1;
  716. ixj[board].gpio.bytes.low = ixj[board].ssr.low;
  717. ixj[board].gpio.bytes.high = ixj[board].ssr.high;
  719. return 0;
  720. }
  722. extern __inline__ void LED_SetState(int state, int board)
  723. {
  724. if (ixj[board].dsp.low == 0x21) {
  725. ixj[board].pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
  726. ixj[board].pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
  727. ixj[board].pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
  728. ixj[board].pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
  730. outb_p(ixj[board].pld_scrw.byte, ixj[board].XILINXbase);
  731. }
  732. }
  734. /*********************************************************************
  735. *  GPIO Pins are configured as follows on the Quicknet Internet
  736. *  PhoneJACK Telephony Cards
  737. * 
  738. * POTS Select        GPIO_6=0 GPIO_7=0
  739. * Mic/Speaker Select GPIO_6=0 GPIO_7=1
  740. * Handset Select     GPIO_6=1 GPIO_7=0
  741. *
  742. * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
  743. * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
  744. * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
  745. *
  746. * Hook Switch changes reported on GPIO_3
  747. *********************************************************************/
  748. static int ixj_set_port(int board, int arg)
  749. {
  750. IXJ *j = &ixj[board];
  752. if (j->cardtype == 400) {
  753. if (arg != PORT_POTS)
  754. return 10;
  755. else
  756. return 0;
  757. }
  758. switch (arg) {
  759. case PORT_POTS:
  760. j->port = PORT_POTS;
  761. switch (j->cardtype) {
  762. case 500:
  763. j->pld_slicw.pcib.mic = 0;
  764. j->pld_slicw.pcib.spk = 0;
  765. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  766. break;
  767. case 300:
  768. if (ixj_WriteDSPCommand(0xC528, board)) /* Write CODEC config to
  769.    Software Control Register */
  770. return 2;
  771. j->pld_scrw.bits.daafsyncen = 0; // Turn off DAA Frame Sync
  773. outb_p(j->pld_scrw.byte, j->XILINXbase);
  774. j->pld_clock.byte = 0;
  775. outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
  776. j->pld_slicw.bits.rly1 = 1;
  777. j->pld_slicw.bits.spken = 0;
  778. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  779. SLIC_SetState(PLD_SLIC_STATE_STANDBY, board);
  780. break;
  781. case 100:
  782. j->gpio.bytes.high = 0x0B;
  783. j->gpio.bits.gpio6 = 0;
  784. j->gpio.bits.gpio7 = 0;
  785. ixj_WriteDSPCommand(j->gpio.word, board);
  786. break;
  787. }
  788. break;
  789. case PORT_PSTN:
  790. if (j->cardtype == 300) {
  791. ixj_WriteDSPCommand(0xC534, board); /* Write CODEC config to Software Control Register */
  793. j->pld_slicw.bits.rly3 = 0;
  794. j->pld_slicw.bits.rly1 = 1;
  795. j->pld_slicw.bits.spken = 0;
  796. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  797. j->port = PORT_PSTN;
  798. } else {
  799. return 4;
  800. }
  801. break;
  802. case PORT_SPEAKER:
  803. j->port = PORT_SPEAKER;
  804. switch (j->cardtype) {
  805. case 500:
  806. j->pld_slicw.pcib.mic = 1;
  807. j->pld_slicw.pcib.spk = 1;
  808. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  809. break;
  810. case 300:
  811. break;
  812. case 100:
  813. j->gpio.bytes.high = 0x0B;
  814. j->gpio.bits.gpio6 = 0;
  815. j->gpio.bits.gpio7 = 1;
  816. ixj_WriteDSPCommand(j->gpio.word, board);
  817. break;
  818. }
  819. break;
  820. case PORT_HANDSET:
  821. if (j->cardtype == 300 || j->cardtype == 500) {
  822. return 5;
  823. } else {
  824. j->gpio.bytes.high = 0x0B;
  825. j->gpio.bits.gpio6 = 1;
  826. j->gpio.bits.gpio7 = 0;
  827. ixj_WriteDSPCommand(j->gpio.word, board);
  828. j->port = PORT_HANDSET;
  829. }
  830. break;
  831. default:
  832. return 6;
  833. break;
  834. }
  835. return 0;
  836. }
  838. static int ixj_set_pots(int board, int arg)
  839. {
  840. IXJ *j = &ixj[board];
  842. if (j->cardtype == 300) {
  843. if (arg) {
  844. if (j->port == PORT_PSTN) {
  845. j->pld_slicw.bits.rly1 = 0;
  846. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  847. return 1;
  848. } else {
  849. return 0;
  850. }
  851. } else {
  852. j->pld_slicw.bits.rly1 = 1;
  853. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  854. return 1;
  855. }
  856. } else {
  857. return 0;
  858. }
  859. }
  861. static void ixj_ring_on(int board)
  862. {
  863. IXJ *j = &ixj[board];
  864. if (j->dsp.low == 0x20) // Internet PhoneJACK
  865.  {
  866. if (ixjdebug > 0)
  867. printk(KERN_INFO "IXJ Ring On /dev/ixj%dn", board);
  869. j->gpio.bytes.high = 0x0B;
  870. j->gpio.bytes.low = 0x00;
  871. j->gpio.bits.gpio1 = 1;
  872. j->gpio.bits.gpio2 = 1;
  873. j->gpio.bits.gpio5 = 0;
  874. ixj_WriteDSPCommand(j->gpio.word, board); /* send the ring signal */
  875. } else //  Internet LineJACK, Internet PhoneJACK Lite or
  876.               //  Internet PhoneJACK PCI
  877.  {
  878. if (ixjdebug > 0)
  879. printk(KERN_INFO "IXJ Ring On /dev/phone%dn", board);
  881. SLIC_SetState(PLD_SLIC_STATE_RINGING, board);
  882. }
  883. }
  885. static int ixj_hookstate(int board)
  886. {
  887. unsigned long det;
  888. IXJ *j = &ixj[board];
  889. int fOffHook = 0;
  891. switch (j->cardtype) {
  892. case 100:
  893. ixj_gpio_read(board);
  894. fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
  895. break;
  896. case 300:
  897. case 400:
  898. case 500:
  899. SLIC_GetState(board);
  900. if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
  901.     j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
  902. if (j->flags.ringing) {
  903. det = jiffies + (hertz / 50);
  904. while (time_before(jiffies, det)) {
  905. current->state = TASK_INTERRUPTIBLE;
  906. schedule_timeout(1);
  907. }
  908. SLIC_GetState(board);
  909. if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
  910. ixj_ring_on(board);
  911. }
  912. }
  913. if (j->cardtype == 500) {
  914. j->pld_scrr.byte = inb_p(j->XILINXbase);
  915. fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
  916. } else
  917. fOffHook = j->pld_slicr.bits.det ? 1 : 0;
  918. }
  919. break;
  920. }
  921. if (j->r_hook != fOffHook) {
  922. j->r_hook = fOffHook;
  923. if (j->port != PORT_POTS) {
  924. j->ex.bits.hookstate = 1;
  925. if (j->async_queue)
  926. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  928. }
  929. }
  930. if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
  931. fOffHook |= 2;
  933. if (j->port == PORT_SPEAKER)
  934. fOffHook |= 2;
  936. if (j->port == PORT_HANDSET)
  937. fOffHook |= 2;
  939. return fOffHook;
  940. }
  942. static void ixj_ring_off(board)
  943. {
  944. IXJ *j = &ixj[board];
  946. if (j->dsp.low == 0x20) // Internet PhoneJACK
  947.  {
  948. if (ixjdebug > 0)
  949. printk(KERN_INFO "IXJ Ring Offn");
  950. j->gpio.bytes.high = 0x0B;
  951. j->gpio.bytes.low = 0x00;
  952. j->gpio.bits.gpio1 = 0;
  953. j->gpio.bits.gpio2 = 1;
  954. j->gpio.bits.gpio5 = 0;
  955. ixj_WriteDSPCommand(j->gpio.word, board);
  956. } else // Internet LineJACK
  957.  {
  958. if (ixjdebug > 0)
  959. printk(KERN_INFO "IXJ Ring Offn");
  961. SLIC_SetState(PLD_SLIC_STATE_STANDBY, board);
  963. SLIC_GetState(board);
  964. }
  965. }
  967. static void ixj_ring_start(board)
  968. {
  969. IXJ *j = &ixj[board];
  971. j->flags.cringing = 1;
  972. if (ixj_hookstate(board) & 1) {
  973. if (j->port == PORT_POTS)
  974. ixj_ring_off(board);
  975. j->flags.cringing = 0;
  976. } else {
  977. j->ring_cadence_jif = jiffies;
  978. j->ring_cadence_t = 15;
  979. if (j->ring_cadence & 1 << j->ring_cadence_t) {
  980. ixj_ring_on(board);
  981. } else {
  982. ixj_ring_off(board);
  983. }
  984. }
  985. }
  987. static int ixj_ring(board)
  988. {
  989. char cntr;
  990. unsigned long jif, det;
  991. IXJ *j = &ixj[board];
  993. j->flags.ringing = 1;
  994. if (ixj_hookstate(board) & 1) {
  995. ixj_ring_off(board);
  996. j->flags.ringing = 0;
  997. return 1;
  998. }
  999. det = 0;
  1000. for (cntr = 0; cntr < j->maxrings; cntr++) {
  1001. jif = jiffies + (1 * hertz);
  1002. ixj_ring_on(board);
  1003. while (time_before(jiffies, jif)) {
  1004. if (ixj_hookstate(board) & 1) {
  1005. ixj_ring_off(board);
  1006. j->flags.ringing = 0;
  1007. return 1;
  1008. }
  1009. current->state = TASK_INTERRUPTIBLE;
  1010. schedule_timeout(1);
  1011. }
  1012. jif = jiffies + (3 * hertz);
  1013. ixj_ring_off(board);
  1014. while (time_before(jiffies, jif)) {
  1015. if (ixj_hookstate(board) & 1) {
  1016. det = jiffies + (hertz / 100);
  1017. while (time_before(jiffies, det)) {
  1018. current->state = TASK_INTERRUPTIBLE;
  1019. schedule_timeout(1);
  1020. }
  1021. if (ixj_hookstate(board) & 1) {
  1022. j->flags.ringing = 0;
  1023. return 1;
  1024. }
  1025. }
  1026. current->state = TASK_INTERRUPTIBLE;
  1027. schedule_timeout(1);
  1028. }
  1029. }
  1030. ixj_ring_off(board);
  1031. j->flags.ringing = 0;
  1032. return 0;
  1033. }
  1035. int ixj_open(struct phone_device *p, struct file *file_p)
  1036. {
  1037. IXJ *j = &ixj[p->board];
  1039. if (!j->DSPbase)
  1040. return -ENODEV;
  1042. if (file_p->f_mode & FMODE_READ)
  1043. j->readers++;
  1044. if (file_p->f_mode & FMODE_WRITE)
  1045. j->writers++;
  1047. MOD_INC_USE_COUNT;
  1049. if (ixjdebug > 0)
  1050. //    printk(KERN_INFO "Opening board %dn", NUM(inode->i_rdev));
  1051. printk(KERN_INFO "Opening board %dn", p->board);
  1053. return 0;
  1054. }
  1056. int ixj_release(struct inode *inode, struct file *file_p)
  1057. {
  1058. IXJ_TONE ti;
  1059. int board = NUM(inode->i_rdev);
  1060. IXJ *j = &ixj[board];
  1062. if (ixjdebug > 0)
  1063. printk(KERN_INFO "Closing board %dn", NUM(inode->i_rdev));
  1065. daa_set_mode(board, SOP_PU_SLEEP);
  1066. ixj_set_port(board, PORT_POTS);
  1067. aec_stop(board);
  1068. ixj_play_stop(board);
  1069. ixj_record_stop(board);
  1071. ti.tone_index = 10;
  1072. ti.gain0 = 1;
  1073. ti.freq0 = hz941;
  1074. ti.gain1 = 0;
  1075. ti.freq1 = hz1209;
  1076. ti.tone_index = 11;
  1077. ti.gain0 = 1;
  1078. ti.freq0 = hz941;
  1079. ti.gain1 = 0;
  1080. ti.freq1 = hz1336;
  1081. ti.tone_index = 12;
  1082. ti.gain0 = 1;
  1083. ti.freq0 = hz941;
  1084. ti.gain1 = 0;
  1085. ti.freq1 = hz1477;
  1086. ti.tone_index = 13;
  1087. ti.gain0 = 1;
  1088. ti.freq0 = hz800;
  1089. ti.gain1 = 0;
  1090. ti.freq1 = 0;
  1091. ixj_init_tone(board, &ti);
  1092. ti.tone_index = 14;
  1093. ti.gain0 = 1;
  1094. ti.freq0 = hz1000;
  1095. ti.gain1 = 0;
  1096. ti.freq1 = 0;
  1097. ixj_init_tone(board, &ti);
  1098. ti.tone_index = 15;
  1099. ti.gain0 = 1;
  1100. ti.freq0 = hz1250;
  1101. ti.gain1 = 0;
  1102. ti.freq1 = 0;
  1103. ixj_init_tone(board, &ti);
  1104. ti.tone_index = 16;
  1105. ti.gain0 = 1;
  1106. ti.freq0 = hz950;
  1107. ti.gain1 = 0;
  1108. ti.freq1 = 0;
  1109. ixj_init_tone(board, &ti);
  1110. ti.tone_index = 17;
  1111. ti.gain0 = 1;
  1112. ti.freq0 = hz1100;
  1113. ti.gain1 = 0;
  1114. ti.freq1 = 0;
  1115. ixj_init_tone(board, &ti);
  1116. ti.tone_index = 18;
  1117. ti.gain0 = 1;
  1118. ti.freq0 = hz1400;
  1119. ti.gain1 = 0;
  1120. ti.freq1 = 0;
  1121. ixj_init_tone(board, &ti);
  1122. ti.tone_index = 19;
  1123. ti.gain0 = 1;
  1124. ti.freq0 = hz1500;
  1125. ti.gain1 = 0;
  1126. ti.freq1 = 0;
  1127. ixj_init_tone(board, &ti);
  1128. ti.tone_index = 20;
  1129. ti.gain0 = 1;
  1130. ti.freq0 = hz1600;
  1131. ti.gain1 = 0;
  1132. ti.freq1 = 0;
  1133. ixj_init_tone(board, &ti);
  1134. ti.tone_index = 21;
  1135. ti.gain0 = 1;
  1136. ti.freq0 = hz1800;
  1137. ti.gain1 = 0;
  1138. ti.freq1 = 0;
  1139. ixj_init_tone(board, &ti);
  1140. ti.tone_index = 22;
  1141. ti.gain0 = 1;
  1142. ti.freq0 = hz2100;
  1143. ti.gain1 = 0;
  1144. ti.freq1 = 0;
  1145. ixj_init_tone(board, &ti);
  1146. ti.tone_index = 23;
  1147. ti.gain0 = 1;
  1148. ti.freq0 = hz1300;
  1149. ti.gain1 = 0;
  1150. ti.freq1 = 0;
  1151. ixj_init_tone(board, &ti);
  1152. ti.tone_index = 24;
  1153. ti.gain0 = 1;
  1154. ti.freq0 = hz2450;
  1155. ti.gain1 = 0;
  1156. ti.freq1 = 0;
  1157. ixj_init_tone(board, &ti);
  1158. ti.tone_index = 25;
  1159. ti.gain0 = 1;
  1160. ti.freq0 = hz350;
  1161. ti.gain1 = 0;
  1162. ti.freq1 = hz440;
  1163. ixj_init_tone(board, &ti);
  1164. ti.tone_index = 26;
  1165. ti.gain0 = 1;
  1166. ti.freq0 = hz440;
  1167. ti.gain1 = 0;
  1168. ti.freq1 = hz480;
  1169. ixj_init_tone(board, &ti);
  1170. ti.tone_index = 27;
  1171. ti.gain0 = 1;
  1172. ti.freq0 = hz480;
  1173. ti.gain1 = 0;
  1174. ti.freq1 = hz620;
  1175. ixj_init_tone(board, &ti);
  1177. idle(board);
  1179. if (file_p->f_mode & FMODE_READ)
  1180. j->readers--;
  1181. if (file_p->f_mode & FMODE_WRITE)
  1182. j->writers--;
  1184. if (j->read_buffer && !j->readers) {
  1185. kfree(j->read_buffer);
  1186. j->read_buffer = NULL;
  1187. j->read_buffer_size = 0;
  1188. }
  1189. if (j->write_buffer && !j->writers) {
  1190. kfree(j->write_buffer);
  1191. j->write_buffer = NULL;
  1192. j->write_buffer_size = 0;
  1193. }
  1194. j->rec_codec = j->play_codec = 0;
  1195. j->rec_frame_size = j->play_frame_size = 0;
  1196. ixj_fasync(-1, file_p, 0); // remove from list of async notification
  1198. MOD_DEC_USE_COUNT;
  1199. return 0;
  1200. }
  1202. static int read_filters(int board)
  1203. {
  1204. unsigned short fc, cnt;
  1205. IXJ *j = &ixj[board];
  1207. if (ixj_WriteDSPCommand(0x5144, board))
  1208. return -1;
  1210. fc = j->ssr.high << 8 | j->ssr.low;
  1211. if (fc == j->frame_count)
  1212. return 1;
  1214. j->frame_count = fc;
  1216. for (cnt = 0; cnt < 4; cnt++) {
  1217. if (ixj_WriteDSPCommand(0x5154 + cnt, board))
  1218. return -1;
  1220. if (ixj_WriteDSPCommand(0x515C, board))
  1221. return -1;
  1223. j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
  1224. if ((j->filter_hist[cnt] & 1 && !(j->filter_hist[cnt] & 2)) ||
  1225. (j->filter_hist[cnt] & 2 && !(j->filter_hist[cnt] & 1))) {
  1226. switch (cnt) {
  1227. case 0:
  1228. j->ex.bits.f0 = 1;
  1229. break;
  1230. case 1:
  1231. j->ex.bits.f1 = 1;
  1232. break;
  1233. case 2:
  1234. j->ex.bits.f2 = 1;
  1235. break;
  1236. case 3:
  1237. j->ex.bits.f3 = 1;
  1238. break;
  1239. }
  1240. }
  1241. }
  1242. return 0;
  1243. }
  1245. static int LineMonitor(int board)
  1246. {
  1247. IXJ *j = &ixj[board];
  1249. if (j->dtmf_proc) {
  1250. return -1;
  1251. }
  1252. j->dtmf_proc = 1;
  1254. if (ixj_WriteDSPCommand(0x7000, board)) // Line Monitor
  1256. return -1;
  1258. j->dtmf.bytes.high = j->ssr.high;
  1259. j->dtmf.bytes.low = j->ssr.low;
  1260. if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
  1261. j->dtmf_state = 1;
  1262. j->dtmf_current = j->dtmf.bits.digit;
  1263. }
  1264. if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) // && j->dtmf_wp != j->dtmf_rp)
  1265.  {
  1266. j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
  1267. j->dtmf_wp++;
  1268. if (j->dtmf_wp == 79)
  1269. j->dtmf_wp = 0;
  1270. j->ex.bits.dtmf_ready = 1;
  1271. j->dtmf_state = 0;
  1272. }
  1273. j->dtmf_proc = 0;
  1275. return 0;
  1276. }
  1278. ssize_t ixj_read(struct file * file_p, char *buf, size_t length, loff_t * ppos)
  1279. {
  1280. unsigned long i = *ppos;
  1281. IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];
  1282. struct wait_queue wait =
  1283. {current, NULL};
  1285. add_wait_queue(&j->read_q, &wait);
  1286. current->state = TASK_INTERRUPTIBLE;
  1287. mb();
  1289. while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
  1290. ++j->read_wait;
  1291. if (file_p->f_flags & O_NONBLOCK) {
  1292. current->state = TASK_RUNNING;
  1293. remove_wait_queue(&j->read_q, &wait);
  1294. return -EAGAIN;
  1295. }
  1296. if (!ixj_hookstate(NUM(file_p->f_dentry->d_inode->i_rdev))) {
  1297. current->state = TASK_RUNNING;
  1298. remove_wait_queue(&j->read_q, &wait);
  1299. return 0;
  1300. }
  1301. interruptible_sleep_on(&j->read_q);
  1302. if (signal_pending(current)) {
  1303. current->state = TASK_RUNNING;
  1304. remove_wait_queue(&j->read_q, &wait);
  1305. return -EINTR;
  1306. }
  1307. }
  1309. remove_wait_queue(&j->read_q, &wait);
  1310. current->state = TASK_RUNNING;
  1311. /* Don't ever copy more than the user asks */
  1312. i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
  1313. j->read_buffer_ready = 0;
  1314. if (i)
  1315. return -EFAULT;
  1316. else
  1317. return min(length, j->read_buffer_size);
  1318. }
  1320. ssize_t ixj_enhanced_read(struct file * file_p, char *buf, size_t length,
  1321.   loff_t * ppos)
  1322. {
  1323. int pre_retval;
  1324. ssize_t read_retval = 0;
  1325. IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];
  1327. pre_retval = ixj_PreRead(j, 0L);
  1328. switch (pre_retval) {
  1329. case NORMAL:
  1330. read_retval = ixj_read(file_p, buf, length, ppos);
  1331. ixj_PostRead(j, 0L);
  1332. break;
  1333. case NOPOST:
  1334. read_retval = ixj_read(file_p, buf, length, ppos);
  1335. break;
  1336. case POSTONLY:
  1337. ixj_PostRead(j, 0L);
  1338. break;
  1339. default:
  1340. read_retval = pre_retval;
  1341. }
  1342. return read_retval;
  1343. }
  1345. ssize_t ixj_write(struct file * file_p, const char *buf, size_t count, loff_t * ppos)
  1346. {
  1347. unsigned long i = *ppos;
  1348. int board = NUM(file_p->f_dentry->d_inode->i_rdev);
  1349. IXJ *j = &ixj[board];
  1350. struct wait_queue wait =
  1351. {current, NULL};
  1353. add_wait_queue(&j->read_q, &wait);
  1354. current->state = TASK_INTERRUPTIBLE;
  1355. mb();
  1358. while (!j->write_buffers_empty) {
  1359. ++j->write_wait;
  1360. if (file_p->f_flags & O_NONBLOCK) {
  1361. current->state = TASK_RUNNING;
  1362. remove_wait_queue(&j->read_q, &wait);
  1363. return -EAGAIN;
  1364. }
  1365. if (!ixj_hookstate(NUM(file_p->f_dentry->d_inode->i_rdev))) {
  1366. current->state = TASK_RUNNING;
  1367. remove_wait_queue(&j->read_q, &wait);
  1368. return 0;
  1369. }
  1370. interruptible_sleep_on(&j->write_q);
  1371. if (signal_pending(current)) {
  1372. current->state = TASK_RUNNING;
  1373. remove_wait_queue(&j->read_q, &wait);
  1374. return -EINTR;
  1375. }
  1376. }
  1377. current->state = TASK_RUNNING;
  1378. remove_wait_queue(&j->read_q, &wait);
  1379. if (j->write_buffer_wp + count >= j->write_buffer_end)
  1380. j->write_buffer_wp = j->write_buffer;
  1381. i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
  1382. if (i)
  1383. return -EFAULT;
  1385. return min(count, j->write_buffer_size);
  1386. }
  1388. ssize_t ixj_enhanced_write(struct file * file_p, const char *buf, size_t count,
  1389.    loff_t * ppos)
  1390. {
  1391. int pre_retval;
  1392. ssize_t write_retval = 0;
  1393. IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];
  1395. pre_retval = ixj_PreWrite(j, 0L);
  1396. switch (pre_retval) {
  1397. case NORMAL:
  1398. write_retval = ixj_write(file_p, buf, count, ppos);
  1399. if (write_retval != -EFAULT) {
  1400. ixj_PostWrite(j, 0L);
  1401. j->write_buffer_wp += count;
  1402. j->write_buffers_empty--;
  1403. }
  1404. break;
  1405. case NOPOST:
  1406. write_retval = ixj_write(file_p, buf, count, ppos);
  1407. if (write_retval != -EFAULT) {
  1408. j->write_buffer_wp += count;
  1409. j->write_buffers_empty--;
  1410. }
  1411. break;
  1412. case POSTONLY:
  1413. ixj_PostWrite(j, 0L);
  1414. break;
  1415. default:
  1416. write_retval = pre_retval;
  1417. }
  1418. return write_retval;
  1419. }
  1421. static void ixj_read_frame(int board)
  1422. {
  1423. int cnt, dly;
  1424. IXJ *j = &ixj[board];
  1426. if (j->read_buffer) {
  1427. for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
  1428. if (!(cnt % 16) && !IsRxReady(board)) {
  1429. dly = 0;
  1430. while (!IsRxReady(board)) {
  1431. if (dly++ > 5) {
  1432. dly = 0;
  1433. break;
  1434. }
  1435. udelay(10);
  1436. }
  1437. }
  1438. // Throw away word 0 of the 8021 compressed format to get standard G.729.
  1439. if (j->rec_codec == G729 && (cnt == 0 || cnt == 5 || cnt == 10)) {
  1440. inb_p(j->DSPbase + 0x0E);
  1441. inb_p(j->DSPbase + 0x0F);
  1442. }
  1443. *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
  1444. *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
  1445. }
  1446. #ifdef PERFMON_STATS
  1447. ++j->framesread;
  1448. #endif
  1449. if (j->intercom != -1) {
  1450. if (IsTxReady(j->intercom)) {
  1451. for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
  1452. if (!(cnt % 16) && !IsTxReady(board)) {
  1453. dly = 0;
  1454. while (!IsTxReady(board)) {
  1455. if (dly++ > 5) {
  1456. dly = 0;
  1457. break;
  1458. }
  1459. udelay(10);
  1460. }
  1461. }
  1462. outb_p(*(j->read_buffer + cnt), ixj[j->intercom].DSPbase + 0x0C);
  1463. outb_p(*(j->read_buffer + cnt + 1), ixj[j->intercom].DSPbase + 0x0D);
  1464. }
  1465. #ifdef PERFMON_STATS
  1466. ++ixj[j->intercom].frameswritten;
  1467. #endif
  1468. }
  1469. } else {
  1470. j->read_buffer_ready = 1;
  1471. wake_up_interruptible(&j->read_q); // Wake any blocked readers
  1473. wake_up_interruptible(&j->poll_q); // Wake any blocked selects
  1475. if (j->async_queue)
  1476. kill_fasync(j->async_queue, SIGIO); // Send apps notice of frame
  1478. }
  1479. }
  1480. }
  1482. static void ixj_write_frame(int board)
  1483. {
  1484. int cnt, frame_count, dly;
  1485. BYTES blankword;
  1486. IXJ *j = &ixj[board];
  1488. frame_count = 0;
  1489. if (j->write_buffer && j->write_buffers_empty < 2) {
  1490. if (j->write_buffer_wp > j->write_buffer_rp) {
  1491. frame_count =
  1492.     (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
  1493. }
  1494. if (j->write_buffer_rp > j->write_buffer_wp) {
  1495. frame_count =
  1496.     (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
  1497.     (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
  1498. }
  1499. if (frame_count >= 1) {
  1500. if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
  1501. switch (j->play_mode) {
  1502. case PLAYBACK_MODE_ULAW:
  1503. case PLAYBACK_MODE_ALAW:
  1504. blankword.low = blankword.high = 0xFF;
  1505. break;
  1506. case PLAYBACK_MODE_8LINEAR:
  1507. case PLAYBACK_MODE_16LINEAR:
  1508. blankword.low = blankword.high = 0x00;
  1509. break;
  1510. case PLAYBACK_MODE_8LINEAR_WSS:
  1511. blankword.low = blankword.high = 0x80;
  1512. break;
  1513. }
  1514. for (cnt = 0; cnt < 16; cnt++) {
  1515. if (!(cnt % 16) && !IsTxReady(board)) {
  1516. dly = 0;
  1517. while (!IsTxReady(board)) {
  1518. if (dly++ > 5) {
  1519. dly = 0;
  1520. break;
  1521. }
  1522. udelay(10);
  1523. }
  1524. }
  1525. outb_p((blankword.low), j->DSPbase + 0x0C);
  1526. outb_p((blankword.high), j->DSPbase + 0x0D);
  1527. }
  1528. j->flags.play_first_frame = 0;
  1529. }
  1530. for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
  1531. if (!(cnt % 16) && !IsTxReady(board)) {
  1532. dly = 0;
  1533. while (!IsTxReady(board)) {
  1534. if (dly++ > 5) {
  1535. dly = 0;
  1536. break;
  1537. }
  1538. udelay(10);
  1539. }
  1540. }
  1541. // Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG 
  1542. // so all frames are type 1.
  1543. if (j->play_codec == G729 && (cnt == 0 || cnt == 5 || cnt == 10)) {
  1544. outb_p(0x01, j->DSPbase + 0x0C);
  1545. outb_p(0x00, j->DSPbase + 0x0D);
  1546. }
  1547. outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
  1548. outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
  1549. *(j->write_buffer_rp + cnt) = 0;
  1550. *(j->write_buffer_rp + cnt + 1) = 0;
  1551. }
  1552. j->write_buffer_rp += j->play_frame_size * 2;
  1553. if (j->write_buffer_rp >= j->write_buffer_end) {
  1554. j->write_buffer_rp = j->write_buffer;
  1555. }
  1556. j->write_buffers_empty++;
  1557. wake_up_interruptible(&(j->write_q)); // Wake any blocked writers
  1559. wake_up_interruptible(&j->poll_q); // Wake any blocked selects
  1561. if (j->async_queue)
  1562. kill_fasync(j->async_queue, SIGIO); // Send apps notice of empty buffer
  1563. #ifdef PERFMON_STATS
  1564. ++j->frameswritten;
  1565. #endif
  1566. }
  1567. } else {
  1568. j->drybuffer++;
  1569. }
  1570. }
  1572. static int idle(int board)
  1573. {
  1574. IXJ *j = &ixj[board];
  1576. if (ixj_WriteDSPCommand(0x0000, board)) // DSP Idle
  1578. return 0;
  1579. if (j->ssr.high || j->ssr.low)
  1580. return 0;
  1581. else
  1582. return 1;
  1583. }
  1585. static int set_base_frame(int board, int size)
  1586. {
  1587. unsigned short cmd;
  1588. int cnt;
  1589. IXJ *j = &ixj[board];
  1591. aec_stop(board);
  1592. for (cnt = 0; cnt < 10; cnt++) {
  1593. if (idle(board))
  1594. break;
  1595. }
  1596. if (j->ssr.high || j->ssr.low)
  1597. return -1;
  1598. if (j->dsp.low != 0x20) {
  1599. switch (size) {
  1600. case 30:
  1601. cmd = 0x07F0;
  1602. /* Set Base Frame Size to 240 pg9-10 8021 */
  1603. break;
  1604. case 20:
  1605. cmd = 0x07A0;
  1606. /* Set Base Frame Size to 160 pg9-10 8021 */
  1607. break;
  1608. case 10:
  1609. cmd = 0x0750;
  1610. /* Set Base Frame Size to 80 pg9-10 8021 */
  1611. break;
  1612. default:
  1613. return -1;
  1614. }
  1615. } else {
  1616. if (size == 30)
  1617. return size;
  1618. else
  1619. return -1;
  1620. }
  1621. if (ixj_WriteDSPCommand(cmd, board)) {
  1622. j->baseframe.high = j->baseframe.low = 0xFF;
  1623. return -1;
  1624. } else {
  1625. j->baseframe.high = j->ssr.high;
  1626. j->baseframe.low = j->ssr.low;
  1627. }
  1628. return size;
  1629. }
  1631. static int set_rec_codec(int board, int rate)
  1632. {
  1633. int retval = 0;
  1634. IXJ *j = &ixj[board];
  1636. j->rec_codec = rate;
  1638. switch (rate) {
  1639. case G723_63:
  1640. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  1641. j->rec_frame_size = 12;
  1642. j->rec_mode = 0;
  1643. } else {
  1644. retval = 1;
  1645. }
  1646. break;
  1647. case G723_53:
  1648. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  1649. j->rec_frame_size = 10;
  1650. j->rec_mode = 0;
  1651. } else {
  1652. retval = 1;
  1653. }
  1654. break;
  1655. case TS85:
  1656. if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
  1657. j->rec_frame_size = 16;
  1658. j->rec_mode = 0;
  1659. } else {
  1660. retval = 1;
  1661. }
  1662. break;
  1663. case TS48:
  1664. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  1665. j->rec_frame_size = 9;
  1666. j->rec_mode = 0;
  1667. } else {
  1668. retval = 1;
  1669. }
  1670. break;
  1671. case TS41:
  1672. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  1673. j->rec_frame_size = 8;
  1674. j->rec_mode = 0;
  1675. } else {
  1676. retval = 1;
  1677. }
  1678. break;
  1679. case G728:
  1680. if (j->dsp.low != 0x20) {
  1681. j->rec_frame_size = 48;
  1682. j->rec_mode = 0;
  1683. } else {
  1684. retval = 1;
  1685. }
  1686. break;
  1687. case G729:
  1688. if (j->dsp.low != 0x20) {
  1689. if (!j->flags.g729_loaded) {
  1690. retval = 1;
  1691. break;
  1692. }
  1693. switch (j->baseframe.low) {
  1694. case 0xA0:
  1695. j->rec_frame_size = 10;
  1696. break;
  1697. case 0x50:
  1698. j->rec_frame_size = 5;
  1699. break;
  1700. default:
  1701. j->rec_frame_size = 15;
  1702. break;
  1703. }
  1704. j->rec_mode = 0;
  1705. } else {
  1706. retval = 1;
  1707. }
  1708. break;
  1709. case ULAW:
  1710. switch (j->baseframe.low) {
  1711. case 0xA0:
  1712. j->rec_frame_size = 80;
  1713. break;
  1714. case 0x50:
  1715. j->rec_frame_size = 40;
  1716. break;
  1717. default:
  1718. j->rec_frame_size = 120;
  1719. break;
  1720. }
  1721. j->rec_mode = 4;
  1722. break;
  1723. case ALAW:
  1724. switch (j->baseframe.low) {
  1725. case 0xA0:
  1726. j->rec_frame_size = 80;
  1727. break;
  1728. case 0x50:
  1729. j->rec_frame_size = 40;
  1730. break;
  1731. default:
  1732. j->rec_frame_size = 120;
  1733. break;
  1734. }
  1735. j->rec_mode = 4;
  1736. break;
  1737. case LINEAR16:
  1738. switch (j->baseframe.low) {
  1739. case 0xA0:
  1740. j->rec_frame_size = 160;
  1741. break;
  1742. case 0x50:
  1743. j->rec_frame_size = 80;
  1744. break;
  1745. default:
  1746. j->rec_frame_size = 240;
  1747. break;
  1748. }
  1749. j->rec_mode = 5;
  1750. break;
  1751. case LINEAR8:
  1752. switch (j->baseframe.low) {
  1753. case 0xA0:
  1754. j->rec_frame_size = 80;
  1755. break;
  1756. case 0x50:
  1757. j->rec_frame_size = 40;
  1758. break;
  1759. default:
  1760. j->rec_frame_size = 120;
  1761. break;
  1762. }
  1763. j->rec_mode = 6;
  1764. break;
  1765. case WSS:
  1766. switch (j->baseframe.low) {
  1767. case 0xA0:
  1768. j->rec_frame_size = 80;
  1769. break;
  1770. case 0x50:
  1771. j->rec_frame_size = 40;
  1772. break;
  1773. default:
  1774. j->rec_frame_size = 120;
  1775. break;
  1776. }
  1777. j->rec_mode = 7;
  1778. break;
  1779. default:
  1780. j->rec_frame_size = 0;
  1781. j->rec_mode = -1;
  1782. if (j->read_buffer) {
  1783. kfree(j->read_buffer);
  1784. j->read_buffer = NULL;
  1785. j->read_buffer_size = 0;
  1786. }
  1787. retval = 1;
  1788. break;
  1789. }
  1790. return retval;
  1791. }
  1793. static int ixj_record_start(int board)
  1794. {
  1795. unsigned short cmd = 0x0000;
  1796. IXJ *j = &ixj[board];
  1798. if (!j->rec_mode) {
  1799. switch (j->rec_codec) {
  1800. case G723_63:
  1801. cmd = 0x5131;
  1802. break;
  1803. case G723_53:
  1804. cmd = 0x5132;
  1805. break;
  1806. case TS85:
  1807. cmd = 0x5130; // TrueSpeech 8.5
  1809. break;
  1810. case TS48:
  1811. cmd = 0x5133; // TrueSpeech 4.8
  1813. break;
  1814. case TS41:
  1815. cmd = 0x5134; // TrueSpeech 4.1
  1817. break;
  1818. case G728:
  1819. cmd = 0x5135;
  1820. break;
  1821. case G729:
  1822. cmd = 0x5136;
  1823. break;
  1824. default:
  1825. return 1;
  1826. }
  1827. if (ixj_WriteDSPCommand(cmd, board))
  1828. return -1;
  1829. }
  1830. if (!j->read_buffer) {
  1831. if (!j->read_buffer)
  1832. j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_KERNEL);
  1833. if (!j->read_buffer) {
  1834. printk("Read buffer allocation for ixj board %d failed!n", board);
  1835. return -ENOMEM;
  1836. }
  1837. }
  1838. j->read_buffer_size = j->rec_frame_size * 2;
  1840. if (ixj_WriteDSPCommand(0x5102, board)) // Set Poll sync mode
  1842. return -1;
  1844. switch (j->rec_mode) {
  1845. case 0:
  1846. cmd = 0x1C03; // Record C1
  1848. break;
  1849. case 4:
  1850. if (j->ver.low == 0x12) {
  1851. cmd = 0x1E03; // Record C1
  1853. } else {
  1854. cmd = 0x1E01; // Record C1
  1856. }
  1857. break;
  1858. case 5:
  1859. if (j->ver.low == 0x12) {
  1860. cmd = 0x1E83; // Record C1
  1862. } else {
  1863. cmd = 0x1E81; // Record C1
  1865. }
  1866. break;
  1867. case 6:
  1868. if (j->ver.low == 0x12) {
  1869. cmd = 0x1F03; // Record C1
  1871. } else {
  1872. cmd = 0x1F01; // Record C1
  1874. }
  1875. break;
  1876. case 7:
  1877. if (j->ver.low == 0x12) {
  1878. cmd = 0x1F83; // Record C1
  1880. } else {
  1881. cmd = 0x1F81; // Record C1
  1883. }
  1884. break;
  1885. }
  1886. if (ixj_WriteDSPCommand(cmd, board))
  1887. return -1;
  1889. return 0;
  1890. }
  1892. static void ixj_record_stop(int board)
  1893. {
  1894. IXJ *j = &ixj[board];
  1896. if (j->rec_mode > -1) {
  1897. ixj_WriteDSPCommand(0x5120, board);
  1898. j->rec_mode = -1;
  1899. }
  1900. }
  1902. static void set_rec_depth(int board, int depth)
  1903. {
  1904. if (depth > 60)
  1905. depth = 60;
  1906. if (depth < 0)
  1907. depth = 0;
  1908. ixj_WriteDSPCommand(0x5180 + depth, board);
  1909. }
  1911. static void set_rec_volume(int board, int volume)
  1912. {
  1913. ixj_WriteDSPCommand(0xCF03, board);
  1914. ixj_WriteDSPCommand(volume, board);
  1915. }
  1917. static int get_rec_level(int board)
  1918. {
  1919. IXJ *j = &ixj[board];
  1921. ixj_WriteDSPCommand(0xCF88, board);
  1923. return j->ssr.high << 8 | j->ssr.low;
  1924. }
  1926. static void ixj_aec_start(int board, int level)
  1927. {
  1928. IXJ *j = &ixj[board];
  1930. j->aec_level = level;
  1931. if (!level) {
  1932. ixj_WriteDSPCommand(0xB002, board);
  1933. } else {
  1934. if (j->rec_codec == G729 || j->play_codec == G729) {
  1935. ixj_WriteDSPCommand(0xE022, board); // Move AEC filter buffer
  1937. ixj_WriteDSPCommand(0x0300, board);
  1938. }
  1939. ixj_WriteDSPCommand(0xB001, board); // AEC On
  1941. ixj_WriteDSPCommand(0xE013, board); // Advanced AEC C1
  1943. switch (level) {
  1944. case 1:
  1945. ixj_WriteDSPCommand(0x0000, board); // Advanced AEC C2 = off
  1947. ixj_WriteDSPCommand(0xE011, board);
  1948. ixj_WriteDSPCommand(0xFFFF, board);
  1949. break;
  1951. case 2:
  1952. ixj_WriteDSPCommand(0x0600, board); // Advanced AEC C2 = on medium
  1954. ixj_WriteDSPCommand(0xE011, board);
  1955. ixj_WriteDSPCommand(0x0080, board);
  1956. break;
  1958. case 3:
  1959. ixj_WriteDSPCommand(0x0C00, board); // Advanced AEC C2 = on high
  1961. ixj_WriteDSPCommand(0xE011, board);
  1962. ixj_WriteDSPCommand(0x0080, board);
  1963. break;
  1964. }
  1965. }
  1966. }
  1968. static void aec_stop(int board)
  1969. {
  1970. IXJ *j = &ixj[board];
  1972. if (j->rec_codec == G729 || j->play_codec == G729) {
  1973. ixj_WriteDSPCommand(0xE022, board); // Move AEC filter buffer back
  1975. ixj_WriteDSPCommand(0x0700, board);
  1976. }
  1977. if (ixj[board].play_mode != -1 && ixj[board].rec_mode != -1);
  1978. {
  1979. ixj_WriteDSPCommand(0xB002, board); // AEC Stop
  1981. }
  1982. }
  1984. static int set_play_codec(int board, int rate)
  1985. {
  1986. int retval = 0;
  1987. IXJ *j = &ixj[board];
  1989. j->play_codec = rate;
  1991. switch (rate) {
  1992. case G723_63:
  1993. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  1994. j->play_frame_size = 12;
  1995. j->play_mode = 0;
  1996. } else {
  1997. retval = 1;
  1998. }
  1999. break;
  2000. case G723_53:
  2001. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  2002. j->play_frame_size = 10;
  2003. j->play_mode = 0;
  2004. } else {
  2005. retval = 1;
  2006. }
  2007. break;
  2008. case TS85:
  2009. if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
  2010. j->play_frame_size = 16;
  2011. j->play_mode = 0;
  2012. } else {
  2013. retval = 1;
  2014. }
  2015. break;
  2016. case TS48:
  2017. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  2018. j->play_frame_size = 9;
  2019. j->play_mode = 0;
  2020. } else {
  2021. retval = 1;
  2022. }
  2023. break;
  2024. case TS41:
  2025. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  2026. j->play_frame_size = 8;
  2027. j->play_mode = 0;
  2028. } else {
  2029. retval = 1;
  2030. }
  2031. break;
  2032. case G728:
  2033. if (j->dsp.low != 0x20) {
  2034. j->play_frame_size = 48;
  2035. j->play_mode = 0;
  2036. } else {
  2037. retval = 1;
  2038. }
  2039. break;
  2040. case G729:
  2041. if (j->dsp.low != 0x20) {
  2042. if (!j->flags.g729_loaded) {
  2043. retval = 1;
  2044. break;
  2045. }
  2046. switch (j->baseframe.low) {
  2047. case 0xA0:
  2048. j->play_frame_size = 10;
  2049. break;
  2050. case 0x50:
  2051. j->play_frame_size = 5;
  2052. break;
  2053. default:
  2054. j->play_frame_size = 15;
  2055. break;
  2056. }
  2057. j->play_mode = 0;
  2058. } else {
  2059. retval = 1;
  2060. }
  2061. break;
  2062. case ULAW:
  2063. switch (j->baseframe.low) {
  2064. case 0xA0:
  2065. j->play_frame_size = 80;
  2066. break;
  2067. case 0x50:
  2068. j->play_frame_size = 40;
  2069. break;
  2070. default:
  2071. j->play_frame_size = 120;
  2072. break;
  2073. }
  2074. j->play_mode = 2;
  2075. break;
  2076. case ALAW:
  2077. switch (j->baseframe.low) {
  2078. case 0xA0:
  2079. j->play_frame_size = 80;
  2080. break;
  2081. case 0x50:
  2082. j->play_frame_size = 40;
  2083. break;
  2084. default:
  2085. j->play_frame_size = 120;
  2086. break;
  2087. }
  2088. j->play_mode = 2;
  2089. break;
  2090. case LINEAR16:
  2091. switch (j->baseframe.low) {
  2092. case 0xA0:
  2093. j->play_frame_size = 160;
  2094. break;
  2095. case 0x50:
  2096. j->play_frame_size = 80;
  2097. break;
  2098. default:
  2099. j->play_frame_size = 240;
  2100. break;
  2101. }
  2102. j->play_mode = 6;
  2103. break;
  2104. case LINEAR8:
  2105. switch (j->baseframe.low) {
  2106. case 0xA0:
  2107. j->play_frame_size = 80;
  2108. break;
  2109. case 0x50:
  2110. j->play_frame_size = 40;
  2111. break;
  2112. default:
  2113. j->play_frame_size = 120;
  2114. break;
  2115. }
  2116. j->play_mode = 4;
  2117. break;
  2118. case WSS:
  2119. switch (j->baseframe.low) {
  2120. case 0xA0:
  2121. j->play_frame_size = 80;
  2122. break;
  2123. case 0x50:
  2124. j->play_frame_size = 40;
  2125. break;
  2126. default:
  2127. j->play_frame_size = 120;
  2128. break;
  2129. }
  2130. j->play_mode = 5;
  2131. break;
  2132. default:
  2133. j->play_frame_size = 0;
  2134. j->play_mode = -1;
  2135. if (j->write_buffer) {
  2136. kfree(j->write_buffer);
  2137. j->write_buffer = NULL;
  2138. j->write_buffer_size = 0;
  2139. }
  2140. retval = 1;
  2141. break;
  2142. }
  2143. return retval;
  2144. }
  2146. static int ixj_play_start(int board)
  2147. {
  2148. unsigned short cmd = 0x0000;
  2149. IXJ *j = &ixj[board];
  2151. j->flags.play_first_frame = 1;
  2152. j->drybuffer = 0;
  2154. if (!j->play_mode) {
  2155. switch (j->play_codec) {
  2156. case G723_63:
  2157. cmd = 0x5231;
  2158. break;
  2159. case G723_53:
  2160. cmd = 0x5232;
  2161. break;
  2162. case TS85:
  2163. cmd = 0x5230; // TrueSpeech 8.5
  2165. break;
  2166. case TS48:
  2167. cmd = 0x5233; // TrueSpeech 4.8
  2169. break;
  2170. case TS41:
  2171. cmd = 0x5234; // TrueSpeech 4.1
  2173. break;
  2174. case G728:
  2175. cmd = 0x5235;
  2176. break;
  2177. case G729:
  2178. cmd = 0x5236;
  2179. break;
  2180. default:
  2181. return 1;
  2182. }
  2183. if (ixj_WriteDSPCommand(cmd, board))
  2184. return -1;
  2185. }
  2186. if (!j->write_buffer) {
  2187. j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_KERNEL);
  2188. if (!j->write_buffer) {
  2189. printk("Write buffer allocation for ixj board %d failed!n", board);
  2190. return -ENOMEM;
  2191. }
  2192. }
  2193. j->write_buffers_empty = 2;
  2194. j->write_buffer_size = j->play_frame_size * 2;
  2195. j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
  2196. j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
  2198. if (ixj_WriteDSPCommand(0x5202, board)) // Set Poll sync mode
  2200. return -1;
  2202. switch (j->play_mode) {
  2203. case 0:
  2204. cmd = 0x2C03;
  2205. break;
  2206. case 2:
  2207. if (j->ver.low == 0x12) {
  2208. cmd = 0x2C23;
  2209. } else {
  2210. cmd = 0x2C21;
  2211. }
  2212. break;
  2213. case 4:
  2214. if (j->ver.low == 0x12) {
  2215. cmd = 0x2C43;
  2216. } else {
  2217. cmd = 0x2C41;
  2218. }
  2219. break;
  2220. case 5:
  2221. if (j->ver.low == 0x12) {
  2222. cmd = 0x2C53;
  2223. } else {
  2224. cmd = 0x2C51;
  2225. }
  2226. break;
  2227. case 6:
  2228. if (j->ver.low == 0x12) {
  2229. cmd = 0x2C63;
  2230. } else {
  2231. cmd = 0x2C61;
  2232. }
  2233. break;
  2234. }
  2235. if (ixj_WriteDSPCommand(cmd, board))
  2236. return -1;
  2238. if (ixj_WriteDSPCommand(0x2000, board)) // Playback C2
  2240. return -1;
  2242. if (ixj_WriteDSPCommand(0x2000 + ixj[board].play_frame_size, board)) // Playback C3
  2244. return -1;
  2246. return 0;
  2247. }
  2249. static void ixj_play_stop(int board)
  2250. {
  2251. IXJ *j = &ixj[board];
  2253. if (j->play_mode > -1) {
  2254. ixj_WriteDSPCommand(0x5221, board); // Stop playback
  2256. j->play_mode = -1;
  2257. }
  2258. }
  2260. extern __inline__ void set_play_depth(int board, int depth)
  2261. {
  2262. if (depth > 60)
  2263. depth = 60;
  2264. if (depth < 0)
  2265. depth = 0;
  2266. ixj_WriteDSPCommand(0x5280 + depth, board);
  2267. }
  2269. extern __inline__ void set_play_volume(int board, int volume)
  2270. {
  2271. ixj_WriteDSPCommand(0xCF02, board);
  2272. ixj_WriteDSPCommand(volume, board);
  2273. }
  2275. extern __inline__ int get_play_level(int board)
  2276. {
  2277. ixj_WriteDSPCommand(0xCF8F, board);
  2278. return ixj[board].ssr.high << 8 | ixj[board].ssr.low;
  2279. }
  2281. static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
  2282. {
  2283. unsigned int mask = 0;
  2284. IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];
  2286. poll_wait(file_p, &(j->poll_q), wait);
  2287. if (j->read_buffer_ready > 0)
  2288. mask |= POLLIN | POLLRDNORM; /* readable */
  2289. if (j->write_buffers_empty > 0)
  2290. mask |= POLLOUT | POLLWRNORM; /* writable */
  2291. if (j->ex.bytes)
  2292. mask |= POLLPRI;
  2293. return mask;
  2294. }
  2296. static int ixj_play_tone(int board, char tone)
  2297. {
  2298. IXJ *j = &ixj[board];
  2300. if (!j->tone_state)
  2301. idle(board);
  2303. j->tone_index = tone;
  2304. if (ixj_WriteDSPCommand(0x6000 + j->tone_index, board))
  2305. return -1;
  2307. if (!j->tone_state) {
  2308. j->tone_start_jif = jiffies;
  2310. j->tone_state = 1;
  2311. }
  2312. return 0;
  2313. }
  2315. static int ixj_set_tone_on(unsigned short arg, int board)
  2316. {
  2317. IXJ *j = &ixj[board];
  2319. j->tone_on_time = arg;
  2321. if (ixj_WriteDSPCommand(0x6E04, board)) // Set Tone On Period
  2323. return -1;
  2325. if (ixj_WriteDSPCommand(arg, board))
  2326. return -1;
  2328. return 0;
  2329. }
  2331. static int SCI_WaitHighSCI(int board)
  2332. {
  2333. int cnt;
  2334. IXJ *j = &ixj[board];
  2336. j->pld_scrr.byte = inb_p(j->XILINXbase);
  2337. if (!j->pld_scrr.bits.sci) {
  2338. for (cnt = 0; cnt < 10; cnt++) {
  2339. udelay(32);
  2340. j->pld_scrr.byte = inb_p(j->XILINXbase);
  2342. if ((j->pld_scrr.bits.sci))
  2343. return 1;
  2344. }
  2345. if (ixjdebug > 1)
  2346. printk(KERN_INFO "SCI Wait High failed %xn", j->pld_scrr.byte);
  2347. return 0;
  2348. } else
  2349. return 1;
  2350. }
  2352. static int SCI_WaitLowSCI(int board)
  2353. {
  2354. int cnt;
  2355. IXJ *j = &ixj[board];
  2357. j->pld_scrr.byte = inb_p(j->XILINXbase);
  2358. if (j->pld_scrr.bits.sci) {
  2359. for (cnt = 0; cnt < 10; cnt++) {
  2360. udelay(32);
  2361. j->pld_scrr.byte = inb_p(j->XILINXbase);
  2363. if (!(j->pld_scrr.bits.sci))
  2364. return 1;
  2365. }
  2366. if (ixjdebug > 1)
  2367. printk(KERN_INFO "SCI Wait Low failed %xn", j->pld_scrr.byte);
  2368. return 0;
  2369. } else
  2370. return 1;
  2371. }
  2373. static int SCI_Control(int board, int control)
  2374. {
  2375. IXJ *j = &ixj[board];
  2377. switch (control) {
  2378. case SCI_End:
  2379. j->pld_scrw.bits.c0 = 0; // Set PLD Serial control interface
  2381. j->pld_scrw.bits.c1 = 0; // to no selection 
  2383. break;
  2384. case SCI_Enable_DAA:
  2385. j->pld_scrw.bits.c0 = 1; // Set PLD Serial control interface
  2387. j->pld_scrw.bits.c1 = 0; // to write to DAA
  2389. break;
  2390. case SCI_Enable_Mixer:
  2391. j->pld_scrw.bits.c0 = 0; // Set PLD Serial control interface
  2393. j->pld_scrw.bits.c1 = 1; // to write to mixer 
  2395. break;
  2396. case SCI_Enable_EEPROM:
  2397. j->pld_scrw.bits.c0 = 1; // Set PLD Serial control interface
  2399. j->pld_scrw.bits.c1 = 1; // to write to EEPROM 
  2401. break;
  2402. default:
  2403. return 0;
  2404. break;
  2405. }
  2406. outb_p(j->pld_scrw.byte, j->XILINXbase);
  2408. switch (control) {
  2409. case SCI_End:
  2410. return 1;
  2411. break;
  2412. case SCI_Enable_DAA:
  2413. case SCI_Enable_Mixer:
  2414. case SCI_Enable_EEPROM:
  2415. if (!SCI_WaitHighSCI(board))
  2416. return 0;
  2417. break;
  2418. default:
  2419. return 0;
  2420. break;
  2421. }
  2422. return 1;
  2423. }
  2425. static int SCI_Prepare(int board)
  2426. {
  2427. if (!SCI_Control(board, SCI_End))
  2428. return 0;
  2430. if (!SCI_WaitLowSCI(board))
  2431. return 0;
  2433. return 1;
  2434. }
  2436. static int ixj_mixer(long val, int board)
  2437. {
  2438. BYTES bytes;
  2439. IXJ *j = &ixj[board];
  2441. bytes.high = (val & 0xFF00) >> 8;
  2442. bytes.low = val & 0x00FF;
  2444. outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); // Load Mixer Address
  2446. outb_p(bytes.low, j->XILINXbase + 0x02); // Load Mixer Data
  2448. SCI_Control(board, SCI_Enable_Mixer);
  2450. SCI_Control(board, SCI_End);
  2452. return 0;
  2453. }
  2455. static int daa_load(BYTES * p_bytes, int board)
  2456. {
  2457. IXJ *j = &ixj[board];
  2459. outb_p(p_bytes->high, j->XILINXbase + 0x03);
  2460. outb_p(p_bytes->low, j->XILINXbase + 0x02);
  2461. if (!SCI_Control(board, SCI_Enable_DAA))
  2462. return 0;
  2463. else
  2464. return 1;
  2465. }
  2467. static int ixj_daa_cr4(int board, char reg)
  2468. {
  2469. IXJ *j = &ixj[board];
  2470. BYTES bytes;
  2472. switch (j->daa_mode) {
  2473. case SOP_PU_SLEEP:
  2474. bytes.high = 0x14;
  2475. break;
  2476. case SOP_PU_RINGING:
  2477. bytes.high = 0x54;
  2478. break;
  2479. case SOP_PU_CONVERSATION:
  2480. bytes.high = 0x94;
  2481. break;
  2482. case SOP_PU_PULSEDIALING:
  2483. bytes.high = 0xD4;
  2484. break;
  2485. }
  2487. switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
  2488. case 0:
  2489. j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
  2490. break;
  2491. case 1:
  2492. j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
  2493. break;
  2494. case 2:
  2495. j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
  2496. break;
  2497. case 3:
  2498. j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
  2499. break;
  2500. }
  2502. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
  2504. if (!daa_load(&bytes, board))
  2505. return 0;
  2507. if (!SCI_Prepare(board))
  2508. return 0;
  2510. return 1;
  2511. }
  2513. static char daa_int_read(int board)
  2514. {
  2515. BYTES bytes;
  2516. IXJ *j = &ixj[board];
  2518. if (!SCI_Prepare(board))
  2519. return 0;
  2521. bytes.high = 0x38;
  2522. bytes.low = 0x00;
  2523. outb_p(bytes.high, j->XILINXbase + 0x03);
  2524. outb_p(bytes.low, j->XILINXbase + 0x02);
  2526. if (!SCI_Control(board, SCI_Enable_DAA))
  2527. return 0;
  2529. bytes.high = inb_p(j->XILINXbase + 0x03);
  2530. bytes.low = inb_p(j->XILINXbase + 0x02);
  2531. if (bytes.low != ALISDAA_ID_BYTE) {
  2532. if (ixjdebug > 0)
  2533. printk("Cannot read DAA ID Byte high = %d low = %dn", bytes.high, bytes.low);
  2534. return 0;
  2535. }
  2536. if (!SCI_Control(board, SCI_Enable_DAA))
  2537. return 0;
  2538. if (!SCI_Control(board, SCI_End))
  2539. return 0;
  2541. bytes.high = inb_p(j->XILINXbase + 0x03);
  2542. bytes.low = inb_p(j->XILINXbase + 0x02);
  2544. j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
  2545. return 1;
  2546. }
  2548. static int ixj_daa_cid_reset(int board)
  2549. {
  2550. int i;
  2551. BYTES bytes;
  2552. IXJ *j = &ixj[board];
  2554. if (!SCI_Prepare(board))
  2555. return 0;
  2557. bytes.high = 0x58;
  2558. bytes.low = 0x00;
  2559. outb_p(bytes.high, j->XILINXbase + 0x03);
  2560. outb_p(bytes.low, j->XILINXbase + 0x02);
  2562. if (!SCI_Control(board, SCI_Enable_DAA))
  2563. return 0;
  2565. if (!SCI_WaitHighSCI(board))
  2566. return 0;
  2568. for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
  2569. bytes.high = bytes.low = 0x00;
  2570. outb_p(bytes.high, j->XILINXbase + 0x03);
  2572. if (i < ALISDAA_CALLERID_SIZE - 1)
  2573. outb_p(bytes.low, j->XILINXbase + 0x02);
  2575. if (!SCI_Control(board, SCI_Enable_DAA))
  2576. return 0;
  2578. if (!SCI_WaitHighSCI(board))
  2579. return 0;
  2581. }
  2583. if (!SCI_Control(board, SCI_End))
  2584. return 0;
  2586. return 1;
  2587. }
  2589. static int ixj_daa_cid_read(int board)
  2590. {
  2591. int i;
  2592. BYTES bytes;
  2593. char CID[ALISDAA_CALLERID_SIZE], mContinue;
  2594. char *pIn, *pOut;
  2595. IXJ *j = &ixj[board];
  2597. if (!SCI_Prepare(board))
  2598. return 0;
  2600. bytes.high = 0x78;
  2601. bytes.low = 0x00;
  2602. outb_p(bytes.high, j->XILINXbase + 0x03);
  2603. outb_p(bytes.low, j->XILINXbase + 0x02);
  2605. if (!SCI_Control(board, SCI_Enable_DAA))
  2606. return 0;
  2608. if (!SCI_WaitHighSCI(board))
  2609. return 0;
  2611. bytes.high = inb_p(j->XILINXbase + 0x03);
  2612. bytes.low = inb_p(j->XILINXbase + 0x02);
  2613. if (bytes.low != ALISDAA_ID_BYTE) {
  2614. if (ixjdebug > 0)
  2615. printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %dn", bytes.high, bytes.low);
  2616. return 0;
  2617. }
  2618. for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
  2619. bytes.high = bytes.low = 0x00;
  2620. outb_p(bytes.high, j->XILINXbase + 0x03);
  2621. outb_p(bytes.low, j->XILINXbase + 0x02);
  2623. if (!SCI_Control(board, SCI_Enable_DAA))
  2624. return 0;
  2626. if (!SCI_WaitHighSCI(board))
  2627. return 0;
  2629. CID[i + 0] = inb_p(j->XILINXbase + 0x03);
  2630. CID[i + 1] = inb_p(j->XILINXbase + 0x02);
  2631. }
  2633. if (!SCI_Control(board, SCI_End))
  2634. return 0;
  2636. pIn = CID;
  2637. pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
  2638. mContinue = 1;
  2639. while (mContinue) {
  2640. if ((pIn[1] & 0x03) == 0x01) {
  2641. pOut[0] = pIn[0];
  2642. }
  2643. if ((pIn[2] & 0x0c) == 0x04) {
  2644. pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
  2645. }
  2646. if ((pIn[3] & 0x30) == 0x10) {
  2647. pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
  2648. }
  2649. if ((pIn[4] & 0xc0) == 0x40) {
  2650. pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
  2651. } else {
  2652. mContinue = FALSE;
  2653. }
  2654. pIn += 5, pOut += 4;
  2655. }
  2656. memset(&j->cid, 0, sizeof(IXJ_CID));
  2657. pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
  2658. pOut += 4;
  2659. strncpy(j->cid.month, pOut, 2);
  2660. pOut += 2;
  2661. strncpy(j->cid.day, pOut, 2);
  2662. pOut += 2;
  2663. strncpy(j->cid.hour, pOut, 2);
  2664. pOut += 2;
  2665. strncpy(j->cid.min, pOut, 2);
  2666. pOut += 3;
  2667. j->cid.numlen = *pOut;
  2668. pOut += 1;
  2669. strncpy(j->cid.number, pOut, j->cid.numlen);
  2670. pOut += j->cid.numlen + 1;
  2671. j->cid.namelen = *pOut;
  2672. pOut += 1;
  2673. strncpy(j->cid.name, pOut, j->cid.namelen);
  2675. ixj_daa_cid_reset(board);
  2676. return 1;
  2677. }
  2679. static char daa_get_version(int board)
  2680. {
  2681. BYTES bytes;
  2682. IXJ *j = &ixj[board];
  2684. if (!SCI_Prepare(board))
  2685. return 0;
  2687. bytes.high = 0x35;
  2688. bytes.low = 0x00;
  2689. outb_p(bytes.high, j->XILINXbase + 0x03);
  2690. outb_p(bytes.low, j->XILINXbase + 0x02);
  2692. if (!SCI_Control(board, SCI_Enable_DAA))
  2693. return 0;
  2695. bytes.high = inb_p(j->XILINXbase + 0x03);
  2696. bytes.low = inb_p(j->XILINXbase + 0x02);
  2697. if (bytes.low != ALISDAA_ID_BYTE) {
  2698. if (ixjdebug > 0)
  2699. printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %dn", bytes.high, bytes.low);
  2700. return 0;
  2701. }
  2702. if (!SCI_Control(board, SCI_Enable_DAA))
  2703. return 0;
  2705. if (!SCI_Control(board, SCI_End))
  2706. return 0;
  2708. bytes.high = inb_p(j->XILINXbase + 0x03);
  2709. bytes.low = inb_p(j->XILINXbase + 0x02);
  2710. if (ixjdebug > 0)
  2711. printk("DAA CR5 Byte high = 0x%x low = 0x%xn", bytes.high, bytes.low);
  2712. j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
  2713. return bytes.high;
  2714. }
  2716. static int daa_set_mode(int board, int mode)
  2717. {
  2718. // NOTE:
  2719. //      The DAA *MUST* be in the conversation mode if the
  2720. //      PSTN line is to be seized (PSTN line off-hook).
  2721. //      Taking the PSTN line off-hook while the DAA is in
  2722. //      a mode other than conversation mode will cause a
  2723. //      hardware failure of the ALIS-A part.
  2725. // NOTE:
  2726. //      The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
  2727. //      if the PSTN line is on-hook.  Failure to have the PSTN line
  2728. //      in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
  2729. //      ALIS-A part.
  2730. //
  2733. BYTES bytes;
  2734. IXJ *j = &ixj[board];
  2736. if (!SCI_Prepare(board))
  2737. return 0;
  2739. switch (mode) {
  2740. case SOP_PU_SLEEP:
  2741. j->pld_scrw.bits.daafsyncen = 0; // Turn off DAA Frame Sync
  2743. outb_p(j->pld_scrw.byte, j->XILINXbase);
  2744. j->pld_slicw.bits.rly2 = 0;
  2745. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  2746. bytes.high = 0x10;
  2747. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  2748. daa_load(&bytes, board);
  2749. if (!SCI_Prepare(board))
  2750. return 0;
  2751. j->daa_mode = SOP_PU_SLEEP;
  2752. j->flags.pstn_ringing = 0;
  2753. j->pstn_sleeptil = jiffies + (hertz * 3);
  2754. break;
  2755. case SOP_PU_RINGING:
  2756. j->pld_scrw.bits.daafsyncen = 0; // Turn off DAA Frame Sync
  2758. outb_p(j->pld_scrw.byte, j->XILINXbase);
  2759. j->pld_slicw.bits.rly2 = 0;
  2760. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  2761. bytes.high = 0x50;
  2762. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  2763. daa_load(&bytes, board);
  2764. if (!SCI_Prepare(board))
  2765. return 0;
  2766. j->daa_mode = SOP_PU_RINGING;
  2767. break;
  2768. case SOP_PU_CONVERSATION:
  2769. bytes.high = 0x90;
  2770. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  2771. daa_load(&bytes, board);
  2772. if (!SCI_Prepare(board))
  2773. return 0;
  2774. j->pld_slicw.bits.rly2 = 1;
  2775. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  2776. j->pld_scrw.bits.daafsyncen = 1; // Turn on DAA Frame Sync
  2778. outb_p(j->pld_scrw.byte, j->XILINXbase);
  2779. j->daa_mode = SOP_PU_CONVERSATION;
  2780. j->flags.pstn_ringing = 0;
  2781. j->ex.bits.pstn_ring = 0;
  2782. break;
  2783. case SOP_PU_PULSEDIALING:
  2784. j->pld_scrw.bits.daafsyncen = 0; // Turn off DAA Frame Sync
  2786. outb_p(j->pld_scrw.byte, j->XILINXbase);
  2787. j->pld_slicw.bits.rly2 = 0;
  2788. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  2789. bytes.high = 0xD0;
  2790. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  2791. daa_load(&bytes, board);
  2792. if (!SCI_Prepare(board))
  2793. return 0;
  2794. j->daa_mode = SOP_PU_PULSEDIALING;
  2795. break;
  2796. default:
  2797. break;
  2798. }
  2799. return 1;
  2800. }
  2802. static int ixj_daa_write(int board)
  2803. {
  2804. BYTES bytes;
  2805. IXJ *j = &ixj[board];
  2807. if (!SCI_Prepare(board))
  2808. return 0;
  2810. bytes.high = 0x14;
  2811. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
  2812. if (!daa_load(&bytes, board))
  2813. return 0;
  2815. bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
  2816. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
  2817. if (!daa_load(&bytes, board))
  2818. return 0;
  2820. bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
  2821. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  2822. if (!daa_load(&bytes, board))
  2823. return 0;
  2825. if (!SCI_Prepare(board))
  2826. return 0;
  2828. bytes.high = 0x1F;
  2829. bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
  2830. if (!daa_load(&bytes, board))
  2831. return 0;
  2833. bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
  2834. bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
  2835. if (!daa_load(&bytes, board))
  2836. return 0;
  2838. bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
  2839. bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
  2840. if (!daa_load(&bytes, board))
  2841. return 0;
  2843. bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
  2844. bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
  2845. if (!daa_load(&bytes, board))
  2846. return 0;
  2848. bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
  2849. bytes.low = 0x00;
  2850. if (!daa_load(&bytes, board))
  2851. return 0;
  2853. if (!SCI_Prepare(board))
  2854. return 0;
  2856. bytes.high = 0x00;
  2857. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
  2858. if (!daa_load(&bytes, board))
  2859. return 0;
  2861. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
  2862. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
  2863. if (!daa_load(&bytes, board))
  2864. return 0;
  2866. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
  2867. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
  2868. if (!daa_load(&bytes, board))
  2869. return 0;
  2871. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
  2872. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
  2873. if (!daa_load(&bytes, board))
  2874. return 0;
  2876. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
  2877. bytes.low = 0x00;
  2878. if (!daa_load(&bytes, board))
  2879. return 0;
  2881. if (!SCI_Control(board, SCI_End))
  2882. return 0;
  2883. if (!SCI_WaitLowSCI(board))
  2884. return 0;
  2886. bytes.high = 0x01;
  2887. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
  2888. if (!daa_load(&bytes, board))
  2889. return 0;
  2891. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
  2892. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
  2893. if (!daa_load(&bytes, board))
  2894. return 0;
  2896. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
  2897. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
  2898. if (!daa_load(&bytes, board))
  2899. return 0;
  2901. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
  2902. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
  2903. if (!daa_load(&bytes, board))
  2904. return 0;
  2906. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
  2907. bytes.low = 0x00;
  2908. if (!daa_load(&bytes, board))
  2909. return 0;
  2911. if (!SCI_Control(board, SCI_End))
  2912. return 0;
  2913. if (!SCI_WaitLowSCI(board))
  2914. return 0;
  2916. bytes.high = 0x02;
  2917. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
  2918. if (!daa_load(&bytes, board))
  2919. return 0;
  2921. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
  2922. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
  2923. if (!daa_load(&bytes, board))
  2924. return 0;
  2926. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
  2927. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
  2928. if (!daa_load(&bytes, board))
  2929. return 0;
  2931. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
  2932. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
  2933. if (!daa_load(&bytes, board))
  2934. return 0;
  2936. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
  2937. bytes.low = 0x00;
  2938. if (!daa_load(&bytes, board))
  2939. return 0;
  2941. if (!SCI_Control(board, SCI_End))
  2942. return 0;
  2943. if (!SCI_WaitLowSCI(board))
  2944. return 0;
  2946. bytes.high = 0x03;
  2947. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
  2948. if (!daa_load(&bytes, board))
  2949. return 0;
  2951. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
  2952. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
  2953. if (!daa_load(&bytes, board))
  2954. return 0;
  2956. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
  2957. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
  2958. if (!daa_load(&bytes, board))
  2959. return 0;
  2961. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
  2962. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
  2963. if (!daa_load(&bytes, board))
  2964. return 0;
  2966. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
  2967. bytes.low = 0x00;
  2968. if (!daa_load(&bytes, board))
  2969. return 0;
  2971. if (!SCI_Control(board, SCI_End))
  2972. return 0;
  2973. if (!SCI_WaitLowSCI(board))
  2974. return 0;
  2976. bytes.high = 0x04;
  2977. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
  2978. if (!daa_load(&bytes, board))
  2979. return 0;
  2981. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
  2982. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
  2983. if (!daa_load(&bytes, board))
  2984. return 0;
  2986. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
  2987. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
  2988. if (!daa_load(&bytes, board))
  2989. return 0;
  2991. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
  2992. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
  2993. if (!daa_load(&bytes, board))
  2994. return 0;
  2996. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
  2997. bytes.low = 0x00;
  2998. if (!daa_load(&bytes, board))
  2999. return 0;
  3001. if (!SCI_Control(board, SCI_End))
  3002. return 0;
  3003. if (!SCI_WaitLowSCI(board))
  3004. return 0;
  3006. bytes.high = 0x05;
  3007. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
  3008. if (!daa_load(&bytes, board))
  3009. return 0;
  3011. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
  3012. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
  3013. if (!daa_load(&bytes, board))
  3014. return 0;
  3016. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
  3017. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
  3018. if (!daa_load(&bytes, board))
  3019. return 0;
  3021. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
  3022. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
  3023. if (!daa_load(&bytes, board))
  3024. return 0;
  3026. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
  3027. bytes.low = 0x00;
  3028. if (!daa_load(&bytes, board))
  3029. return 0;
  3031. if (!SCI_Control(board, SCI_End))
  3032. return 0;
  3033. if (!SCI_WaitLowSCI(board))
  3034. return 0;
  3036. bytes.high = 0x06;
  3037. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
  3038. if (!daa_load(&bytes, board))
  3039. return 0;
  3041. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
  3042. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
  3043. if (!daa_load(&bytes, board))
  3044. return 0;
  3046. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
  3047. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
  3048. if (!daa_load(&bytes, board))
  3049. return 0;
  3051. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
  3052. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
  3053. if (!daa_load(&bytes, board))
  3054. return 0;
  3056. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
  3057. bytes.low = 0x00;
  3058. if (!daa_load(&bytes, board))
  3059. return 0;
  3061. if (!SCI_Control(board, SCI_End))
  3062. return 0;
  3063. if (!SCI_WaitLowSCI(board))
  3064. return 0;
  3066. bytes.high = 0x07;
  3067. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
  3068. if (!daa_load(&bytes, board))
  3069. return 0;
  3071. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
  3072. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
  3073. if (!daa_load(&bytes, board))
  3074. return 0;
  3076. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
  3077. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
  3078. if (!daa_load(&bytes, board))
  3079. return 0;
  3081. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
  3082. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
  3083. if (!daa_load(&bytes, board))
  3084. return 0;
  3086. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
  3087. bytes.low = 0x00;
  3088. if (!daa_load(&bytes, board))
  3089. return 0;
  3091. if (!SCI_Control(board, SCI_End))
  3092. return 0;
  3093. if (!SCI_WaitLowSCI(board))
  3094. return 0;
  3096. bytes.high = 0x08;
  3097. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
  3098. if (!daa_load(&bytes, board))
  3099. return 0;
  3101. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
  3102. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
  3103. if (!daa_load(&bytes, board))
  3104. return 0;
  3106. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
  3107. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
  3108. if (!daa_load(&bytes, board))
  3109. return 0;
  3111. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
  3112. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
  3113. if (!daa_load(&bytes, board))
  3114. return 0;
  3116. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
  3117. bytes.low = 0x00;
  3118. if (!daa_load(&bytes, board))
  3119. return 0;
  3121. if (!SCI_Control(board, SCI_End))
  3122. return 0;
  3123. if (!SCI_WaitLowSCI(board))
  3124. return 0;
  3126. bytes.high = 0x09;
  3127. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
  3128. if (!daa_load(&bytes, board))
  3129. return 0;
  3131. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
  3132. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
  3133. if (!daa_load(&bytes, board))
  3134. return 0;
  3136. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
  3137. bytes.low = 0x00;
  3138. if (!daa_load(&bytes, board))
  3139. return 0;
  3141. if (!SCI_Control(board, SCI_End))
  3142. return 0;
  3143. if (!SCI_WaitLowSCI(board))
  3144. return 0;
  3146. bytes.high = 0x0A;
  3147. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
  3148. if (!daa_load(&bytes, board))
  3149. return 0;
  3151. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
  3152. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
  3153. if (!daa_load(&bytes, board))
  3154. return 0;
  3156. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
  3157. bytes.low = 0x00;
  3158. if (!daa_load(&bytes, board))
  3159. return 0;
  3161. if (!SCI_Control(board, SCI_End))
  3162. return 0;
  3163. if (!SCI_WaitLowSCI(board))
  3164. return 0;
  3166. bytes.high = 0x0B;
  3167. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
  3168. if (!daa_load(&bytes, board))
  3169. return 0;
  3171. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
  3172. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
  3173. if (!daa_load(&bytes, board))
  3174. return 0;
  3176. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
  3177. bytes.low = 0x00;
  3178. if (!daa_load(&bytes, board))
  3179. return 0;
  3181. if (!SCI_Control(board, SCI_End))
  3182. return 0;
  3183. if (!SCI_WaitLowSCI(board))
  3184. return 0;
  3186. bytes.high = 0x0C;
  3187. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
  3188. if (!daa_load(&bytes, board))
  3189. return 0;
  3191. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
  3192. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
  3193. if (!daa_load(&bytes, board))
  3194. return 0;
  3196. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
  3197. bytes.low = 0x00;
  3198. if (!daa_load(&bytes, board))
  3199. return 0;
  3201. if (!SCI_Control(board, SCI_End))
  3202. return 0;
  3203. if (!SCI_WaitLowSCI(board))
  3204. return 0;
  3206. bytes.high = 0x0D;
  3207. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
  3208. if (!daa_load(&bytes, board))
  3209. return 0;
  3211. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
  3212. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
  3213. if (!daa_load(&bytes, board))
  3214. return 0;
  3216. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
  3217. bytes.low = 0x00;
  3218. if (!daa_load(&bytes, board))
  3219. return 0;
  3221. if (!SCI_Control(board, SCI_End))
  3222. return 0;
  3223. if (!SCI_WaitLowSCI(board))
  3224. return 0;
  3226. bytes.high = 0x0E;
  3227. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
  3228. if (!daa_load(&bytes, board))
  3229. return 0;
  3231. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
  3232. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
  3233. if (!daa_load(&bytes, board))
  3234. return 0;
  3236. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
  3237. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
  3238. if (!daa_load(&bytes, board))
  3239. return 0;
  3241. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
  3242. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
  3243. if (!daa_load(&bytes, board))
  3244. return 0;
  3246. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
  3247. bytes.low = 0x00;
  3248. if (!daa_load(&bytes, board))
  3249. return 0;
  3251. if (!SCI_Control(board, SCI_End))
  3252. return 0;
  3253. if (!SCI_WaitLowSCI(board))
  3254. return 0;
  3256. bytes.high = 0x0F;
  3257. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
  3258. if (!daa_load(&bytes, board))
  3259. return 0;
  3261. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
  3262. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
  3263. if (!daa_load(&bytes, board))
  3264. return 0;
  3266. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
  3267. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
  3268. if (!daa_load(&bytes, board))
  3269. return 0;
  3271. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
  3272. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
  3273. if (!daa_load(&bytes, board))
  3274. return 0;
  3276. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
  3277. bytes.low = 0x00;
  3278. if (!daa_load(&bytes, board))
  3279. return 0;
  3281. udelay(32);
  3282. j->pld_scrr.byte = inb_p(j->XILINXbase);
  3283. if (!SCI_Control(board, SCI_End))
  3284. return 0;
  3286. return 1;
  3287. }
  3289. int ixj_set_tone_off(unsigned short arg, int board)
  3290. {
  3291. ixj[board].tone_off_time = arg;
  3293. if (ixj_WriteDSPCommand(0x6E05, board)) // Set Tone Off Period
  3295. return -1;
  3297. if (ixj_WriteDSPCommand(arg, board))
  3298. return -1;
  3300. return 0;
  3301. }
  3303. static int ixj_get_tone_on(int board)
  3304. {
  3305. if (ixj_WriteDSPCommand(0x6E06, board)) // Get Tone On Period
  3307. return -1;
  3309. return 0;
  3310. }
  3312. static int ixj_get_tone_off(int board)
  3313. {
  3314. if (ixj_WriteDSPCommand(0x6E07, board)) // Get Tone Off Period
  3316. return -1;
  3318. return 0;
  3319. }
  3321. static void ixj_busytone(int board)
  3322. {
  3323. ixj[board].flags.ringback = 0;
  3324. ixj[board].flags.dialtone = 0;
  3325. ixj[board].flags.busytone = 1;
  3327. ixj_set_tone_on(0x07D0, board);
  3328. ixj_set_tone_off(0x07D0, board);
  3329. ixj_play_tone(board, 27);
  3330. }
  3332. static void ixj_dialtone(int board)
  3333. {
  3334. ixj[board].flags.ringback = 0;
  3335. ixj[board].flags.dialtone = 1;
  3336. ixj[board].flags.busytone = 0;
  3338. if (ixj[board].dsp.low == 0x20) {
  3339. return;
  3340. } else {
  3341. ixj_set_tone_on(0xFFFF, board);
  3342. ixj_set_tone_off(0x0000, board);
  3344. ixj_play_tone(board, 25);
  3345. }
  3346. }
  3348. static void ixj_cpt_stop(board)
  3349. {
  3350. IXJ *j = &ixj[board];
  3352. j->flags.dialtone = 0;
  3353. j->flags.busytone = 0;
  3354. j->flags.ringback = 0;
  3356. ixj_set_tone_on(0x0001, board);
  3357. ixj_set_tone_off(0x0000, board);
  3359. ixj_play_tone(board, 0);
  3361. j->tone_state = 0;
  3363. if (j->cadence_t) {
  3364. if (j->cadence_t->ce) {
  3365. kfree(j->cadence_t->ce);
  3366. }
  3367. kfree(j->cadence_t);
  3368. j->cadence_t = NULL;
  3369. }
  3370. if (j->dsp.low == 0x20 || (j->play_mode == -1 && j->rec_mode == -1))
  3371. idle(board);
  3372. if (j->play_mode != -1)
  3373. ixj_play_start(board);
  3374. if (j->rec_mode != -1)
  3375. ixj_record_start(board);
  3376. }
  3378. static void ixj_ringback(int board)
  3379. {
  3380. ixj[board].flags.busytone = 0;
  3381. ixj[board].flags.dialtone = 0;
  3382. ixj[board].flags.ringback = 1;
  3384. ixj_set_tone_on(0x0FA0, board);
  3385. ixj_set_tone_off(0x2EE0, board);
  3386. ixj_play_tone(board, 26);
  3387. }
  3389. static void ixj_testram(int board)
  3390. {
  3391. ixj_WriteDSPCommand(0x3001, board); /* Test External SRAM */
  3392. }
  3394. static int ixj_build_cadence(int board, IXJ_CADENCE * cp)
  3395. {
  3396. IXJ_CADENCE *lcp;
  3397. IXJ_CADENCE_ELEMENT *lcep;
  3398. IXJ_TONE ti;
  3399. IXJ *j = &ixj[board];
  3401. lcp = kmalloc(sizeof(IXJ_CADENCE), GFP_KERNEL);
  3402. if (lcp == NULL)
  3403. return -ENOMEM;
  3405. if (copy_from_user(lcp, (char *) cp, sizeof(IXJ_CADENCE)))
  3406. return -EFAULT;
  3408. lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
  3409. if (lcep == NULL) {
  3410. kfree(lcp);
  3411. return -ENOMEM;
  3412. }
  3413. if (copy_from_user(lcep, lcp->ce, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
  3414. return -EFAULT;
  3416. lcp->ce = (void *) lcep;
  3417. j->cadence_t = lcp;
  3418. j->tone_cadence_state = 0;
  3419. ixj_set_tone_on(lcp->ce[0].tone_on_time, board);
  3420. ixj_set_tone_off(lcp->ce[0].tone_off_time, board);
  3421. if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
  3422. ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
  3423. ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
  3424. ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
  3425. ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
  3426. ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
  3427. ixj_init_tone(board, &ti);
  3428. }
  3429. ixj_play_tone(board, lcp->ce[0].index);
  3431. return 1;
  3432. }
  3434. static void add_caps(int board)
  3435. {
  3436. IXJ *j = &ixj[board];
  3437. j->caps = 0;
  3439. j->caplist[j->caps].cap = vendor;
  3440. strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
  3441. j->caplist[j->caps].captype = vendor;
  3442. j->caplist[j->caps].handle = j->caps++;
  3443. j->caplist[j->caps].captype = device;
  3444. switch (j->cardtype) {
  3445. case 100:
  3446. strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
  3447. j->caplist[j->caps].cap = 100;
  3448. break;
  3449. case 300:
  3450. strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
  3451. j->caplist[j->caps].cap = 300;
  3452. break;
  3453. case 400:
  3454. strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
  3455. j->caplist[j->caps].cap = 400;
  3456. break;
  3457. case 500:
  3458. strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
  3459. j->caplist[j->caps].cap = 500;
  3460. break;
  3461. }
  3462. j->caplist[j->caps].handle = j->caps++;
  3463. strcpy(j->caplist[j->caps].desc, "POTS");
  3464. j->caplist[j->caps].captype = port;
  3465. j->caplist[j->caps].cap = pots;
  3466. j->caplist[j->caps].handle = j->caps++;
  3467. switch (ixj[board].cardtype) {
  3468. case 100:
  3469. strcpy(j->caplist[j->caps].desc, "SPEAKER");
  3470. j->caplist[j->caps].captype = port;
  3471. j->caplist[j->caps].cap = speaker;
  3472. j->caplist[j->caps].handle = j->caps++;
  3473. strcpy(j->caplist[j->caps].desc, "HANDSET");
  3474. j->caplist[j->caps].captype = port;
  3475. j->caplist[j->caps].cap = handset;
  3476. j->caplist[j->caps].handle = j->caps++;
  3477. break;
  3478. case 300:
  3479. strcpy(j->caplist[j->caps].desc, "SPEAKER");
  3480. j->caplist[j->caps].captype = port;
  3481. j->caplist[j->caps].cap = speaker;
  3482. j->caplist[j->caps].handle = j->caps++;
  3483. strcpy(j->caplist[j->caps].desc, "PSTN");
  3484. j->caplist[j->caps].captype = port;
  3485. j->caplist[j->caps].cap = pstn;
  3486. j->caplist[j->caps].handle = j->caps++;
  3487. break;
  3488. }
  3489. strcpy(j->caplist[j->caps].desc, "ULAW");
  3490. j->caplist[j->caps].captype = codec;
  3491. j->caplist[j->caps].cap = ULAW;
  3492. j->caplist[j->caps].handle = j->caps++;
  3493. strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
  3494. j->caplist[j->caps].captype = codec;
  3495. j->caplist[j->caps].cap = LINEAR16;
  3496. j->caplist[j->caps].handle = j->caps++;
  3497. strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
  3498. j->caplist[j->caps].captype = codec;
  3499. j->caplist[j->caps].cap = LINEAR8;
  3500. j->caplist[j->caps].handle = j->caps++;
  3501. strcpy(j->caplist[j->caps].desc, "Windows Sound System");
  3502. j->caplist[j->caps].captype = codec;
  3503. j->caplist[j->caps].cap = WSS;
  3504. j->caplist[j->caps].handle = j->caps++;
  3505. if (j->ver.low != 0x12) {
  3506. strcpy(j->caplist[j->caps].desc, "G.723.1 6.3Kbps");
  3507. j->caplist[j->caps].captype = codec;
  3508. j->caplist[j->caps].cap = G723_63;
  3509. j->caplist[j->caps].handle = j->caps++;
  3510. strcpy(j->caplist[j->caps].desc, "G.723.1 5.3Kbps");
  3511. j->caplist[j->caps].captype = codec;
  3512. j->caplist[j->caps].cap = G723_53;
  3513. j->caplist[j->caps].handle = j->caps++;
  3514. strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8Kbps");
  3515. j->caplist[j->caps].captype = codec;
  3516. j->caplist[j->caps].cap = TS48;
  3517. j->caplist[j->caps].handle = j->caps++;
  3518. strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1Kbps");
  3519. j->caplist[j->caps].captype = codec;
  3520. j->caplist[j->caps].cap = TS41;
  3521. j->caplist[j->caps].handle = j->caps++;
  3522. }
  3523. if (j->cardtype == 100) {
  3524. strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5Kbps");
  3525. j->caplist[j->caps].captype = codec;
  3526. j->caplist[j->caps].cap = TS85;
  3527. j->caplist[j->caps].handle = j->caps++;
  3528. }
  3529. }
  3530. static int capabilities_check(int board, struct phone_capability *pcreq)
  3531. {
  3532. int cnt;
  3533. IXJ *j = &ixj[board];
  3534. int retval = 0;
  3536. for (cnt = 0; cnt < j->caps; cnt++) {
  3537. if (pcreq->captype == j->caplist[cnt].captype &&
  3538.     pcreq->cap == j->caplist[cnt].cap) {
  3539. retval = 1;
  3540. break;
  3541. }
  3542. }
  3543. return retval;
  3544. }
  3546. int ixj_ioctl(struct inode *inode, struct file *file_p,
  3547.       unsigned int cmd, unsigned long arg)
  3548. {
  3549. IXJ_TONE ti;
  3550. IXJ_FILTER jf;
  3551. unsigned int minor = MINOR(inode->i_rdev);
  3552. int board = NUM(inode->i_rdev);
  3553. IXJ *j = &ixj[NUM(inode->i_rdev)];
  3554. int retval = 0;
  3556. if (ixjdebug > 1)
  3557. printk(KERN_DEBUG "ixj%d ioctl, cmd: 0x%x, arg: 0x%lxn", minor, cmd, arg);
  3558. if (minor >= IXJMAX)
  3559. return -ENODEV;
  3561. /*
  3562.  *    Check ioctls only root can use.
  3563.  */
  3565. if (!capable(CAP_SYS_ADMIN)) {
  3566. switch (cmd) {
  3567. case IXJCTL_TESTRAM:
  3568. case IXJCTL_HZ:
  3569. return -EPERM;
  3570. }
  3571. }
  3572. switch (cmd) {
  3573. case IXJCTL_TESTRAM:
  3574. ixj_testram(board);
  3575. retval = (j->ssr.high << 8) + j->ssr.low;
  3576. break;
  3577. case IXJCTL_CARDTYPE:
  3578. retval = j->cardtype;
  3579. break;
  3580. case IXJCTL_SERIAL:
  3581. retval = j->serial;
  3582. break;
  3583. case PHONE_RING_CADENCE:
  3584. j->ring_cadence = arg;
  3585. break;
  3586. case PHONE_RING_START:
  3587. ixj_ring_start(board);
  3588. break;
  3589. case PHONE_RING_STOP:
  3590. j->flags.cringing = 0;
  3591. ixj_ring_off(board);
  3592. break;
  3593. case PHONE_RING:
  3594. retval = ixj_ring(board);
  3595. break;
  3596. case PHONE_EXCEPTION:
  3597. retval = j->ex.bytes;
  3598. j->ex.bytes &= 0x03;
  3599. break;
  3600. case PHONE_HOOKSTATE:
  3601. j->ex.bits.hookstate = 0;
  3602. retval = j->r_hook;
  3603. break;
  3604. case IXJCTL_SET_LED:
  3605. LED_SetState(arg, board);
  3606. break;
  3607. case PHONE_FRAME:
  3608. retval = set_base_frame(board, arg);
  3609. break;
  3610. case PHONE_REC_CODEC:
  3611. retval = set_rec_codec(board, arg);
  3612. break;
  3613. case PHONE_REC_START:
  3614. ixj_record_start(board);
  3615. break;
  3616. case PHONE_REC_STOP:
  3617. ixj_record_stop(board);
  3618. break;
  3619. case PHONE_REC_DEPTH:
  3620. set_rec_depth(board, arg);
  3621. break;
  3622. case PHONE_REC_VOLUME:
  3623. set_rec_volume(board, arg);
  3624. break;
  3625. case PHONE_REC_LEVEL:
  3626. retval = get_rec_level(board);
  3627. break;
  3628. case IXJCTL_AEC_START:
  3629. ixj_aec_start(board, arg);
  3630. break;
  3631. case IXJCTL_AEC_STOP:
  3632. aec_stop(board);
  3633. break;
  3634. case IXJCTL_AEC_GET_LEVEL:
  3635. retval = j->aec_level;
  3636. break;
  3637. case PHONE_PLAY_CODEC:
  3638. retval = set_play_codec(board, arg);
  3639. break;
  3640. case PHONE_PLAY_START:
  3641. ixj_play_start(board);
  3642. break;
  3643. case PHONE_PLAY_STOP:
  3644. ixj_play_stop(board);
  3645. break;
  3646. case PHONE_PLAY_DEPTH:
  3647. set_play_depth(board, arg);
  3648. break;
  3649. case PHONE_PLAY_VOLUME:
  3650. set_play_volume(board, arg);
  3651. break;
  3652. case PHONE_PLAY_LEVEL:
  3653. retval = get_play_level(board);
  3654. break;
  3655. case IXJCTL_DSP_TYPE:
  3656. retval = (j->dsp.high << 8) + j->dsp.low;
  3657. break;
  3658. case IXJCTL_DSP_VERSION:
  3659. retval = (j->ver.high << 8) + j->ver.low;
  3660. break;
  3661. case IXJCTL_HZ:
  3662. hertz = arg;
  3663. break;
  3664. case IXJCTL_RATE:
  3665. if (arg > hertz)
  3666. retval = -1;
  3667. else
  3668. samplerate = arg;
  3669. break;
  3670. case IXJCTL_DRYBUFFER_READ:
  3671. put_user(j->drybuffer, (unsigned long *) arg);
  3672. break;
  3673. case IXJCTL_DRYBUFFER_CLEAR:
  3674. j->drybuffer = 0;
  3675. break;
  3676. case IXJCTL_FRAMES_READ:
  3677. put_user(j->framesread, (unsigned long *) arg);
  3678. break;
  3679. case IXJCTL_FRAMES_WRITTEN:
  3680. put_user(j->frameswritten, (unsigned long *) arg);
  3681. break;
  3682. case IXJCTL_READ_WAIT:
  3683. put_user(j->read_wait, (unsigned long *) arg);
  3684. break;
  3685. case IXJCTL_WRITE_WAIT:
  3686. put_user(j->write_wait, (unsigned long *) arg);
  3687. break;
  3688. case PHONE_MAXRINGS:
  3689. j->maxrings = arg;
  3690. break;
  3691. case PHONE_SET_TONE_ON_TIME:
  3692. ixj_set_tone_on(arg, board);
  3693. break;
  3694. case PHONE_SET_TONE_OFF_TIME:
  3695. ixj_set_tone_off(arg, board);
  3696. break;
  3697. case PHONE_GET_TONE_ON_TIME:
  3698. if (ixj_get_tone_on(board)) {
  3699. retval = -1;
  3700. } else {
  3701. retval = (j->ssr.high << 8) + j->ssr.low;
  3702. }
  3703. break;
  3704. case PHONE_GET_TONE_OFF_TIME:
  3705. if (ixj_get_tone_off(board)) {
  3706. retval = -1;
  3707. } else {
  3708. retval = (j->ssr.high << 8) + j->ssr.low;
  3709. }
  3710. break;
  3711. case PHONE_PLAY_TONE:
  3712. if (!j->tone_state)
  3713. ixj_play_tone(board, arg);
  3714. break;
  3715. case PHONE_GET_TONE_STATE:
  3716. retval = j->tone_state;
  3717. break;
  3718. case PHONE_DTMF_READY:
  3719. retval = j->ex.bits.dtmf_ready;
  3720. break;
  3721. case PHONE_GET_DTMF:
  3722. if (ixj_hookstate(board)) {
  3723. if (j->dtmf_rp != j->dtmf_wp) {
  3724. retval = j->dtmfbuffer[j->dtmf_rp];
  3725. j->dtmf_rp++;
  3726. if (j->dtmf_rp == 79)
  3727. j->dtmf_rp = 0;
  3728. if (j->dtmf_rp == j->dtmf_wp) {
  3729. j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
  3730. }
  3731. }
  3732. }
  3733. break;
  3734. case PHONE_GET_DTMF_ASCII:
  3735. if (ixj_hookstate(board)) {
  3736. if (j->dtmf_rp != j->dtmf_wp) {
  3737. switch (j->dtmfbuffer[j->dtmf_rp]) {
  3738. case 10:
  3739. retval = 42; //'*';
  3741. break;
  3742. case 11:
  3743. retval = 48; //'0';
  3745. break;
  3746. case 12:
  3747. retval = 35; //'#';
  3749. break;
  3750. case 28:
  3751. retval = 65; //'A';
  3753. break;
  3754. case 29:
  3755. retval = 66; //'B';
  3757. break;
  3758. case 30:
  3759. retval = 67; //'C';
  3761. break;
  3762. case 31:
  3763. retval = 68; //'D';
  3765. break;
  3766. default:
  3767. retval = 48 + j->dtmfbuffer[j->dtmf_rp];
  3768. break;
  3769. }
  3770. j->dtmf_rp++;
  3771. if (j->dtmf_rp == 79)
  3772. j->dtmf_rp = 0;
  3773. //          if(j->dtmf_rp == j->dtmf_wp)
  3774. {
  3775. j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
  3776. }
  3777. }
  3778. }
  3779. break;
  3780. case PHONE_DTMF_OOB:
  3781. j->flags.dtmf_oob = arg;
  3782. break;
  3783. case PHONE_DIALTONE:
  3784. ixj_dialtone(board);
  3785. break;
  3786. case PHONE_BUSY:
  3787. ixj_busytone(board);
  3788. break;
  3789. case PHONE_RINGBACK:
  3790. ixj_ringback(board);
  3791. break;
  3792. case PHONE_CPT_STOP:
  3793. ixj_cpt_stop(board);
  3794. break;
  3795. case IXJCTL_DSP_IDLE:
  3796. idle(board);
  3797. break;
  3798. case IXJCTL_MIXER:
  3799. ixj_mixer(arg, board);
  3800. break;
  3801. case IXJCTL_DAA_COEFF_SET:
  3802. switch (arg) {
  3803. case DAA_US:
  3804. DAA_Coeff_US(board);
  3805. ixj_daa_write(board);
  3806. break;
  3807. case DAA_UK:
  3808. DAA_Coeff_UK(board);
  3809. ixj_daa_write(board);
  3810. break;
  3811. case DAA_FRANCE:
  3812. DAA_Coeff_France(board);
  3813. ixj_daa_write(board);
  3814. break;
  3815. case DAA_GERMANY:
  3816. DAA_Coeff_Germany(board);
  3817. ixj_daa_write(board);
  3818. break;
  3819. case DAA_AUSTRALIA:
  3820. DAA_Coeff_Australia(board);
  3821. ixj_daa_write(board);
  3822. break;
  3823. case DAA_JAPAN:
  3824. DAA_Coeff_Japan(board);
  3825. ixj_daa_write(board);
  3826. break;
  3827. default:
  3828. break;
  3829. }
  3830. break;
  3831. case IXJCTL_DAA_AGAIN:
  3832. ixj_daa_cr4(board, arg | 0x02);
  3833. break;
  3834. case IXJCTL_PSTN_LINETEST:
  3835. retval = ixj_linetest(board);
  3836. break;
  3837. case IXJCTL_CID:
  3838. if (copy_to_user((char *) arg, &j->cid, sizeof(IXJ_CID)))
  3839. return -EFAULT;
  3840. j->ex.bits.caller_id = 0;
  3841. break;
  3842. case IXJCTL_WINK_DURATION:
  3843. j->winktime = arg;
  3844. break;
  3845. case IXJCTL_PORT:
  3846. if (arg)
  3847. retval = ixj_set_port(board, arg);
  3848. else
  3849. retval = j->port;
  3850. break;
  3851. case IXJCTL_POTS_PSTN:
  3852. retval = ixj_set_pots(board, arg);
  3853. break;
  3854. case PHONE_CAPABILITIES:
  3855. retval = j->caps;
  3856. break;
  3857. case PHONE_CAPABILITIES_LIST:
  3858. if (copy_to_user((char *) arg, j->caplist, sizeof(struct phone_capability) * j->caps))
  3859. return -EFAULT;
  3860. break;
  3861. case PHONE_CAPABILITIES_CHECK:
  3862. retval = capabilities_check(board, (struct phone_capability *) arg);
  3863. break;
  3864. case PHONE_PSTN_SET_STATE:
  3865. daa_set_mode(board, arg);
  3866. break;
  3867. case PHONE_PSTN_GET_STATE:
  3868. retval = j->daa_mode;
  3869. j->ex.bits.pstn_ring = 0;
  3870. break;
  3871. case IXJCTL_SET_FILTER:
  3872. if (copy_from_user(&jf, (char *) arg, sizeof(ti)))
  3873. return -EFAULT;
  3874. retval = ixj_init_filter(board, &jf);
  3875. break;
  3876. case IXJCTL_GET_FILTER_HIST:
  3877. retval = j->filter_hist[arg];
  3878. break;
  3879. case IXJCTL_INIT_TONE:
  3880. copy_from_user(&ti, (char *) arg, sizeof(ti));
  3881. retval = ixj_init_tone(board, &ti);
  3882. break;
  3883. case IXJCTL_TONE_CADENCE:
  3884. retval = ixj_build_cadence(board, (IXJ_CADENCE *) arg);
  3885. break;
  3886. case IXJCTL_INTERCOM_STOP:
  3887. ixj[board].intercom = -1;
  3888. ixj[arg].intercom = -1;
  3889. ixj_record_stop(board);
  3890. ixj_record_stop(arg);