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

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

流媒体/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-2000  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.  *
  37.  ***************************************************************************/
  39. static char ixj_c_rcsid[] = "$Id: ixj.c,v 1.1 2000/03/27 22:29:24 ctam Exp $";
  41. //#define PERFMON_STATS
  42. #define IXJDEBUG 0
  43. #define MAXRINGS 5
  45. #include <linux/autoconf.h>
  46. #if defined(CONFIG_MODVERSIONS) && !defined(MODVERSIONS)
  47. #define MODVERSIONS
  48. #endif
  49. #ifdef MODVERSIONS
  50. #include <linux/modversions.h>
  51. #endif
  53. #ifdef CONFIG_PCMCIA
  54. #include <pcmcia/config.h>
  55. #include <pcmcia/k_compat.h>
  56. #endif
  58. #include <linux/module.h>
  60. #include <linux/init.h>
  61. #include <linux/sched.h>
  62. #include <linux/kernel.h> /* printk() */
  63. #include <linux/fs.h> /* everything... */
  64. #include <linux/errno.h> /* error codes */
  65. #include <linux/malloc.h>
  66. #include <linux/mm.h>
  67. #include <linux/ioport.h>
  68. #include <linux/interrupt.h>
  69. #include <linux/tqueue.h>
  70. #include <linux/proc_fs.h>
  71. #include <linux/poll.h>
  72. #include <linux/timer.h>
  73. #include <linux/delay.h>
  74. #include <linux/pci.h>
  76. #include <asm/io.h>
  77. #include <asm/segment.h>
  78. #include <asm/uaccess.h>
  80. #ifdef CONFIG_ISAPNP
  81. #include "../isapnp/pnpio.h"
  82. #include "../isapnp/isapnp.h"
  83. #endif
  85. #ifdef CONFIG_PCMCIA
  86. #include <pcmcia/version.h>
  87. #include <pcmcia/cs_types.h>
  88. #include <pcmcia/cs.h>
  89. #include <pcmcia/cistpl.h>
  90. #include <pcmcia/ds.h>
  91. #include <pcmcia/cisreg.h>
  92. #include <pcmcia/ciscode.h>
  93. #endif
  95. #include "ixj.h"
  97. #define TYPE(dev) (MINOR(dev) >> 4)
  98. #define NUM(dev) (MINOR(dev) & 0xf)
  100. static int ixjdebug = 0;
  101. static int hertz = HZ;
  102. static int samplerate = 100;
  104. MODULE_PARM(ixjdebug, "i");
  106. static IXJ ixj[IXJMAX];
  108. static struct timer_list ixj_timer;
  110. int ixj_convert_loaded = 0;
  112. /************************************************************************
  113. *
  114. * These are function definitions to allow external modules to register
  115. * enhanced functionality call backs.
  116. *
  117. ************************************************************************/
  119. static int Stub(IXJ * J, unsigned long arg)
  120. {
  121. return 0;
  122. }
  124. static IXJ_REGFUNC ixj_DownloadG729 = &Stub;
  125. static IXJ_REGFUNC ixj_DownloadTS85 = &Stub;
  126. static IXJ_REGFUNC ixj_PreRead = &Stub;
  127. static IXJ_REGFUNC ixj_PostRead = &Stub;
  128. static IXJ_REGFUNC ixj_PreWrite = &Stub;
  129. static IXJ_REGFUNC ixj_PostWrite = &Stub;
  130. static IXJ_REGFUNC ixj_PreIoctl = &Stub;
  131. static IXJ_REGFUNC ixj_PostIoctl = &Stub;
  133. static void ixj_read_frame(int board);
  134. static void ixj_write_frame(int board);
  135. static void ixj_init_timer(void);
  136. static void ixj_add_timer(void);
  137. static void ixj_del_timer(void);
  138. static void ixj_timeout(unsigned long ptr);
  139. static int read_filters(int board);
  140. static int LineMonitor(int board);
  141. static int ixj_fasync(int fd, struct file *, int mode);
  142. static int ixj_hookstate(int board);
  143. static int ixj_record_start(int board);
  144. static void ixj_record_stop(int board);
  145. static void ixj_vad(int board, int arg);
  146. static int ixj_play_start(int board);
  147. static void ixj_play_stop(int board);
  148. static int ixj_set_tone_on(unsigned short arg, int board);
  149. static int ixj_set_tone_off(unsigned short, int board);
  150. static int ixj_play_tone(int board, char tone);
  151. static int idle(int board);
  152. static void ixj_ring_on(int board);
  153. static void ixj_ring_off(int board);
  154. static void aec_stop(int board);
  155. static void ixj_ringback(int board);
  156. static void ixj_busytone(int board);
  157. static void ixj_dialtone(int board);
  158. static void ixj_cpt_stop(int board);
  159. static char daa_int_read(int board);
  160. static int daa_set_mode(int board, int mode);
  161. static int ixj_linetest(int board);
  162. static int ixj_daa_cid_read(int board);
  163. static void DAA_Coeff_US(int board);
  164. static void DAA_Coeff_UK(int board);
  165. static void DAA_Coeff_France(int board);
  166. static void DAA_Coeff_Germany(int board);
  167. static void DAA_Coeff_Australia(int board);
  168. static void DAA_Coeff_Japan(int board);
  169. static int ixj_init_filter(int board, IXJ_FILTER * jf);
  170. static int ixj_init_tone(int board, IXJ_TONE * ti);
  171. static int ixj_build_cadence(int board, IXJ_CADENCE * cp);
  172. static int ixj_build_filter_cadence(int board, IXJ_FILTER_CADENCE * cp);
  173. // Serial Control Interface funtions
  174. static int SCI_Control(int board, int control);
  175. static int SCI_Prepare(int board);
  176. static int SCI_WaitHighSCI(int board);
  177. static int SCI_WaitLowSCI(int board);
  178. static DWORD PCIEE_GetSerialNumber(WORD wAddress);
  180. /************************************************************************
  181. CT8020/CT8021 Host Programmers Model
  182. Host address Function Access
  183. DSPbase +
  184. 0-1 Aux Software Status Register (reserved) Read Only
  185. 2-3 Software Status Register Read Only
  186. 4-5 Aux Software Control Register (reserved) Read Write
  187. 6-7 Software Control Register Read Write
  188. 8-9 Hardware Status Register Read Only
  189. A-B Hardware Control Register Read Write
  190. C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
  191. E-F Host Recieve (Read) Data Buffer Access Port (buffer input) Read Only
  192. ************************************************************************/
  194. extern __inline__ void ixj_read_HSR(int board)
  195. {
  196. ixj[board].hsr.bytes.low = inb_p(ixj[board].DSPbase + 8);
  197. ixj[board].hsr.bytes.high = inb_p(ixj[board].DSPbase + 9);
  198. }
  200. extern __inline__ int IsControlReady(int board)
  201. {
  202. ixj_read_HSR(board);
  203. return ixj[board].hsr.bits.controlrdy ? 1 : 0;
  204. }
  206. extern __inline__ int IsPCControlReady(int board)
  207. {
  208. ixj[board].pccr1.byte = inb_p(ixj[board].XILINXbase + 3);
  209. return ixj[board].pccr1.bits.crr ? 1 : 0;
  210. }
  212. extern __inline__ int IsStatusReady(int board)
  213. {
  214. ixj_read_HSR(board);
  215. return ixj[board].hsr.bits.statusrdy ? 1 : 0;
  216. }
  218. extern __inline__ int IsRxReady(int board)
  219. {
  220. ixj_read_HSR(board);
  221. return ixj[board].hsr.bits.rxrdy ? 1 : 0;
  222. }
  224. extern __inline__ int IsTxReady(int board)
  225. {
  226. ixj_read_HSR(board);
  227. return ixj[board].hsr.bits.txrdy ? 1 : 0;
  228. }
  230. extern __inline__ BYTE SLIC_GetState(int board)
  231. {
  232. IXJ *j = &ixj[board];
  234. j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
  236. return j->pld_slicr.bits.state;
  237. }
  239. static BOOL SLIC_SetState(BYTE byState, int board)
  240. {
  241. BOOL fRetVal = FALSE;
  242. IXJ *j = &ixj[board];
  244. // Set the C1, C2, C3 & B2EN signals.
  245. switch (byState) {
  246. case PLD_SLIC_STATE_OC:
  247. j->pld_slicw.bits.c1 = 0;
  248. j->pld_slicw.bits.c2 = 0;
  249. j->pld_slicw.bits.c3 = 0;
  250. j->pld_slicw.bits.b2en = 0;
  251. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  252. fRetVal = TRUE;
  253. break;
  254. case PLD_SLIC_STATE_RINGING:
  255. j->pld_slicw.bits.c1 = 1;
  256. j->pld_slicw.bits.c2 = 0;
  257. j->pld_slicw.bits.c3 = 0;
  258. j->pld_slicw.bits.b2en = 1;
  259. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  260. fRetVal = TRUE;
  261. break;
  262. case PLD_SLIC_STATE_ACTIVE:
  263. j->pld_slicw.bits.c1 = 0;
  264. j->pld_slicw.bits.c2 = 1;
  265. j->pld_slicw.bits.c3 = 0;
  266. j->pld_slicw.bits.b2en = 0;
  267. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  268. fRetVal = TRUE;
  269. break;
  270. case PLD_SLIC_STATE_OHT: // On-hook transmit
  272. j->pld_slicw.bits.c1 = 1;
  273. j->pld_slicw.bits.c2 = 1;
  274. j->pld_slicw.bits.c3 = 0;
  275. j->pld_slicw.bits.b2en = 0;
  276. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  277. fRetVal = TRUE;
  278. break;
  279. case PLD_SLIC_STATE_TIPOPEN:
  280. j->pld_slicw.bits.c1 = 0;
  281. j->pld_slicw.bits.c2 = 0;
  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. case PLD_SLIC_STATE_STANDBY:
  288. j->pld_slicw.bits.c1 = 1;
  289. j->pld_slicw.bits.c2 = 0;
  290. j->pld_slicw.bits.c3 = 1;
  291. j->pld_slicw.bits.b2en = 1;
  292. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  293. fRetVal = TRUE;
  294. break;
  295. case PLD_SLIC_STATE_APR: // Active polarity reversal
  297. j->pld_slicw.bits.c1 = 0;
  298. j->pld_slicw.bits.c2 = 1;
  299. j->pld_slicw.bits.c3 = 1;
  300. j->pld_slicw.bits.b2en = 0;
  301. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  302. fRetVal = TRUE;
  303. break;
  304. case PLD_SLIC_STATE_OHTPR: // OHT polarity reversal
  306. j->pld_slicw.bits.c1 = 1;
  307. j->pld_slicw.bits.c2 = 1;
  308. j->pld_slicw.bits.c3 = 1;
  309. j->pld_slicw.bits.b2en = 0;
  310. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  311. fRetVal = TRUE;
  312. break;
  313. default:
  314. fRetVal = FALSE;
  315. break;
  316. }
  318. return fRetVal;
  319. }
  321. int ixj_register(int index, IXJ_REGFUNC regfunc)
  322. {
  323. int cnt;
  324. int retval = 0;
  325. switch (index) {
  326. case G729LOADER:
  327. ixj_DownloadG729 = regfunc;
  328. for (cnt = 0; cnt < IXJMAX; cnt++)
  329. ixj_DownloadG729(&ixj[cnt], 0L);
  330. break;
  331. case TS85LOADER:
  332. ixj_DownloadTS85 = regfunc;
  333. for (cnt = 0; cnt < IXJMAX; cnt++)
  334. ixj_DownloadTS85(&ixj[cnt], 0L);
  335. break;
  336. case PRE_READ:
  337. ixj_PreRead = regfunc;
  338. break;
  339. case POST_READ:
  340. ixj_PostRead = regfunc;
  341. break;
  342. case PRE_WRITE:
  343. ixj_PreWrite = regfunc;
  344. break;
  345. case POST_WRITE:
  346. ixj_PostWrite = regfunc;
  347. break;
  348. case PRE_IOCTL:
  349. ixj_PreIoctl = regfunc;
  350. break;
  351. case POST_IOCTL:
  352. ixj_PostIoctl = regfunc;
  353. break;
  354. default:
  355. retval = 1;
  356. }
  357. return retval;
  358. }
  360. int ixj_unregister(int index)
  361. {
  362. int retval = 0;
  363. switch (index) {
  364. case G729LOADER:
  365. ixj_DownloadG729 = &Stub;
  366. break;
  367. case TS85LOADER:
  368. ixj_DownloadTS85 = &Stub;
  369. break;
  370. case PRE_READ:
  371. ixj_PreRead = &Stub;
  372. break;
  373. case POST_READ:
  374. ixj_PostRead = &Stub;
  375. break;
  376. case PRE_WRITE:
  377. ixj_PreWrite = &Stub;
  378. break;
  379. case POST_WRITE:
  380. ixj_PostWrite = &Stub;
  381. break;
  382. case PRE_IOCTL:
  383. ixj_PreIoctl = &Stub;
  384. break;
  385. case POST_IOCTL:
  386. ixj_PostIoctl = &Stub;
  387. break;
  388. default:
  389. retval = 1;
  390. }
  391. return retval;
  392. }
  394. static void ixj_init_timer(void)
  395. {
  396. init_timer(&ixj_timer);
  397. ixj_timer.function = ixj_timeout;
  398. ixj_timer.data = (int) NULL;
  399. }
  401. static void ixj_add_timer(void)
  402. {
  403. ixj_timer.expires = jiffies + (hertz / samplerate);
  404. add_timer(&ixj_timer);
  405. }
  407. static void ixj_del_timer(void)
  408. {
  409. del_timer(&ixj_timer);
  410. }
  412. static void ixj_tone_timeout(int board)
  413. {
  414. IXJ *j = &ixj[board];
  415. IXJ_TONE ti;
  417. j->tone_state++;
  418. if (j->tone_state == 3) {
  419. j->tone_state = 0;
  420. if (j->cadence_t) {
  421. j->tone_cadence_state++;
  422. if (j->tone_cadence_state >= j->cadence_t->elements_used) {
  423. switch (j->cadence_t->termination) {
  424. case PLAY_ONCE:
  425. ixj_cpt_stop(board);
  426. break;
  427. case REPEAT_LAST_ELEMENT:
  428. j->tone_cadence_state--;
  429. ixj_play_tone(board, j->cadence_t->ce[j->tone_cadence_state].index);
  430. break;
  431. case REPEAT_ALL:
  432. j->tone_cadence_state = 0;
  433. if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
  434. ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
  435. ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
  436. ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
  437. ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
  438. ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
  439. ixj_init_tone(board, &ti);
  440. }
  441. ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, board);
  442. ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, board);
  443. ixj_play_tone(board, j->cadence_t->ce[0].index);
  444. break;
  445. }
  446. } else {
  447. if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
  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[j->tone_cadence_state].tone_on_time, board);
  456. ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, board);
  457. ixj_play_tone(board, j->cadence_t->ce[j->tone_cadence_state].index);
  458. }
  459. }
  460. }
  461. }
  463. static void ixj_timeout(unsigned long ptr)
  464. {
  465. int board;
  466. unsigned long jifon;
  467. IXJ *j;
  469. for (board = 0; board < IXJMAX; board++) {
  470. j = &ixj[board];
  472. if (j->DSPbase) {
  473. #ifdef PERFMON_STATS
  474. j->timerchecks++;
  475. #endif
  476. if (j->tone_state) {
  477. if (!ixj_hookstate(board)) {
  478. ixj_cpt_stop(board);
  479. if (j->m_hook) {
  480. j->m_hook = 0;
  481. j->ex.bits.hookstate = 1;
  482. if (j->async_queue)
  483. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  485. }
  486. continue;
  487. }
  488. if (j->tone_state == 1)
  489. jifon = (hertz * j->tone_on_time * 25 / 100000);
  490. else
  491. jifon = (hertz * j->tone_on_time * 25 / 100000) +
  492.     (hertz * j->tone_off_time * 25 / 100000);
  493. if (time_before(jiffies, j->tone_start_jif + jifon)) {
  494. if (j->tone_state == 1) {
  495. ixj_play_tone(board, j->tone_index);
  496. if (j->dsp.low == 0x20) {
  497. continue;
  498. }
  499. } else {
  500. ixj_play_tone(board, 0);
  501. if (j->dsp.low == 0x20) {
  502. continue;
  503. }
  504. }
  505. } else {
  506. ixj_tone_timeout(board);
  507. if (j->flags.dialtone) {
  508. ixj_dialtone(board);
  509. }
  510. if (j->flags.busytone) {
  511. ixj_busytone(board);
  512. if (j->dsp.low == 0x20) {
  513. continue;
  514. }
  515. }
  516. if (j->flags.ringback) {
  517. ixj_ringback(board);
  518. if (j->dsp.low == 0x20) {
  519. continue;
  520. }
  521. }
  522. if (!j->tone_state) {
  523. if (j->dsp.low == 0x20 || (j->play_mode == -1 && j->rec_mode == -1))
  524. idle(board);
  525. if (j->dsp.low == 0x20 && j->play_mode != -1)
  526. ixj_play_start(board);
  527. if (j->dsp.low == 0x20 && j->rec_mode != -1)
  528. ixj_record_start(board);
  529. }
  530. }
  531. }
  532. if (!j->tone_state || j->dsp.low != 0x20) {
  533. if (IsRxReady(board)) {
  534. ixj_read_frame(board);
  535. }
  536. if (IsTxReady(board)) {
  537. ixj_write_frame(board);
  538. }
  539. }
  540. if (j->flags.cringing) {
  541. if (ixj_hookstate(board) & 1) {
  542. j->flags.cringing = 0;
  543. ixj_ring_off(board);
  544. } else {
  545. if (jiffies - j->ring_cadence_jif >= (.5 * hertz)) {
  546. j->ring_cadence_t--;
  547. if (j->ring_cadence_t == -1)
  548. j->ring_cadence_t = 15;
  549. j->ring_cadence_jif = jiffies;
  550. }
  551. if (j->ring_cadence & 1 << j->ring_cadence_t) {
  552. ixj_ring_on(board);
  553. } else {
  554. ixj_ring_off(board);
  555. }
  556. continue;
  557. }
  558. }
  559. if (!j->flags.ringing) {
  560. if (ixj_hookstate(board)) {
  561. if (j->dsp.low != 0x20 &&
  562.     j->pld_slicr.bits.state != PLD_SLIC_STATE_ACTIVE)
  563. // Internet LineJACK
  564. {
  565. SLIC_SetState(PLD_SLIC_STATE_ACTIVE, board);
  566. }
  567. LineMonitor(board);
  568. read_filters(board);
  569. ixj_WriteDSPCommand(0x511B, board);
  570. j->proc_load = j->ssr.high << 8 | j->ssr.low;
  571. if (!j->m_hook) {
  572. j->m_hook = j->ex.bits.hookstate = 1;
  573. if (j->async_queue)
  574. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  576. }
  577. } else {
  578. if (j->dsp.low != 0x20 &&
  579.     j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE)
  580. // Internet LineJACK
  581. {
  582. SLIC_SetState(PLD_SLIC_STATE_STANDBY, board);
  583. }
  584. if (j->ex.bits.dtmf_ready) {
  585. j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
  586. }
  587. if (j->m_hook) {
  588. j->m_hook = 0;
  589. j->ex.bits.hookstate = 1;
  590. if (j->async_queue)
  591. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  593. }
  594. }
  595. }
  596. if (j->cardtype == 300) {
  597. if (j->flags.pstn_present) {
  598. j->pld_scrr.byte = inb_p(j->XILINXbase);
  599. if (jiffies >= j->pstn_sleeptil && j->pld_scrr.bits.daaflag) {
  600. daa_int_read(board);
  601. if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
  602. if (!j->flags.pstn_ringing) {
  603. j->flags.pstn_ringing = 1;
  604. if (j->daa_mode != SOP_PU_RINGING)
  605. daa_set_mode(board, SOP_PU_RINGING);
  606. }
  607. }
  608. if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
  609. j->pstn_winkstart = 0;
  610. if (j->flags.pstn_ringing && !j->pstn_envelope) {
  611. j->ex.bits.pstn_ring = 0;
  612. j->pstn_envelope = 1;
  613. j->pstn_ring_start = jiffies;
  614. }
  615. } else {
  616. if (j->flags.pstn_ringing && j->pstn_envelope &&
  617.     jiffies > j->pstn_ring_start + ((hertz * 15) / 10)) {
  618. j->ex.bits.pstn_ring = 1;
  619. j->pstn_envelope = 0;
  620. } else if (j->daa_mode == SOP_PU_CONVERSATION) {
  621. if (!j->pstn_winkstart) {
  622. j->pstn_winkstart = jiffies;
  623. } else if (jiffies > j->pstn_winkstart + (hertz * j->winktime / 1000)) {
  624. daa_set_mode(board, SOP_PU_SLEEP);
  625. j->pstn_winkstart = 0;
  626. j->ex.bits.pstn_wink = 1;
  627. }
  628. } else {
  629. j->ex.bits.pstn_ring = 0;
  630. }
  631. }
  632. if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
  633. if (j->daa_mode == SOP_PU_RINGING) {
  634. daa_set_mode(board, SOP_PU_SLEEP);
  635. j->flags.pstn_ringing = 0;
  636. j->ex.bits.pstn_ring = 0;
  637. }
  638. }
  639. if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
  640. if (j->daa_mode == SOP_PU_RINGING && j->flags.pstn_ringing) {
  641. j->pstn_cid_intr = 1;
  642. j->pstn_cid_recieved = jiffies;
  643. }
  644. }
  645. } else {
  646. if (j->pld_scrr.bits.daaflag) {
  647. daa_int_read(board);
  648. }
  649. j->ex.bits.pstn_ring = 0;
  650. if (j->pstn_cid_intr && jiffies > j->pstn_cid_recieved + (hertz * 3)) {
  651. if (j->daa_mode == SOP_PU_RINGING) {
  652. ixj_daa_cid_read(board);
  653. j->ex.bits.caller_id = 1;
  654. }
  655. j->pstn_cid_intr = 0;
  656. } else {
  657. j->ex.bits.caller_id = 0;
  658. }
  659. if (!j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
  660. if (j->flags.pstn_ringing && j->pstn_envelope) {
  661. j->ex.bits.pstn_ring = 1;
  662. j->pstn_envelope = 0;
  663. } else if (j->daa_mode == SOP_PU_CONVERSATION) {
  664. if (!j->pstn_winkstart) {
  665. j->pstn_winkstart = jiffies;
  666. } else if (jiffies > j->pstn_winkstart + (hertz * 320 / 1000)) {
  667. daa_set_mode(board, SOP_PU_SLEEP);
  668. j->pstn_winkstart = 0;
  669. j->ex.bits.pstn_wink = 1;
  670. }
  671. }
  672. }
  673. }
  674. }
  675. }
  676. if (j->ex.bytes) {
  677. wake_up_interruptible(&j->poll_q); // Wake any blocked selects
  679. if (j->async_queue)
  680. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  682. }
  683. } else {
  684. break;
  685. }
  686. }
  687. ixj_add_timer();
  688. }
  690. static int ixj_status_wait(int board)
  691. {
  692. unsigned long jif;
  694. jif = jiffies;
  695. while (!IsStatusReady(board)) {
  696. if (jiffies - jif > (60 * (hertz / 100))) {
  697. return -1;
  698. }
  699. }
  700. return 0;
  701. }
  703. static int ixj_PCcontrol_wait(int board)
  704. {
  705. unsigned long jif;
  707. jif = jiffies;
  708. while (!IsPCControlReady(board)) {
  709. if (jiffies - jif > (60 * (hertz / 100))) {
  710. return -1;
  711. }
  712. }
  713. return 0;
  714. }
  716. int ixj_WriteDSPCommand(unsigned short cmd, int board)
  717. {
  718. BYTES bytes;
  719. unsigned long jif;
  721. bytes.high = (cmd & 0xFF00) >> 8;
  722. bytes.low = cmd & 0x00FF;
  723. jif = jiffies;
  724. while (!IsControlReady(board)) {
  725. if (jiffies - jif > (60 * (hertz / 100))) {
  726. return -1;
  727. }
  728. }
  729. outb_p(bytes.low, ixj[board].DSPbase + 6);
  730. outb_p(bytes.high, ixj[board].DSPbase + 7);
  732. if (ixj_status_wait(board)) {
  733. ixj[board].ssr.low = 0xFF;
  734. ixj[board].ssr.high = 0xFF;
  735. return -1;
  736. }
  737. /* Read Software Status Register */
  738. ixj[board].ssr.low = inb_p(ixj[board].DSPbase + 2);
  739. ixj[board].ssr.high = inb_p(ixj[board].DSPbase + 3);
  740. return 0;
  741. }
  743. /***************************************************************************
  744. *
  745. *  General Purpose IO Register read routine
  746. *
  747. ***************************************************************************/
  748. extern __inline__ int ixj_gpio_read(int board)
  749. {
  750. if (ixj_WriteDSPCommand(0x5143, board))
  751. return -1;
  753. ixj[board].gpio.bytes.low = ixj[board].ssr.low;
  754. ixj[board].gpio.bytes.high = ixj[board].ssr.high;
  756. return 0;
  757. }
  759. extern __inline__ void LED_SetState(int state, int board)
  760. {
  761. if (ixj[board].cardtype == 300) {
  762. ixj[board].pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
  763. ixj[board].pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
  764. ixj[board].pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
  765. ixj[board].pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
  767. outb_p(ixj[board].pld_scrw.byte, ixj[board].XILINXbase);
  768. }
  769. }
  771. /*********************************************************************
  772. *  GPIO Pins are configured as follows on the Quicknet Internet
  773. *  PhoneJACK Telephony Cards
  774. * 
  775. * POTS Select        GPIO_6=0 GPIO_7=0
  776. * Mic/Speaker Select GPIO_6=0 GPIO_7=1
  777. * Handset Select     GPIO_6=1 GPIO_7=0
  778. *
  779. * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
  780. * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
  781. * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
  782. *
  783. * Hook Switch changes reported on GPIO_3
  784. *********************************************************************/
  785. static int ixj_set_port(int board, int arg)
  786. {
  787. IXJ *j = &ixj[board];
  789. if (j->cardtype == 400) {
  790. if (arg != PORT_POTS)
  791. return 10;
  792. else
  793. return 0;
  794. }
  795. if (j->cardtype == 600) {
  796. if (arg != PORT_SPEAKER)
  797. return 11;
  798. else
  799. return 0;
  800. }
  801. switch (arg) {
  802. case PORT_POTS:
  803. j->port = PORT_POTS;
  804. switch (j->cardtype) {
  805. case 500:
  806. j->pld_slicw.pcib.mic = 0;
  807. j->pld_slicw.pcib.spk = 0;
  808. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  809. break;
  810. case 300:
  811. if (ixj_WriteDSPCommand(0xC528, board)) /* Write CODEC config to
  812.    Software Control Register */
  813. return 2;
  814. j->pld_scrw.bits.daafsyncen = 0; // Turn off DAA Frame Sync
  816. outb_p(j->pld_scrw.byte, j->XILINXbase);
  817. j->pld_clock.byte = 0;
  818. outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
  819. j->pld_slicw.bits.rly1 = 1;
  820. j->pld_slicw.bits.spken = 0;
  821. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  822. SLIC_SetState(PLD_SLIC_STATE_STANDBY, board);
  823. break;
  824. case 100:
  825. j->gpio.bytes.high = 0x0B;
  826. j->gpio.bits.gpio6 = 0;
  827. j->gpio.bits.gpio7 = 0;
  828. ixj_WriteDSPCommand(j->gpio.word, board);
  829. break;
  830. }
  831. break;
  832. case PORT_PSTN:
  833. if (j->cardtype == 300) {
  834. ixj_WriteDSPCommand(0xC534, board); /* Write CODEC config to Software Control Register */
  836. j->pld_slicw.bits.rly3 = 0;
  837. j->pld_slicw.bits.rly1 = 1;
  838. j->pld_slicw.bits.spken = 0;
  839. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  840. j->port = PORT_PSTN;
  841. } else {
  842. return 4;
  843. }
  844. break;
  845. case PORT_SPEAKER:
  846. j->port = PORT_SPEAKER;
  847. switch (j->cardtype) {
  848. case 500:
  849. j->pld_slicw.pcib.mic = 1;
  850. j->pld_slicw.pcib.spk = 1;
  851. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  852. break;
  853. case 600:
  854. case 300:
  855. break;
  856. case 100:
  857. j->gpio.bytes.high = 0x0B;
  858. j->gpio.bits.gpio6 = 0;
  859. j->gpio.bits.gpio7 = 1;
  860. ixj_WriteDSPCommand(j->gpio.word, board);
  861. break;
  862. }
  863. break;
  864. case PORT_HANDSET:
  865. if (j->cardtype == 300 || j->cardtype == 500) {
  866. return 5;
  867. } else {
  868. j->gpio.bytes.high = 0x0B;
  869. j->gpio.bits.gpio6 = 1;
  870. j->gpio.bits.gpio7 = 0;
  871. ixj_WriteDSPCommand(j->gpio.word, board);
  872. j->port = PORT_HANDSET;
  873. }
  874. break;
  875. default:
  876. return 6;
  877. break;
  878. }
  879. return 0;
  880. }
  882. static int ixj_set_pots(int board, int arg)
  883. {
  884. IXJ *j = &ixj[board];
  886. if (j->cardtype == 300) {
  887. if (arg) {
  888. if (j->port == PORT_PSTN) {
  889. j->pld_slicw.bits.rly1 = 0;
  890. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  891. return 1;
  892. } else {
  893. return 0;
  894. }
  895. } else {
  896. j->pld_slicw.bits.rly1 = 1;
  897. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  898. return 1;
  899. }
  900. } else {
  901. return 0;
  902. }
  903. }
  905. static void ixj_ring_on(int board)
  906. {
  907. IXJ *j = &ixj[board];
  908. if (j->dsp.low == 0x20) // Internet PhoneJACK
  909.  {
  910. if (ixjdebug > 0)
  911. printk(KERN_INFO "IXJ Ring On /dev/phone%dn", board);
  913. j->gpio.bytes.high = 0x0B;
  914. j->gpio.bytes.low = 0x00;
  915. j->gpio.bits.gpio1 = 1;
  916. j->gpio.bits.gpio2 = 1;
  917. j->gpio.bits.gpio5 = 0;
  918. ixj_WriteDSPCommand(j->gpio.word, board); /* send the ring signal */
  919. } else // Internet LineJACK, Internet PhoneJACK Lite or 
  920. // Internet PhoneJACK PCI
  921.  {
  922. if (ixjdebug > 0)
  923. printk(KERN_INFO "IXJ Ring On /dev/phone%dn", board);
  925. SLIC_SetState(PLD_SLIC_STATE_RINGING, board);
  926. }
  927. }
  929. static int ixj_pcmcia_cable_check(int board)
  930. {
  931. IXJ *j = &ixj[board];
  932. j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
  933. if (!j->pccr1.bits.drf) {
  934. j->psccr.bits.dev = 3;
  935. j->psccr.bits.rw = 1;
  936. outb(j->psccr.byte, j->XILINXbase + 0x01);
  937. if (ixj_PCcontrol_wait(board))
  938. return 0;
  939. else {
  940. if (!j->flags.pcmciascp) {
  941. j->flags.pcmciascp = 1; // Set Cable Present Flag
  943. j->flags.pcmciasct = inb_p(j->XILINXbase + 0x01); // Get Cable Type
  945. j->sic1.bits.cpd = 0; // Chip Power Down
  947. j->sic1.bits.mpd = 0; // MIC Bias Power Down
  949. j->sic1.bits.hpd = 0; // Handset Bias Power Down
  951. j->sic1.bits.lpd = 0; // Line Bias Power Down
  953. j->sic1.bits.spd = 1; // Speaker Drive Power Down
  955. j->psccr.bits.addr = 1; // R/W Smart Cable Register Address
  957. j->psccr.bits.rw = 0; // Read / Write flag
  959. j->psccr.bits.dev = 0;
  960. outb(j->sic1.byte, j->XILINXbase + 0x00);
  961. outb(j->psccr.byte, j->XILINXbase + 0x01);
  962. ixj_PCcontrol_wait(board);
  964. j->sic2.bits.al = 0; // Analog Loopback DAC analog -> ADC analog
  966. j->sic2.bits.dl2 = 0; // Digital Loopback DAC -> ADC one bit
  968. j->sic2.bits.dl1 = 0; // Digital Loopback ADC -> DAC one bit
  970. j->sic2.bits.pll = 0; // 1 = div 10, 0 = div 5
  972. j->sic2.bits.hpd = 0; // HPF disable
  974. j->psccr.bits.addr = 2; // R/W Smart Cable Register Address
  976. j->psccr.bits.rw = 0; // Read / Write flag
  978. j->psccr.bits.dev = 0;
  979. outb(j->sic2.byte, j->XILINXbase + 0x00);
  980. outb(j->psccr.byte, j->XILINXbase + 0x01);
  981. ixj_PCcontrol_wait(board);
  983. j->psccr.bits.addr = 3; // R/W Smart Cable Register Address
  985. j->psccr.bits.rw = 0; // Read / Write flag
  987. j->psccr.bits.dev = 0;
  988. outb(0x00, j->XILINXbase + 0x00); // PLL Divide N1
  990. outb(j->psccr.byte, j->XILINXbase + 0x01);
  991. ixj_PCcontrol_wait(board);
  993. j->psccr.bits.addr = 4; // R/W Smart Cable Register Address
  995. j->psccr.bits.rw = 0; // Read / Write flag
  997. j->psccr.bits.dev = 0;
  998. outb(0x09, j->XILINXbase + 0x00); // PLL Multiply M1
  1000. outb(j->psccr.byte, j->XILINXbase + 0x01);
  1001. ixj_PCcontrol_wait(board);
  1003. j->sirxg.bits.lig = 1; // Line In Gain
  1005. j->sirxg.bits.lim = 1; // Line In Mute
  1007. j->sirxg.bits.mcg = 3; // MIC In Gain
  1009. j->sirxg.bits.mcm = 0; // MIC In Mute
  1011. j->sirxg.bits.him = 0; // Handset In Mute
  1013. j->sirxg.bits.iir = 1; // IIR
  1015. j->psccr.bits.addr = 5; // R/W Smart Cable Register Address
  1017. j->psccr.bits.rw = 0; // Read / Write flag
  1019. j->psccr.bits.dev = 0;
  1020. outb(j->sirxg.byte, j->XILINXbase + 0x00);
  1021. outb(j->psccr.byte, j->XILINXbase + 0x01);
  1022. ixj_PCcontrol_wait(board);
  1024. j->siadc.bits.hom = 0; // Handset Out Mute
  1026. j->siadc.bits.lom = 0; // Line Out Mute
  1028. j->siadc.bits.rxg = (0xC000 - 0x41C8) / 0x4EF; // RX PGA Gain
  1030. j->psccr.bits.addr = 6; // R/W Smart Cable Register Address
  1032. j->psccr.bits.rw = 0; // Read / Write flag
  1034. j->psccr.bits.dev = 0;
  1035. outb(j->siadc.byte, j->XILINXbase + 0x00);
  1036. outb(j->psccr.byte, j->XILINXbase + 0x01);
  1037. ixj_PCcontrol_wait(board);
  1039. j->sidac.bits.srm = 1; // Speaker Right Mute
  1041. j->sidac.bits.slm = 1; // Speaker Left Mute
  1043. j->sidac.bits.txg = (0xC000 - 0x45E4) / 0x5D3; // TX PGA Gain
  1045. j->psccr.bits.addr = 7; // R/W Smart Cable Register Address
  1047. j->psccr.bits.rw = 0; // Read / Write flag
  1049. j->psccr.bits.dev = 0;
  1050. outb(j->sidac.byte, j->XILINXbase + 0x00);
  1051. outb(j->psccr.byte, j->XILINXbase + 0x01);
  1052. ixj_PCcontrol_wait(board);
  1054. j->siaatt.bits.sot = 0;
  1055. j->psccr.bits.addr = 9; // R/W Smart Cable Register Address
  1057. j->psccr.bits.rw = 0; // Read / Write flag
  1059. j->psccr.bits.dev = 0;
  1060. outb(j->siaatt.byte, j->XILINXbase + 0x00);
  1061. outb(j->psccr.byte, j->XILINXbase + 0x01);
  1062. ixj_PCcontrol_wait(board);
  1063. }
  1064. }
  1065. return 1;
  1066. } else {
  1067. j->flags.pcmciascp = 0;
  1068. return 0;
  1069. }
  1070. }
  1072. static int ixj_hookstate(int board)
  1073. {
  1074. unsigned long det;
  1075. IXJ *j = &ixj[board];
  1076. int fOffHook = 0;
  1078. switch (j->cardtype) {
  1079. case 100:
  1080. ixj_gpio_read(board);
  1081. fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
  1082. break;
  1083. case 300:
  1084. case 400:
  1085. case 500:
  1086. SLIC_GetState(board);
  1087. if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
  1088.     j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
  1089. if (j->flags.ringing) {
  1090. if (!in_interrupt()) {
  1091. det = jiffies + (hertz / 50);
  1092. while (time_before(jiffies, det)) {
  1093. current->state = TASK_INTERRUPTIBLE;
  1094. schedule_timeout(1);
  1095. }
  1096. }
  1097. SLIC_GetState(board);
  1098. if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
  1099. ixj_ring_on(board);
  1100. }
  1101. }
  1102. if (j->cardtype == 500) {
  1103. j->pld_scrr.byte = inb_p(j->XILINXbase);
  1104. fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
  1105. } else
  1106. fOffHook = j->pld_slicr.bits.det ? 1 : 0;
  1107. }
  1108. break;
  1109. case 600:
  1110. fOffHook = ixj_pcmcia_cable_check(board);
  1111. break;
  1112. }
  1113. if (j->r_hook != fOffHook) {
  1114. j->r_hook = fOffHook;
  1115. if (j->port != PORT_POTS || j->cardtype == 600) {
  1116. j->ex.bits.hookstate = 1;
  1117. if (j->async_queue)
  1118. kill_fasync(j->async_queue, SIGIO); // Send apps notice of change
  1120. }
  1121. }
  1122. if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
  1123. fOffHook |= 2;
  1125. if (j->port == PORT_SPEAKER)
  1126. fOffHook |= 2;
  1128. if (j->port == PORT_HANDSET)
  1129. fOffHook |= 2;
  1131. return fOffHook;
  1132. }
  1134. static void ixj_ring_off(board)
  1135. {
  1136. IXJ *j = &ixj[board];
  1138. if (j->dsp.low == 0x20) // Internet PhoneJACK
  1139.  {
  1140. if (ixjdebug > 0)
  1141. printk(KERN_INFO "IXJ Ring Offn");
  1142. j->gpio.bytes.high = 0x0B;
  1143. j->gpio.bytes.low = 0x00;
  1144. j->gpio.bits.gpio1 = 0;
  1145. j->gpio.bits.gpio2 = 1;
  1146. j->gpio.bits.gpio5 = 0;
  1147. ixj_WriteDSPCommand(j->gpio.word, board);
  1148. } else // Internet LineJACK
  1149.  {
  1150. if (ixjdebug > 0)
  1151. printk(KERN_INFO "IXJ Ring Offn");
  1153. SLIC_SetState(PLD_SLIC_STATE_STANDBY, board);
  1155. SLIC_GetState(board);
  1156. }
  1157. }
  1159. static void ixj_ring_start(int board)
  1160. {
  1161. IXJ *j = &ixj[board];
  1163. j->flags.cringing = 1;
  1164. if (ixj_hookstate(board) & 1) {
  1165. if (j->port == PORT_POTS)
  1166. ixj_ring_off(board);
  1167. j->flags.cringing = 0;
  1168. } else {
  1169. j->ring_cadence_jif = jiffies;
  1170. j->ring_cadence_t = 15;
  1171. if (j->ring_cadence & 1 << j->ring_cadence_t) {
  1172. ixj_ring_on(board);
  1173. } else {
  1174. ixj_ring_off(board);
  1175. }
  1176. }
  1177. }
  1179. static int ixj_ring(int board)
  1180. {
  1181. char cntr;
  1182. unsigned long jif, det;
  1183. IXJ *j = &ixj[board];
  1185. j->flags.ringing = 1;
  1186. if (ixj_hookstate(board) & 1) {
  1187. ixj_ring_off(board);
  1188. j->flags.ringing = 0;
  1189. return 1;
  1190. }
  1191. det = 0;
  1192. for (cntr = 0; cntr < j->maxrings; cntr++) {
  1193. jif = jiffies + (1 * hertz);
  1194. ixj_ring_on(board);
  1195. while (time_before(jiffies, jif)) {
  1196. if (ixj_hookstate(board) & 1) {
  1197. ixj_ring_off(board);
  1198. j->flags.ringing = 0;
  1199. return 1;
  1200. }
  1201. current->state = TASK_INTERRUPTIBLE;
  1202. schedule_timeout(1);
  1203. if (signal_pending(current))
  1204. break;
  1205. }
  1206. jif = jiffies + (3 * hertz);
  1207. ixj_ring_off(board);
  1208. while (time_before(jiffies, jif)) {
  1209. if (ixj_hookstate(board) & 1) {
  1210. det = jiffies + (hertz / 100);
  1211. while (time_before(jiffies, det)) {
  1212. current->state = TASK_INTERRUPTIBLE;
  1213. schedule_timeout(1);
  1214. if (signal_pending(current))
  1215. break;
  1216. }
  1217. if (ixj_hookstate(board) & 1) {
  1218. j->flags.ringing = 0;
  1219. return 1;
  1220. }
  1221. }
  1222. current->state = TASK_INTERRUPTIBLE;
  1223. schedule_timeout(1);
  1224. if (signal_pending(current))
  1225. break;
  1226. }
  1227. }
  1228. ixj_ring_off(board);
  1229. j->flags.ringing = 0;
  1230. return 0;
  1231. }
  1233. int ixj_open(struct phone_device *p, struct file *file_p)
  1234. {
  1235. IXJ *j = &ixj[p->board];
  1237. if (!j->DSPbase)
  1238. return -ENODEV;
  1240. if (file_p->f_mode & FMODE_READ)
  1241. j->readers++;
  1242. if (file_p->f_mode & FMODE_WRITE)
  1243. j->writers++;
  1245. MOD_INC_USE_COUNT;
  1247. if (ixjdebug > 0)
  1248. printk(KERN_INFO "Opening board %dn", p->board);
  1250. return 0;
  1251. }
  1253. int ixj_release(struct inode *inode, struct file *file_p)
  1254. {
  1255. IXJ_TONE ti;
  1256. int board = NUM(inode->i_rdev);
  1257. IXJ *j = &ixj[board];
  1259. if (ixjdebug > 0)
  1260. printk(KERN_INFO "Closing board %dn", NUM(inode->i_rdev));
  1262. daa_set_mode(board, SOP_PU_SLEEP);
  1263. ixj_set_port(board, PORT_POTS);
  1264. aec_stop(board);
  1265. ixj_play_stop(board);
  1266. ixj_record_stop(board);
  1268. // Restore the tone table to default settings.
  1269. ti.tone_index = 10;
  1270. ti.gain0 = 1;
  1271. ti.freq0 = hz941;
  1272. ti.gain1 = 0;
  1273. ti.freq1 = hz1209;
  1274. ti.tone_index = 11;
  1275. ti.gain0 = 1;
  1276. ti.freq0 = hz941;
  1277. ti.gain1 = 0;
  1278. ti.freq1 = hz1336;
  1279. ti.tone_index = 12;
  1280. ti.gain0 = 1;
  1281. ti.freq0 = hz941;
  1282. ti.gain1 = 0;
  1283. ti.freq1 = hz1477;
  1284. ti.tone_index = 13;
  1285. ti.gain0 = 1;
  1286. ti.freq0 = hz800;
  1287. ti.gain1 = 0;
  1288. ti.freq1 = 0;
  1289. ixj_init_tone(board, &ti);
  1290. ti.tone_index = 14;
  1291. ti.gain0 = 1;
  1292. ti.freq0 = hz1000;
  1293. ti.gain1 = 0;
  1294. ti.freq1 = 0;
  1295. ixj_init_tone(board, &ti);
  1296. ti.tone_index = 15;
  1297. ti.gain0 = 1;
  1298. ti.freq0 = hz1250;
  1299. ti.gain1 = 0;
  1300. ti.freq1 = 0;
  1301. ixj_init_tone(board, &ti);
  1302. ti.tone_index = 16;
  1303. ti.gain0 = 1;
  1304. ti.freq0 = hz950;
  1305. ti.gain1 = 0;
  1306. ti.freq1 = 0;
  1307. ixj_init_tone(board, &ti);
  1308. ti.tone_index = 17;
  1309. ti.gain0 = 1;
  1310. ti.freq0 = hz1100;
  1311. ti.gain1 = 0;
  1312. ti.freq1 = 0;
  1313. ixj_init_tone(board, &ti);
  1314. ti.tone_index = 18;
  1315. ti.gain0 = 1;
  1316. ti.freq0 = hz1400;
  1317. ti.gain1 = 0;
  1318. ti.freq1 = 0;
  1319. ixj_init_tone(board, &ti);
  1320. ti.tone_index = 19;
  1321. ti.gain0 = 1;
  1322. ti.freq0 = hz1500;
  1323. ti.gain1 = 0;
  1324. ti.freq1 = 0;
  1325. ixj_init_tone(board, &ti);
  1326. ti.tone_index = 20;
  1327. ti.gain0 = 1;
  1328. ti.freq0 = hz1600;
  1329. ti.gain1 = 0;
  1330. ti.freq1 = 0;
  1331. ixj_init_tone(board, &ti);
  1332. ti.tone_index = 21;
  1333. ti.gain0 = 1;
  1334. ti.freq0 = hz1800;
  1335. ti.gain1 = 0;
  1336. ti.freq1 = 0;
  1337. ixj_init_tone(board, &ti);
  1338. ti.tone_index = 22;
  1339. ti.gain0 = 1;
  1340. ti.freq0 = hz2100;
  1341. ti.gain1 = 0;
  1342. ti.freq1 = 0;
  1343. ixj_init_tone(board, &ti);
  1344. ti.tone_index = 23;
  1345. ti.gain0 = 1;
  1346. ti.freq0 = hz1300;
  1347. ti.gain1 = 0;
  1348. ti.freq1 = 0;
  1349. ixj_init_tone(board, &ti);
  1350. ti.tone_index = 24;
  1351. ti.gain0 = 1;
  1352. ti.freq0 = hz2450;
  1353. ti.gain1 = 0;
  1354. ti.freq1 = 0;
  1355. ixj_init_tone(board, &ti);
  1356. ti.tone_index = 25;
  1357. ti.gain0 = 1;
  1358. ti.freq0 = hz350;
  1359. ti.gain1 = 0;
  1360. ti.freq1 = hz440;
  1361. ixj_init_tone(board, &ti);
  1362. ti.tone_index = 26;
  1363. ti.gain0 = 1;
  1364. ti.freq0 = hz440;
  1365. ti.gain1 = 0;
  1366. ti.freq1 = hz480;
  1367. ixj_init_tone(board, &ti);
  1368. ti.tone_index = 27;
  1369. ti.gain0 = 1;
  1370. ti.freq0 = hz480;
  1371. ti.gain1 = 0;
  1372. ti.freq1 = hz620;
  1373. ixj_init_tone(board, &ti);
  1375. idle(board);
  1377. if (file_p->f_mode & FMODE_READ)
  1378. j->readers--;
  1379. if (file_p->f_mode & FMODE_WRITE)
  1380. j->writers--;
  1382. if (j->read_buffer && !j->readers) {
  1383. kfree(j->read_buffer);
  1384. j->read_buffer = NULL;
  1385. j->read_buffer_size = 0;
  1386. }
  1387. if (j->write_buffer && !j->writers) {
  1388. kfree(j->write_buffer);
  1389. j->write_buffer = NULL;
  1390. j->write_buffer_size = 0;
  1391. }
  1392. j->rec_codec = j->play_codec = 0;
  1393. j->rec_frame_size = j->play_frame_size = 0;
  1394. ixj_fasync(-1, file_p, 0); // remove from list of async notification
  1396. MOD_DEC_USE_COUNT;
  1397. return 0;
  1398. }
  1400. static int read_filters(int board)
  1401. {
  1402. unsigned short fc, cnt;
  1403. int var;
  1404. IXJ *j = &ixj[board];
  1406. if (ixj_WriteDSPCommand(0x5144, board))
  1407. return -1;
  1409. fc = j->ssr.high << 8 | j->ssr.low;
  1410. if (fc == j->frame_count)
  1411. return 1;
  1413. j->frame_count = fc;
  1415. if (j->dtmf_proc)
  1416. return 1;
  1418. var = 10;
  1420. for (cnt = 0; cnt < 4; cnt++) {
  1421. if (ixj_WriteDSPCommand(0x5154 + cnt, board))
  1422. return -1;
  1424. if (ixj_WriteDSPCommand(0x515C, board))
  1425. return -1;
  1427. j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
  1429. if (j->cadence_f[cnt].enable) {
  1430. if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
  1431. if (j->cadence_f[cnt].state == 0) {
  1432. j->cadence_f[cnt].state = 1;
  1433. j->cadence_f[cnt].on1min = jiffies + (j->cadence_f[cnt].on1 * hertz * (100 - var) / 10000);
  1434. j->cadence_f[cnt].on1max = jiffies + (j->cadence_f[cnt].on1 * hertz * (100 + var) / 10000);
  1435. } else if (j->cadence_f[cnt].state == 2 &&
  1436.    (time_after(jiffies, j->cadence_f[cnt].off1min) &&
  1437.     time_before(jiffies, j->cadence_f[cnt].off1max))) {
  1438. if (j->cadence_f[cnt].on2) {
  1439. j->cadence_f[cnt].state = 3;
  1440. j->cadence_f[cnt].on2min = jiffies + (j->cadence_f[cnt].on2 * hertz * (100 - var) / 10000);
  1441. j->cadence_f[cnt].on2max = jiffies + (j->cadence_f[cnt].on2 * hertz * (100 + var) / 10000);
  1442. } else {
  1443. j->cadence_f[cnt].state = 6;
  1444. }
  1445. } else if (j->cadence_f[cnt].state == 4 &&
  1446.    (time_after(jiffies, j->cadence_f[cnt].off2min) &&
  1447.     time_before(jiffies, j->cadence_f[cnt].off2max))) {
  1448. if (j->cadence_f[cnt].on2) {
  1449. j->cadence_f[cnt].state = 5;
  1450. j->cadence_f[cnt].on3min = jiffies + (j->cadence_f[cnt].on3 * hertz * (100 - var) / 10000);
  1451. j->cadence_f[cnt].on3max = jiffies + (j->cadence_f[cnt].on3 * hertz * (100 + var) / 10000);
  1452. } else {
  1453. j->cadence_f[cnt].state = 6;
  1454. }
  1455. } else {
  1456. j->cadence_f[cnt].state = 0;
  1457. }
  1458. } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
  1459. if (j->cadence_f[cnt].state == 1 &&
  1460.     (time_after(jiffies, j->cadence_f[cnt].on1min) &&
  1461.      time_before(jiffies, j->cadence_f[cnt].on1max))) {
  1462. j->cadence_f[cnt].state = 2;
  1463. j->cadence_f[cnt].off1min = jiffies + (j->cadence_f[cnt].off1 * hertz * (100 - var) / 10000);
  1464. j->cadence_f[cnt].off1max = jiffies + (j->cadence_f[cnt].off1 * hertz * (100 + var) / 10000);
  1465. } else if (j->cadence_f[cnt].state == 3 &&
  1466.    (time_after(jiffies, j->cadence_f[cnt].on2min) &&
  1467.     time_before(jiffies, j->cadence_f[cnt].on2max))) {
  1468. j->cadence_f[cnt].state = 4;
  1469. j->cadence_f[cnt].off2min = jiffies + (j->cadence_f[cnt].off2 * hertz * (100 - var) / 10000);
  1470. j->cadence_f[cnt].off2max = jiffies + (j->cadence_f[cnt].off2 * hertz * (100 + var) / 10000);
  1471. } else if (j->cadence_f[cnt].state == 5 &&
  1472.    (time_after(jiffies, j->cadence_f[cnt].on3min) &&
  1473.     time_before(jiffies, j->cadence_f[cnt].on3max))) {
  1474. j->cadence_f[cnt].state = 6;
  1475. j->cadence_f[cnt].off3min = jiffies + (j->cadence_f[cnt].off3 * hertz * (100 - var) / 10000);
  1476. j->cadence_f[cnt].off3max = jiffies + (j->cadence_f[cnt].off3 * hertz * (100 + var) / 10000);
  1477. } else {
  1478. j->cadence_f[cnt].state = 0;
  1479. }
  1480. }
  1481. }
  1482. if (j->cadence_f[cnt].state == 6) {
  1483. j->cadence_f[cnt].state = j->cadence_f[cnt].enable = 0;
  1484. switch (cnt) {
  1485. case 0:
  1486. j->ex.bits.fc0 = 1;
  1487. break;
  1488. case 1:
  1489. j->ex.bits.fc1 = 1;
  1490. break;
  1491. case 2:
  1492. j->ex.bits.fc2 = 1;
  1493. break;
  1494. case 3:
  1495. j->ex.bits.fc3 = 1;
  1496. break;
  1497. }
  1498. }
  1499. if ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
  1500.     (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
  1501. switch (cnt) {
  1502. case 0:
  1503. j->ex.bits.f0 = 1;
  1504. break;
  1505. case 1:
  1506. j->ex.bits.f1 = 1;
  1507. break;
  1508. case 2:
  1509. j->ex.bits.f2 = 1;
  1510. break;
  1511. case 3:
  1512. j->ex.bits.f3 = 1;
  1513. break;
  1514. }
  1515. }
  1516. }
  1517. return 0;
  1518. }
  1520. static int LineMonitor(int board)
  1521. {
  1522. IXJ *j = &ixj[board];
  1524. if (j->dtmf_proc) {
  1525. return -1;
  1526. }
  1527. j->dtmf_proc = 1;
  1529. if (ixj_WriteDSPCommand(0x7000, board)) // Line Monitor
  1531. return -1;
  1533. j->dtmf.bytes.high = j->ssr.high;
  1534. j->dtmf.bytes.low = j->ssr.low;
  1535. if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
  1536. j->dtmf_state = 1;
  1537. j->dtmf_current = j->dtmf.bits.digit;
  1538. }
  1539. if (j->dtmf_state && !j->dtmf.bits.dtmf_valid) // && j->dtmf_wp != j->dtmf_rp)
  1540.  {
  1541. j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
  1542. j->dtmf_wp++;
  1543. if (j->dtmf_wp == 79)
  1544. j->dtmf_wp = 0;
  1545. j->ex.bits.dtmf_ready = 1;
  1546. j->dtmf_state = 0;
  1547. }
  1548. j->dtmf_proc = 0;
  1550. return 0;
  1551. }
  1553. ssize_t ixj_read(struct file * file_p, char *buf, size_t length, loff_t * ppos)
  1554. {
  1555. unsigned long i = *ppos;
  1556. IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];
  1557. struct wait_queue wait =
  1558. {current, NULL};
  1560. if(j->flags.inread)
  1561. return -EALREADY;
  1563. j->flags.inread = 1;
  1565. add_wait_queue(&j->read_q, &wait);
  1566. current->state = TASK_INTERRUPTIBLE;
  1567. mb();
  1569. while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
  1570. ++j->read_wait;
  1571. if (file_p->f_flags & O_NONBLOCK) {
  1572. current->state = TASK_RUNNING;
  1573. remove_wait_queue(&j->read_q, &wait);
  1574. j->flags.inread = 0;
  1575. return -EAGAIN;
  1576. }
  1577. if (!ixj_hookstate(NUM(file_p->f_dentry->d_inode->i_rdev))) {
  1578. current->state = TASK_RUNNING;
  1579. remove_wait_queue(&j->read_q, &wait);
  1580. j->flags.inread = 0;
  1581. return 0;
  1582. }
  1583. interruptible_sleep_on(&j->read_q);
  1584. if (signal_pending(current)) {
  1585. current->state = TASK_RUNNING;
  1586. remove_wait_queue(&j->read_q, &wait);
  1587. j->flags.inread = 0;
  1588. return -EINTR;
  1589. }
  1590. }
  1592. remove_wait_queue(&j->read_q, &wait);
  1593. current->state = TASK_RUNNING;
  1594. /* Don't ever copy more than the user asks */
  1595. i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
  1596. j->read_buffer_ready = 0;
  1597. if (i) {
  1598. j->flags.inread = 0;
  1599. return -EFAULT;
  1600. }
  1601. else {
  1602. j->flags.inread = 0;
  1603. return min(length, j->read_buffer_size);
  1604. }
  1605. }
  1607. ssize_t ixj_enhanced_read(struct file * file_p, char *buf, size_t length,
  1608.   loff_t * ppos)
  1609. {
  1610. int pre_retval;
  1611. ssize_t read_retval = 0;
  1612. IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];
  1614. pre_retval = ixj_PreRead(j, 0L);
  1615. switch (pre_retval) {
  1616. case NORMAL:
  1617. read_retval = ixj_read(file_p, buf, length, ppos);
  1618. ixj_PostRead(j, 0L);
  1619. break;
  1620. case NOPOST:
  1621. read_retval = ixj_read(file_p, buf, length, ppos);
  1622. break;
  1623. case POSTONLY:
  1624. ixj_PostRead(j, 0L);
  1625. break;
  1626. default:
  1627. read_retval = pre_retval;
  1628. }
  1629. return read_retval;
  1630. }
  1632. ssize_t ixj_write(struct file * file_p, const char *buf, size_t count, loff_t * ppos)
  1633. {
  1634. unsigned long i = *ppos;
  1635. int board = NUM(file_p->f_dentry->d_inode->i_rdev);
  1636. IXJ *j = &ixj[board];
  1637. struct wait_queue wait =
  1638. {current, NULL};
  1640. if(j->flags.inwrite)
  1641. return -EALREADY;
  1643. j->flags.inwrite = 1;
  1645. add_wait_queue(&j->write_q, &wait);
  1646. current->state = TASK_INTERRUPTIBLE;
  1647. mb();
  1650. while (!j->write_buffers_empty) {
  1651. ++j->write_wait;
  1652. if (file_p->f_flags & O_NONBLOCK) {
  1653. current->state = TASK_RUNNING;
  1654. remove_wait_queue(&j->write_q, &wait);
  1655. j->flags.inwrite = 0;
  1656. return -EAGAIN;
  1657. }
  1658. if (!ixj_hookstate(NUM(file_p->f_dentry->d_inode->i_rdev))) {
  1659. current->state = TASK_RUNNING;
  1660. remove_wait_queue(&j->write_q, &wait);
  1661. j->flags.inwrite = 0;
  1662. return 0;
  1663. }
  1664. interruptible_sleep_on(&j->write_q);
  1665. if (signal_pending(current)) {
  1666. current->state = TASK_RUNNING;
  1667. remove_wait_queue(&j->write_q, &wait);
  1668. j->flags.inwrite = 0;
  1669. return -EINTR;
  1670. }
  1671. }
  1672. current->state = TASK_RUNNING;
  1673. remove_wait_queue(&j->write_q, &wait);
  1674. if (j->write_buffer_wp + count >= j->write_buffer_end)
  1675. j->write_buffer_wp = j->write_buffer;
  1676. i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
  1677. if (i) {
  1678. j->flags.inwrite = 0;
  1679. return -EFAULT;
  1680. }
  1682. j->flags.inwrite = 0;
  1683. return min(count, j->write_buffer_size);
  1684. }
  1686. ssize_t ixj_enhanced_write(struct file * file_p, const char *buf, size_t count,
  1687.    loff_t * ppos)
  1688. {
  1689. int pre_retval;
  1690. ssize_t write_retval = 0;
  1691. IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];
  1693. pre_retval = ixj_PreWrite(j, 0L);
  1694. switch (pre_retval) {
  1695. case NORMAL:
  1696. write_retval = ixj_write(file_p, buf, count, ppos);
  1697. if (write_retval != -EFAULT) {
  1698. ixj_PostWrite(j, 0L);
  1699. j->write_buffer_wp += count;
  1700. j->write_buffers_empty--;
  1701. }
  1702. break;
  1703. case NOPOST:
  1704. write_retval = ixj_write(file_p, buf, count, ppos);
  1705. if (write_retval != -EFAULT) {
  1706. j->write_buffer_wp += count;
  1707. j->write_buffers_empty--;
  1708. }
  1709. break;
  1710. case POSTONLY:
  1711. ixj_PostWrite(j, 0L);
  1712. break;
  1713. default:
  1714. write_retval = pre_retval;
  1715. }
  1716. return write_retval;
  1717. }
  1719. static void ixj_read_frame(int board)
  1720. {
  1721. int cnt, dly;
  1722. IXJ *j = &ixj[board];
  1724. if (j->read_buffer) {
  1725. for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
  1726. if (!(cnt % 16) && !IsRxReady(board)) {
  1727. dly = 0;
  1728. while (!IsRxReady(board)) {
  1729. if (dly++ > 5) {
  1730. dly = 0;
  1731. break;
  1732. }
  1733. udelay(10);
  1734. }
  1735. }
  1736. // Throw away word 0 of the 8021 compressed format to get standard G.729.
  1737. if (j->rec_codec == G729 && (cnt == 0 || cnt == 5 || cnt == 10)) {
  1738. inb_p(j->DSPbase + 0x0E);
  1739. inb_p(j->DSPbase + 0x0F);
  1740. }
  1741. *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
  1742. *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
  1743. }
  1744. #ifdef PERFMON_STATS
  1745. ++j->framesread;
  1746. #endif
  1747. if (j->intercom != -1) {
  1748. if (IsTxReady(j->intercom)) {
  1749. for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
  1750. if (!(cnt % 16) && !IsTxReady(board)) {
  1751. dly = 0;
  1752. while (!IsTxReady(board)) {
  1753. if (dly++ > 5) {
  1754. dly = 0;
  1755. break;
  1756. }
  1757. udelay(10);
  1758. }
  1759. }
  1760. outb_p(*(j->read_buffer + cnt), ixj[j->intercom].DSPbase + 0x0C);
  1761. outb_p(*(j->read_buffer + cnt + 1), ixj[j->intercom].DSPbase + 0x0D);
  1762. }
  1763. #ifdef PERFMON_STATS
  1764. ++ixj[j->intercom].frameswritten;
  1765. #endif
  1766. }
  1767. } else {
  1768. j->read_buffer_ready = 1;
  1769. wake_up_interruptible(&j->read_q); // Wake any blocked readers
  1771. wake_up_interruptible(&j->poll_q); // Wake any blocked selects
  1773. if (j->async_queue)
  1774. kill_fasync(j->async_queue, SIGIO); // Send apps notice of frame
  1776. }
  1777. }
  1778. }
  1780. static void ixj_write_frame(int board)
  1781. {
  1782. int cnt, frame_count, dly;
  1783. BYTES blankword;
  1784. IXJ *j = &ixj[board];
  1786. frame_count = 0;
  1787. if (j->write_buffer && j->write_buffers_empty < 2) {
  1788. if (j->write_buffer_wp > j->write_buffer_rp) {
  1789. frame_count =
  1790.     (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
  1791. }
  1792. if (j->write_buffer_rp > j->write_buffer_wp) {
  1793. frame_count =
  1794.     (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
  1795.     (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
  1796. }
  1797. if (frame_count >= 1) {
  1798. if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
  1799. switch (j->play_mode) {
  1800. case PLAYBACK_MODE_ULAW:
  1801. case PLAYBACK_MODE_ALAW:
  1802. blankword.low = blankword.high = 0xFF;
  1803. break;
  1804. case PLAYBACK_MODE_8LINEAR:
  1805. case PLAYBACK_MODE_16LINEAR:
  1806. blankword.low = blankword.high = 0x00;
  1807. break;
  1808. case PLAYBACK_MODE_8LINEAR_WSS:
  1809. blankword.low = blankword.high = 0x80;
  1810. break;
  1811. }
  1812. for (cnt = 0; cnt < 16; cnt++) {
  1813. if (!(cnt % 16) && !IsTxReady(board)) {
  1814. dly = 0;
  1815. while (!IsTxReady(board)) {
  1816. if (dly++ > 5) {
  1817. dly = 0;
  1818. break;
  1819. }
  1820. udelay(10);
  1821. }
  1822. }
  1823. outb_p((blankword.low), j->DSPbase + 0x0C);
  1824. outb_p((blankword.high), j->DSPbase + 0x0D);
  1825. }
  1826. j->flags.play_first_frame = 0;
  1827. }
  1828. for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
  1829. if (!(cnt % 16) && !IsTxReady(board)) {
  1830. dly = 0;
  1831. while (!IsTxReady(board)) {
  1832. if (dly++ > 5) {
  1833. dly = 0;
  1834. break;
  1835. }
  1836. udelay(10);
  1837. }
  1838. }
  1839. // Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG 
  1840. // so all frames are type 1.
  1841. if (j->play_codec == G729 && (cnt == 0 || cnt == 5 || cnt == 10)) {
  1842. outb_p(0x01, j->DSPbase + 0x0C);
  1843. outb_p(0x00, j->DSPbase + 0x0D);
  1844. }
  1845. outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
  1846. outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
  1847. *(j->write_buffer_rp + cnt) = 0;
  1848. *(j->write_buffer_rp + cnt + 1) = 0;
  1849. }
  1850. j->write_buffer_rp += j->play_frame_size * 2;
  1851. if (j->write_buffer_rp >= j->write_buffer_end) {
  1852. j->write_buffer_rp = j->write_buffer;
  1853. }
  1854. j->write_buffers_empty++;
  1855. wake_up_interruptible(&j->write_q); // Wake any blocked writers
  1857. wake_up_interruptible(&j->poll_q); // Wake any blocked selects
  1859. if (j->async_queue)
  1860. kill_fasync(j->async_queue, SIGIO); // Send apps notice of empty buffer
  1861. #ifdef PERFMON_STATS
  1862. ++j->frameswritten;
  1863. #endif
  1864. }
  1865. } else {
  1866. j->drybuffer++;
  1867. }
  1868. }
  1870. static int idle(int board)
  1871. {
  1872. IXJ *j = &ixj[board];
  1874. if (ixj_WriteDSPCommand(0x0000, board)) // DSP Idle
  1876. return 0;
  1877. if (j->ssr.high || j->ssr.low)
  1878. return 0;
  1879. else
  1880. return 1;
  1881. }
  1883. static int set_base_frame(int board, int size)
  1884. {
  1885. unsigned short cmd;
  1886. int cnt;
  1887. IXJ *j = &ixj[board];
  1889. aec_stop(board);
  1890. for (cnt = 0; cnt < 10; cnt++) {
  1891. if (idle(board))
  1892. break;
  1893. }
  1894. if (j->ssr.high || j->ssr.low)
  1895. return -1;
  1896. if (j->dsp.low != 0x20) {
  1897. switch (size) {
  1898. case 30:
  1899. cmd = 0x07F0;
  1900. /* Set Base Frame Size to 240 pg9-10 8021 */
  1901. break;
  1902. case 20:
  1903. cmd = 0x07A0;
  1904. /* Set Base Frame Size to 160 pg9-10 8021 */
  1905. break;
  1906. case 10:
  1907. cmd = 0x0750;
  1908. /* Set Base Frame Size to 80 pg9-10 8021 */
  1909. break;
  1910. default:
  1911. return -1;
  1912. }
  1913. } else {
  1914. if (size == 30)
  1915. return size;
  1916. else
  1917. return -1;
  1918. }
  1919. if (ixj_WriteDSPCommand(cmd, board)) {
  1920. j->baseframe.high = j->baseframe.low = 0xFF;
  1921. return -1;
  1922. } else {
  1923. j->baseframe.high = j->ssr.high;
  1924. j->baseframe.low = j->ssr.low;
  1925. }
  1926. return size;
  1927. }
  1929. static int set_rec_codec(int board, int rate)
  1930. {
  1931. int retval = 0;
  1932. IXJ *j = &ixj[board];
  1934. j->rec_codec = rate;
  1936. switch (rate) {
  1937. case G723_63:
  1938. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  1939. j->rec_frame_size = 12;
  1940. j->rec_mode = 0;
  1941. } else {
  1942. retval = 1;
  1943. }
  1944. break;
  1945. case G723_53:
  1946. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  1947. j->rec_frame_size = 10;
  1948. j->rec_mode = 0;
  1949. } else {
  1950. retval = 1;
  1951. }
  1952. break;
  1953. case TS85:
  1954. if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
  1955. j->rec_frame_size = 16;
  1956. j->rec_mode = 0;
  1957. } else {
  1958. retval = 1;
  1959. }
  1960. break;
  1961. case TS48:
  1962. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  1963. j->rec_frame_size = 9;
  1964. j->rec_mode = 0;
  1965. } else {
  1966. retval = 1;
  1967. }
  1968. break;
  1969. case TS41:
  1970. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  1971. j->rec_frame_size = 8;
  1972. j->rec_mode = 0;
  1973. } else {
  1974. retval = 1;
  1975. }
  1976. break;
  1977. case G728:
  1978. if (j->dsp.low != 0x20) {
  1979. j->rec_frame_size = 48;
  1980. j->rec_mode = 0;
  1981. } else {
  1982. retval = 1;
  1983. }
  1984. break;
  1985. case G729:
  1986. if (j->dsp.low != 0x20) {
  1987. if (!j->flags.g729_loaded) {
  1988. retval = 1;
  1989. break;
  1990. }
  1991. switch (j->baseframe.low) {
  1992. case 0xA0:
  1993. j->rec_frame_size = 10;
  1994. break;
  1995. case 0x50:
  1996. j->rec_frame_size = 5;
  1997. break;
  1998. default:
  1999. j->rec_frame_size = 15;
  2000. break;
  2001. }
  2002. j->rec_mode = 0;
  2003. } else {
  2004. retval = 1;
  2005. }
  2006. break;
  2007. case ULAW:
  2008. switch (j->baseframe.low) {
  2009. case 0xA0:
  2010. j->rec_frame_size = 80;
  2011. break;
  2012. case 0x50:
  2013. j->rec_frame_size = 40;
  2014. break;
  2015. default:
  2016. j->rec_frame_size = 120;
  2017. break;
  2018. }
  2019. j->rec_mode = 4;
  2020. break;
  2021. case ALAW:
  2022. switch (j->baseframe.low) {
  2023. case 0xA0:
  2024. j->rec_frame_size = 80;
  2025. break;
  2026. case 0x50:
  2027. j->rec_frame_size = 40;
  2028. break;
  2029. default:
  2030. j->rec_frame_size = 120;
  2031. break;
  2032. }
  2033. j->rec_mode = 4;
  2034. break;
  2035. case LINEAR16:
  2036. switch (j->baseframe.low) {
  2037. case 0xA0:
  2038. j->rec_frame_size = 160;
  2039. break;
  2040. case 0x50:
  2041. j->rec_frame_size = 80;
  2042. break;
  2043. default:
  2044. j->rec_frame_size = 240;
  2045. break;
  2046. }
  2047. j->rec_mode = 5;
  2048. break;
  2049. case LINEAR8:
  2050. switch (j->baseframe.low) {
  2051. case 0xA0:
  2052. j->rec_frame_size = 80;
  2053. break;
  2054. case 0x50:
  2055. j->rec_frame_size = 40;
  2056. break;
  2057. default:
  2058. j->rec_frame_size = 120;
  2059. break;
  2060. }
  2061. j->rec_mode = 6;
  2062. break;
  2063. case WSS:
  2064. switch (j->baseframe.low) {
  2065. case 0xA0:
  2066. j->rec_frame_size = 80;
  2067. break;
  2068. case 0x50:
  2069. j->rec_frame_size = 40;
  2070. break;
  2071. default:
  2072. j->rec_frame_size = 120;
  2073. break;
  2074. }
  2075. j->rec_mode = 7;
  2076. break;
  2077. default:
  2078. j->rec_frame_size = 0;
  2079. j->rec_mode = -1;
  2080. if (j->read_buffer) {
  2081. kfree(j->read_buffer);
  2082. j->read_buffer = NULL;
  2083. j->read_buffer_size = 0;
  2084. }
  2085. retval = 1;
  2086. break;
  2087. }
  2088. return retval;
  2089. }
  2091. static int ixj_record_start(int board)
  2092. {
  2093. unsigned short cmd = 0x0000;
  2094. IXJ *j = &ixj[board];
  2096. if (j->read_buffer) {
  2097. ixj_record_stop(board);
  2098. }
  2099. if (!j->rec_mode) {
  2100. switch (j->rec_codec) {
  2101. case G723_63:
  2102. cmd = 0x5131;
  2103. break;
  2104. case G723_53:
  2105. cmd = 0x5132;
  2106. break;
  2107. case TS85:
  2108. cmd = 0x5130; // TrueSpeech 8.5
  2110. break;
  2111. case TS48:
  2112. cmd = 0x5133; // TrueSpeech 4.8
  2114. break;
  2115. case TS41:
  2116. cmd = 0x5134; // TrueSpeech 4.1
  2118. break;
  2119. case G728:
  2120. cmd = 0x5135;
  2121. break;
  2122. case G729:
  2123. cmd = 0x5136;
  2124. break;
  2125. default:
  2126. return 1;
  2127. }
  2128. if (ixj_WriteDSPCommand(cmd, board))
  2129. return -1;
  2130. }
  2131. if (!j->read_buffer) {
  2132. if (!j->read_buffer)
  2133. j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
  2134. if (!j->read_buffer) {
  2135. printk("Read buffer allocation for ixj board %d failed!n", board);
  2136. return -ENOMEM;
  2137. }
  2138. }
  2139. j->read_buffer_size = j->rec_frame_size * 2;
  2141. if (ixj_WriteDSPCommand(0x5102, board)) // Set Poll sync mode
  2143. return -1;
  2145. switch (j->rec_mode) {
  2146. case 0:
  2147. cmd = 0x1C03; // Record C1
  2149. break;
  2150. case 4:
  2151. if (j->ver.low == 0x12) {
  2152. cmd = 0x1E03; // Record C1
  2154. } else {
  2155. cmd = 0x1E01; // Record C1
  2157. }
  2158. break;
  2159. case 5:
  2160. if (j->ver.low == 0x12) {
  2161. cmd = 0x1E83; // Record C1
  2163. } else {
  2164. cmd = 0x1E81; // Record C1
  2166. }
  2167. break;
  2168. case 6:
  2169. if (j->ver.low == 0x12) {
  2170. cmd = 0x1F03; // Record C1
  2172. } else {
  2173. cmd = 0x1F01; // Record C1
  2175. }
  2176. break;
  2177. case 7:
  2178. if (j->ver.low == 0x12) {
  2179. cmd = 0x1F83; // Record C1
  2181. } else {
  2182. cmd = 0x1F81; // Record C1
  2184. }
  2185. break;
  2186. }
  2187. if (ixj_WriteDSPCommand(cmd, board))
  2188. return -1;
  2190. return 0;
  2191. }
  2193. static void ixj_record_stop(int board)
  2194. {
  2195. IXJ *j = &ixj[board];
  2197. if (j->read_buffer) {
  2198. kfree(j->read_buffer);
  2199. j->read_buffer = NULL;
  2200. j->read_buffer_size = 0;
  2201. }
  2202. if (j->rec_mode > -1) {
  2203. ixj_WriteDSPCommand(0x5120, board);
  2204. j->rec_mode = -1;
  2205. }
  2206. }
  2207. static void ixj_vad(int board, int arg)
  2208. {
  2209. if (arg)
  2210. ixj_WriteDSPCommand(0x513F, board);
  2211. else
  2212. ixj_WriteDSPCommand(0x513E, board);
  2213. }
  2215. static void set_rec_depth(int board, int depth)
  2216. {
  2217. if (depth > 60)
  2218. depth = 60;
  2219. if (depth < 0)
  2220. depth = 0;
  2221. ixj_WriteDSPCommand(0x5180 + depth, board);
  2222. }
  2224. static void set_rec_volume(int board, int volume)
  2225. {
  2226. ixj_WriteDSPCommand(0xCF03, board);
  2227. ixj_WriteDSPCommand(volume, board);
  2228. }
  2230. static int get_rec_level(int board)
  2231. {
  2232. IXJ *j = &ixj[board];
  2234. ixj_WriteDSPCommand(0xCF88, board);
  2236. return j->ssr.high << 8 | j->ssr.low;
  2237. }
  2239. static void ixj_aec_start(int board, int level)
  2240. {
  2241. IXJ *j = &ixj[board];
  2243. j->aec_level = level;
  2244. if (!level) {
  2245. ixj_WriteDSPCommand(0xB002, board);
  2246. } else {
  2247. if (j->rec_codec == G729 || j->play_codec == G729) {
  2248. ixj_WriteDSPCommand(0xE022, board); // Move AEC filter buffer
  2250. ixj_WriteDSPCommand(0x0300, board);
  2251. }
  2252. ixj_WriteDSPCommand(0xB001, board); // AEC On
  2254. ixj_WriteDSPCommand(0xE013, board); // Advanced AEC C1
  2256. switch (level) {
  2257. case AEC_LOW:
  2258. ixj_WriteDSPCommand(0x0000, board); // Advanced AEC C2 = off
  2260. ixj_WriteDSPCommand(0xE011, board);
  2261. ixj_WriteDSPCommand(0xFFFF, board);
  2262. break;
  2264. case AEC_MED:
  2265. ixj_WriteDSPCommand(0x0600, board); // Advanced AEC C2 = on medium
  2267. ixj_WriteDSPCommand(0xE011, board);
  2268. ixj_WriteDSPCommand(0x0080, board);
  2269. break;
  2271. case AEC_HIGH:
  2272. ixj_WriteDSPCommand(0x0C00, board); // Advanced AEC C2 = on high
  2274. ixj_WriteDSPCommand(0xE011, board);
  2275. ixj_WriteDSPCommand(0x0080, board);
  2276. break;
  2278. case AEC_AUTO:
  2279. ixj_WriteDSPCommand(0x0002, board); // Attenuation scaling factor of 2
  2281. ixj_WriteDSPCommand(0xE011, board);
  2282. ixj_WriteDSPCommand(0x0100, board); // Higher Threshold Floor
  2284. ixj_WriteDSPCommand(0xE012, board); // Set Train and Lock
  2286. ixj_WriteDSPCommand(0x0023, board);
  2288. ixj_WriteDSPCommand(0xE014, board);
  2289. ixj_WriteDSPCommand(0x0003, board); // Lock threashold at 3dB
  2291. break;
  2292. }
  2293. }
  2294. }
  2296. static void aec_stop(int board)
  2297. {
  2298. IXJ *j = &ixj[board];
  2300. if (j->rec_codec == G729 || j->play_codec == G729) {
  2301. ixj_WriteDSPCommand(0xE022, board); // Move AEC filter buffer back
  2303. ixj_WriteDSPCommand(0x0700, board);
  2304. }
  2305. if (ixj[board].play_mode != -1 && ixj[board].rec_mode != -1);
  2306. {
  2307. ixj_WriteDSPCommand(0xB002, board); // AEC Stop
  2309. }
  2310. }
  2312. static int set_play_codec(int board, int rate)
  2313. {
  2314. int retval = 0;
  2315. IXJ *j = &ixj[board];
  2317. j->play_codec = rate;
  2319. switch (rate) {
  2320. case G723_63:
  2321. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  2322. j->play_frame_size = 12;
  2323. j->play_mode = 0;
  2324. } else {
  2325. retval = 1;
  2326. }
  2327. break;
  2328. case G723_53:
  2329. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  2330. j->play_frame_size = 10;
  2331. j->play_mode = 0;
  2332. } else {
  2333. retval = 1;
  2334. }
  2335. break;
  2336. case TS85:
  2337. if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
  2338. j->play_frame_size = 16;
  2339. j->play_mode = 0;
  2340. } else {
  2341. retval = 1;
  2342. }
  2343. break;
  2344. case TS48:
  2345. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  2346. j->play_frame_size = 9;
  2347. j->play_mode = 0;
  2348. } else {
  2349. retval = 1;
  2350. }
  2351. break;
  2352. case TS41:
  2353. if (j->ver.low != 0x12 || ixj_convert_loaded) {
  2354. j->play_frame_size = 8;
  2355. j->play_mode = 0;
  2356. } else {
  2357. retval = 1;
  2358. }
  2359. break;
  2360. case G728:
  2361. if (j->dsp.low != 0x20) {
  2362. j->play_frame_size = 48;
  2363. j->play_mode = 0;
  2364. } else {
  2365. retval = 1;
  2366. }
  2367. break;
  2368. case G729:
  2369. if (j->dsp.low != 0x20) {
  2370. if (!j->flags.g729_loaded) {
  2371. retval = 1;
  2372. break;
  2373. }
  2374. switch (j->baseframe.low) {
  2375. case 0xA0:
  2376. j->play_frame_size = 10;
  2377. break;
  2378. case 0x50:
  2379. j->play_frame_size = 5;
  2380. break;
  2381. default:
  2382. j->play_frame_size = 15;
  2383. break;
  2384. }
  2385. j->play_mode = 0;
  2386. } else {
  2387. retval = 1;
  2388. }
  2389. break;
  2390. case ULAW:
  2391. switch (j->baseframe.low) {
  2392. case 0xA0:
  2393. j->play_frame_size = 80;
  2394. break;
  2395. case 0x50:
  2396. j->play_frame_size = 40;
  2397. break;
  2398. default:
  2399. j->play_frame_size = 120;
  2400. break;
  2401. }
  2402. j->play_mode = 2;
  2403. break;
  2404. case ALAW:
  2405. switch (j->baseframe.low) {
  2406. case 0xA0:
  2407. j->play_frame_size = 80;
  2408. break;
  2409. case 0x50:
  2410. j->play_frame_size = 40;
  2411. break;
  2412. default:
  2413. j->play_frame_size = 120;
  2414. break;
  2415. }
  2416. j->play_mode = 2;
  2417. break;
  2418. case LINEAR16:
  2419. switch (j->baseframe.low) {
  2420. case 0xA0:
  2421. j->play_frame_size = 160;
  2422. break;
  2423. case 0x50:
  2424. j->play_frame_size = 80;
  2425. break;
  2426. default:
  2427. j->play_frame_size = 240;
  2428. break;
  2429. }
  2430. j->play_mode = 6;
  2431. break;
  2432. case LINEAR8:
  2433. switch (j->baseframe.low) {
  2434. case 0xA0:
  2435. j->play_frame_size = 80;
  2436. break;
  2437. case 0x50:
  2438. j->play_frame_size = 40;
  2439. break;
  2440. default:
  2441. j->play_frame_size = 120;
  2442. break;
  2443. }
  2444. j->play_mode = 4;
  2445. break;
  2446. case WSS:
  2447. switch (j->baseframe.low) {
  2448. case 0xA0:
  2449. j->play_frame_size = 80;
  2450. break;
  2451. case 0x50:
  2452. j->play_frame_size = 40;
  2453. break;
  2454. default:
  2455. j->play_frame_size = 120;
  2456. break;
  2457. }
  2458. j->play_mode = 5;
  2459. break;
  2460. default:
  2461. j->play_frame_size = 0;
  2462. j->play_mode = -1;
  2463. if (j->write_buffer) {
  2464. kfree(j->write_buffer);
  2465. j->write_buffer = NULL;
  2466. j->write_buffer_size = 0;
  2467. }
  2468. retval = 1;
  2469. break;
  2470. }
  2471. return retval;
  2472. }
  2474. static int ixj_play_start(int board)
  2475. {
  2476. unsigned short cmd = 0x0000;
  2477. IXJ *j = &ixj[board];
  2479. if (j->write_buffer) {
  2480. ixj_play_stop(board);
  2481. }
  2483. j->flags.play_first_frame = 1;
  2484. j->drybuffer = 0;
  2486. if (!j->play_mode) {
  2487. switch (j->play_codec) {
  2488. case G723_63:
  2489. cmd = 0x5231;
  2490. break;
  2491. case G723_53:
  2492. cmd = 0x5232;
  2493. break;
  2494. case TS85:
  2495. cmd = 0x5230; // TrueSpeech 8.5
  2497. break;
  2498. case TS48:
  2499. cmd = 0x5233; // TrueSpeech 4.8
  2501. break;
  2502. case TS41:
  2503. cmd = 0x5234; // TrueSpeech 4.1
  2505. break;
  2506. case G728:
  2507. cmd = 0x5235;
  2508. break;
  2509. case G729:
  2510. cmd = 0x5236;
  2511. break;
  2512. default:
  2513. return 1;
  2514. }
  2515. if (ixj_WriteDSPCommand(cmd, board))
  2516. return -1;
  2517. }
  2518. j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
  2519. if (!j->write_buffer) {
  2520. printk("Write buffer allocation for ixj board %d failed!n", board);
  2521. return -ENOMEM;
  2522. }
  2523. j->write_buffers_empty = 2;
  2524. j->write_buffer_size = j->play_frame_size * 2;
  2525. j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
  2526. j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
  2528. if (ixj_WriteDSPCommand(0x5202, board)) // Set Poll sync mode
  2530. return -1;
  2532. switch (j->play_mode) {
  2533. case 0:
  2534. cmd = 0x2C03;
  2535. break;
  2536. case 2:
  2537. if (j->ver.low == 0x12) {
  2538. cmd = 0x2C23;
  2539. } else {
  2540. cmd = 0x2C21;
  2541. }
  2542. break;
  2543. case 4:
  2544. if (j->ver.low == 0x12) {
  2545. cmd = 0x2C43;
  2546. } else {
  2547. cmd = 0x2C41;
  2548. }
  2549. break;
  2550. case 5:
  2551. if (j->ver.low == 0x12) {
  2552. cmd = 0x2C53;
  2553. } else {
  2554. cmd = 0x2C51;
  2555. }
  2556. break;
  2557. case 6:
  2558. if (j->ver.low == 0x12) {
  2559. cmd = 0x2C63;
  2560. } else {
  2561. cmd = 0x2C61;
  2562. }
  2563. break;
  2564. }
  2565. if (ixj_WriteDSPCommand(cmd, board))
  2566. return -1;
  2568. if (ixj_WriteDSPCommand(0x2000, board)) // Playback C2
  2570. return -1;
  2572. if (ixj_WriteDSPCommand(0x2000 + ixj[board].play_frame_size, board)) // Playback C3
  2574. return -1;
  2576. return 0;
  2577. }
  2579. static void ixj_play_stop(int board)
  2580. {
  2581. IXJ *j = &ixj[board];
  2583. if (j->write_buffer) {
  2584. kfree(j->write_buffer);
  2585. j->write_buffer = NULL;
  2586. j->write_buffer_size = 0;
  2587. }
  2589. if (j->play_mode > -1) {
  2590. ixj_WriteDSPCommand(0x5221, board); // Stop playback
  2592. j->play_mode = -1;
  2593. }
  2594. }
  2596. extern __inline__ void set_play_depth(int board, int depth)
  2597. {
  2598. if (depth > 60)
  2599. depth = 60;
  2600. if (depth < 0)
  2601. depth = 0;
  2602. ixj_WriteDSPCommand(0x5280 + depth, board);
  2603. }
  2605. extern __inline__ void set_play_volume(int board, int volume)
  2606. {
  2607. ixj_WriteDSPCommand(0xCF02, board);
  2608. ixj_WriteDSPCommand(volume, board);
  2609. }
  2611. extern __inline__ int get_play_level(int board)
  2612. {
  2613. ixj_WriteDSPCommand(0xCF8F, board);
  2614. return ixj[board].ssr.high << 8 | ixj[board].ssr.low;
  2615. }
  2617. static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
  2618. {
  2619. unsigned int mask = 0;
  2620. IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];
  2622. poll_wait(file_p, &(j->poll_q), wait);
  2623. if (j->read_buffer_ready > 0)
  2624. mask |= POLLIN | POLLRDNORM; /* readable */
  2625. if (j->write_buffers_empty > 0)
  2626. mask |= POLLOUT | POLLWRNORM; /* writable */
  2627. if (j->ex.bytes)
  2628. mask |= POLLPRI;
  2629. return mask;
  2630. }
  2632. static int ixj_play_tone(int board, char tone)
  2633. {
  2634. IXJ *j = &ixj[board];
  2636. if (!j->tone_state)
  2637. idle(board);
  2639. j->tone_index = tone;
  2640. if (ixj_WriteDSPCommand(0x6000 + j->tone_index, board))
  2641. return -1;
  2643. if (!j->tone_state) {
  2644. j->tone_start_jif = jiffies;
  2646. j->tone_state = 1;
  2647. }
  2648. return 0;
  2649. }
  2651. static int ixj_set_tone_on(unsigned short arg, int board)
  2652. {
  2653. IXJ *j = &ixj[board];
  2655. j->tone_on_time = arg;
  2657. if (ixj_WriteDSPCommand(0x6E04, board)) // Set Tone On Period
  2659. return -1;
  2661. if (ixj_WriteDSPCommand(arg, board))
  2662. return -1;
  2664. return 0;
  2665. }
  2667. static int SCI_WaitHighSCI(int board)
  2668. {
  2669. int cnt;
  2670. IXJ *j = &ixj[board];
  2672. j->pld_scrr.byte = inb_p(j->XILINXbase);
  2673. if (!j->pld_scrr.bits.sci) {
  2674. for (cnt = 0; cnt < 10; cnt++) {
  2675. udelay(32);
  2676. j->pld_scrr.byte = inb_p(j->XILINXbase);
  2678. if ((j->pld_scrr.bits.sci))
  2679. return 1;
  2680. }
  2681. if (ixjdebug > 1)
  2682. printk(KERN_INFO "SCI Wait High failed %xn", j->pld_scrr.byte);
  2683. return 0;
  2684. } else
  2685. return 1;
  2686. }
  2688. static int SCI_WaitLowSCI(int board)
  2689. {
  2690. int cnt;
  2691. IXJ *j = &ixj[board];
  2693. j->pld_scrr.byte = inb_p(j->XILINXbase);
  2694. if (j->pld_scrr.bits.sci) {
  2695. for (cnt = 0; cnt < 10; cnt++) {
  2696. udelay(32);
  2697. j->pld_scrr.byte = inb_p(j->XILINXbase);
  2699. if (!(j->pld_scrr.bits.sci))
  2700. return 1;
  2701. }
  2702. if (ixjdebug > 1)
  2703. printk(KERN_INFO "SCI Wait Low failed %xn", j->pld_scrr.byte);
  2704. return 0;
  2705. } else
  2706. return 1;
  2707. }
  2709. static int SCI_Control(int board, int control)
  2710. {
  2711. IXJ *j = &ixj[board];
  2713. switch (control) {
  2714. case SCI_End:
  2715. j->pld_scrw.bits.c0 = 0; // Set PLD Serial control interface
  2717. j->pld_scrw.bits.c1 = 0; // to no selection 
  2719. break;
  2720. case SCI_Enable_DAA:
  2721. j->pld_scrw.bits.c0 = 1; // Set PLD Serial control interface
  2723. j->pld_scrw.bits.c1 = 0; // to write to DAA
  2725. break;
  2726. case SCI_Enable_Mixer:
  2727. j->pld_scrw.bits.c0 = 0; // Set PLD Serial control interface
  2729. j->pld_scrw.bits.c1 = 1; // to write to mixer 
  2731. break;
  2732. case SCI_Enable_EEPROM:
  2733. j->pld_scrw.bits.c0 = 1; // Set PLD Serial control interface
  2735. j->pld_scrw.bits.c1 = 1; // to write to EEPROM 
  2737. break;
  2738. default:
  2739. return 0;
  2740. break;
  2741. }
  2742. outb_p(j->pld_scrw.byte, j->XILINXbase);
  2744. switch (control) {
  2745. case SCI_End:
  2746. return 1;
  2747. break;
  2748. case SCI_Enable_DAA:
  2749. case SCI_Enable_Mixer:
  2750. case SCI_Enable_EEPROM:
  2751. if (!SCI_WaitHighSCI(board))
  2752. return 0;
  2753. break;
  2754. default:
  2755. return 0;
  2756. break;
  2757. }
  2758. return 1;
  2759. }
  2761. static int SCI_Prepare(int board)
  2762. {
  2763. if (!SCI_Control(board, SCI_End))
  2764. return 0;
  2766. if (!SCI_WaitLowSCI(board))
  2767. return 0;
  2769. return 1;
  2770. }
  2772. static int ixj_mixer(long val, int board)
  2773. {
  2774. BYTES bytes;
  2775. IXJ *j = &ixj[board];
  2777. bytes.high = (val & 0xFF00) >> 8;
  2778. bytes.low = val & 0x00FF;
  2780. outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03); // Load Mixer Address
  2782. outb_p(bytes.low, j->XILINXbase + 0x02); // Load Mixer Data
  2784. SCI_Control(board, SCI_Enable_Mixer);
  2786. SCI_Control(board, SCI_End);
  2788. return 0;
  2789. }
  2791. static int daa_load(BYTES * p_bytes, int board)
  2792. {
  2793. IXJ *j = &ixj[board];
  2795. outb_p(p_bytes->high, j->XILINXbase + 0x03);
  2796. outb_p(p_bytes->low, j->XILINXbase + 0x02);
  2797. if (!SCI_Control(board, SCI_Enable_DAA))
  2798. return 0;
  2799. else
  2800. return 1;
  2801. }
  2803. static int ixj_daa_cr4(int board, char reg)
  2804. {
  2805. IXJ *j = &ixj[board];
  2806. BYTES bytes;
  2808. switch (j->daa_mode) {
  2809. case SOP_PU_SLEEP:
  2810. bytes.high = 0x14;
  2811. break;
  2812. case SOP_PU_RINGING:
  2813. bytes.high = 0x54;
  2814. break;
  2815. case SOP_PU_CONVERSATION:
  2816. bytes.high = 0x94;
  2817. break;
  2818. case SOP_PU_PULSEDIALING:
  2819. bytes.high = 0xD4;
  2820. break;
  2821. }
  2823. j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
  2825. switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
  2826. case 0:
  2827. j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
  2828. break;
  2829. case 1:
  2830. j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
  2831. break;
  2832. case 2:
  2833. j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
  2834. break;
  2835. case 3:
  2836. j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
  2837. break;
  2838. }
  2840. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
  2842. if (!daa_load(&bytes, board))
  2843. return 0;
  2845. if (!SCI_Prepare(board))
  2846. return 0;
  2848. return 1;
  2849. }
  2851. static char daa_int_read(int board)
  2852. {
  2853. BYTES bytes;
  2854. IXJ *j = &ixj[board];
  2856. if (!SCI_Prepare(board))
  2857. return 0;
  2859. bytes.high = 0x38;
  2860. bytes.low = 0x00;
  2861. outb_p(bytes.high, j->XILINXbase + 0x03);
  2862. outb_p(bytes.low, j->XILINXbase + 0x02);
  2864. if (!SCI_Control(board, SCI_Enable_DAA))
  2865. return 0;
  2867. bytes.high = inb_p(j->XILINXbase + 0x03);
  2868. bytes.low = inb_p(j->XILINXbase + 0x02);
  2869. if (bytes.low != ALISDAA_ID_BYTE) {
  2870. if (ixjdebug > 0)
  2871. printk("Cannot read DAA ID Byte high = %d low = %dn", bytes.high, bytes.low);
  2872. return 0;
  2873. }
  2874. if (!SCI_Control(board, SCI_Enable_DAA))
  2875. return 0;
  2876. if (!SCI_Control(board, SCI_End))
  2877. return 0;
  2879. bytes.high = inb_p(j->XILINXbase + 0x03);
  2880. bytes.low = inb_p(j->XILINXbase + 0x02);
  2882. j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
  2883. return 1;
  2884. }
  2886. static int ixj_daa_cid_reset(int board)
  2887. {
  2888. int i;
  2889. BYTES bytes;
  2890. IXJ *j = &ixj[board];
  2892. if (!SCI_Prepare(board))
  2893. return 0;
  2895. bytes.high = 0x58;
  2896. bytes.low = 0x00;
  2897. outb_p(bytes.high, j->XILINXbase + 0x03);
  2898. outb_p(bytes.low, j->XILINXbase + 0x02);
  2900. if (!SCI_Control(board, SCI_Enable_DAA))
  2901. return 0;
  2903. if (!SCI_WaitHighSCI(board))
  2904. return 0;
  2906. for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
  2907. bytes.high = bytes.low = 0x00;
  2908. outb_p(bytes.high, j->XILINXbase + 0x03);
  2910. if (i < ALISDAA_CALLERID_SIZE - 1)
  2911. outb_p(bytes.low, j->XILINXbase + 0x02);
  2913. if (!SCI_Control(board, SCI_Enable_DAA))
  2914. return 0;
  2916. if (!SCI_WaitHighSCI(board))
  2917. return 0;
  2919. }
  2921. if (!SCI_Control(board, SCI_End))
  2922. return 0;
  2924. return 1;
  2925. }
  2927. static int ixj_daa_cid_read(int board)
  2928. {
  2929. int i;
  2930. BYTES bytes;
  2931. char CID[ALISDAA_CALLERID_SIZE], mContinue;
  2932. char *pIn, *pOut;
  2933. IXJ *j = &ixj[board];
  2935. if (!SCI_Prepare(board))
  2936. return 0;
  2938. bytes.high = 0x78;
  2939. bytes.low = 0x00;
  2940. outb_p(bytes.high, j->XILINXbase + 0x03);
  2941. outb_p(bytes.low, j->XILINXbase + 0x02);
  2943. if (!SCI_Control(board, SCI_Enable_DAA))
  2944. return 0;
  2946. if (!SCI_WaitHighSCI(board))
  2947. return 0;
  2949. bytes.high = inb_p(j->XILINXbase + 0x03);
  2950. bytes.low = inb_p(j->XILINXbase + 0x02);
  2951. if (bytes.low != ALISDAA_ID_BYTE) {
  2952. if (ixjdebug > 0)
  2953. printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %dn", bytes.high, bytes.low);
  2954. return 0;
  2955. }
  2956. for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
  2957. bytes.high = bytes.low = 0x00;
  2958. outb_p(bytes.high, j->XILINXbase + 0x03);
  2959. outb_p(bytes.low, j->XILINXbase + 0x02);
  2961. if (!SCI_Control(board, SCI_Enable_DAA))
  2962. return 0;
  2964. if (!SCI_WaitHighSCI(board))
  2965. return 0;
  2967. CID[i + 0] = inb_p(j->XILINXbase + 0x03);
  2968. CID[i + 1] = inb_p(j->XILINXbase + 0x02);
  2969. }
  2971. if (!SCI_Control(board, SCI_End))
  2972. return 0;
  2974. pIn = CID;
  2975. pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
  2976. mContinue = 1;
  2977. while (mContinue) {
  2978. if ((pIn[1] & 0x03) == 0x01) {
  2979. pOut[0] = pIn[0];
  2980. }
  2981. if ((pIn[2] & 0x0c) == 0x04) {
  2982. pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
  2983. }
  2984. if ((pIn[3] & 0x30) == 0x10) {
  2985. pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
  2986. }
  2987. if ((pIn[4] & 0xc0) == 0x40) {
  2988. pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
  2989. } else {
  2990. mContinue = FALSE;
  2991. }
  2992. pIn += 5, pOut += 4;
  2993. }
  2994. memset(&j->cid, 0, sizeof(IXJ_CID));
  2995. pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
  2996. pOut += 4;
  2997. strncpy(j->cid.month, pOut, 2);
  2998. pOut += 2;
  2999. strncpy(j->cid.day, pOut, 2);
  3000. pOut += 2;
  3001. strncpy(j->cid.hour, pOut, 2);
  3002. pOut += 2;
  3003. strncpy(j->cid.min, pOut, 2);
  3004. pOut += 3;
  3005. j->cid.numlen = *pOut;
  3006. pOut += 1;
  3007. strncpy(j->cid.number, pOut, j->cid.numlen);
  3008. pOut += j->cid.numlen + 1;
  3009. j->cid.namelen = *pOut;
  3010. pOut += 1;
  3011. strncpy(j->cid.name, pOut, j->cid.namelen);
  3013. ixj_daa_cid_reset(board);
  3014. return 1;
  3015. }
  3017. static char daa_get_version(int board)
  3018. {
  3019. BYTES bytes;
  3020. IXJ *j = &ixj[board];
  3022. if (!SCI_Prepare(board))
  3023. return 0;
  3025. bytes.high = 0x35;
  3026. bytes.low = 0x00;
  3027. outb_p(bytes.high, j->XILINXbase + 0x03);
  3028. outb_p(bytes.low, j->XILINXbase + 0x02);
  3030. if (!SCI_Control(board, SCI_Enable_DAA))
  3031. return 0;
  3033. bytes.high = inb_p(j->XILINXbase + 0x03);
  3034. bytes.low = inb_p(j->XILINXbase + 0x02);
  3035. if (bytes.low != ALISDAA_ID_BYTE) {
  3036. if (ixjdebug > 0)
  3037. printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %dn", bytes.high, bytes.low);
  3038. return 0;
  3039. }
  3040. if (!SCI_Control(board, SCI_Enable_DAA))
  3041. return 0;
  3043. if (!SCI_Control(board, SCI_End))
  3044. return 0;
  3046. bytes.high = inb_p(j->XILINXbase + 0x03);
  3047. bytes.low = inb_p(j->XILINXbase + 0x02);
  3048. if (ixjdebug > 0)
  3049. printk("DAA CR5 Byte high = 0x%x low = 0x%xn", bytes.high, bytes.low);
  3050. j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
  3051. return bytes.high;
  3052. }
  3054. static int daa_set_mode(int board, int mode)
  3055. {
  3056. // NOTE:
  3057. //      The DAA *MUST* be in the conversation mode if the
  3058. //      PSTN line is to be seized (PSTN line off-hook).
  3059. //      Taking the PSTN line off-hook while the DAA is in
  3060. //      a mode other than conversation mode will cause a
  3061. //      hardware failure of the ALIS-A part.
  3063. // NOTE:
  3064. //      The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
  3065. //      if the PSTN line is on-hook.  Failure to have the PSTN line
  3066. //      in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
  3067. //      ALIS-A part.
  3068. //
  3071. BYTES bytes;
  3072. IXJ *j = &ixj[board];
  3074. if (!SCI_Prepare(board))
  3075. return 0;
  3077. switch (mode) {
  3078. case SOP_PU_SLEEP:
  3079. j->pld_scrw.bits.daafsyncen = 0; // Turn off DAA Frame Sync
  3081. outb_p(j->pld_scrw.byte, j->XILINXbase);
  3082. j->pld_slicw.bits.rly2 = 0;
  3083. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  3084. bytes.high = 0x10;
  3085. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  3086. daa_load(&bytes, board);
  3087. if (!SCI_Prepare(board))
  3088. return 0;
  3089. j->daa_mode = SOP_PU_SLEEP;
  3090. j->flags.pstn_ringing = 0;
  3091. j->pstn_sleeptil = jiffies + (hertz * 3);
  3092. break;
  3093. case SOP_PU_RINGING:
  3094. j->pld_scrw.bits.daafsyncen = 0; // Turn off DAA Frame Sync
  3096. outb_p(j->pld_scrw.byte, j->XILINXbase);
  3097. j->pld_slicw.bits.rly2 = 0;
  3098. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  3099. bytes.high = 0x50;
  3100. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  3101. daa_load(&bytes, board);
  3102. if (!SCI_Prepare(board))
  3103. return 0;
  3104. j->daa_mode = SOP_PU_RINGING;
  3105. break;
  3106. case SOP_PU_CONVERSATION:
  3107. bytes.high = 0x90;
  3108. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  3109. daa_load(&bytes, board);
  3110. if (!SCI_Prepare(board))
  3111. return 0;
  3112. j->pld_slicw.bits.rly2 = 1;
  3113. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  3114. j->pld_scrw.bits.daafsyncen = 1; // Turn on DAA Frame Sync
  3116. outb_p(j->pld_scrw.byte, j->XILINXbase);
  3117. j->daa_mode = SOP_PU_CONVERSATION;
  3118. j->flags.pstn_ringing = 0;
  3119. j->ex.bits.pstn_ring = 0;
  3120. break;
  3121. case SOP_PU_PULSEDIALING:
  3122. j->pld_scrw.bits.daafsyncen = 0; // Turn off DAA Frame Sync
  3124. outb_p(j->pld_scrw.byte, j->XILINXbase);
  3125. j->pld_slicw.bits.rly2 = 0;
  3126. outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
  3127. bytes.high = 0xD0;
  3128. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  3129. daa_load(&bytes, board);
  3130. if (!SCI_Prepare(board))
  3131. return 0;
  3132. j->daa_mode = SOP_PU_PULSEDIALING;
  3133. break;
  3134. default:
  3135. break;
  3136. }
  3137. return 1;
  3138. }
  3140. static int ixj_daa_write(int board)
  3141. {
  3142. BYTES bytes;
  3143. IXJ *j = &ixj[board];
  3145. if (!SCI_Prepare(board))
  3146. return 0;
  3148. bytes.high = 0x14;
  3149. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
  3150. if (!daa_load(&bytes, board))
  3151. return 0;
  3153. bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
  3154. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
  3155. if (!daa_load(&bytes, board))
  3156. return 0;
  3158. bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
  3159. bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
  3160. if (!daa_load(&bytes, board))
  3161. return 0;
  3163. if (!SCI_Prepare(board))
  3164. return 0;
  3166. bytes.high = 0x1F;
  3167. bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
  3168. if (!daa_load(&bytes, board))
  3169. return 0;
  3171. bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
  3172. bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
  3173. if (!daa_load(&bytes, board))
  3174. return 0;
  3176. bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
  3177. bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
  3178. if (!daa_load(&bytes, board))
  3179. return 0;
  3181. bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
  3182. bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
  3183. if (!daa_load(&bytes, board))
  3184. return 0;
  3186. bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
  3187. bytes.low = 0x00;
  3188. if (!daa_load(&bytes, board))
  3189. return 0;
  3191. if (!SCI_Prepare(board))
  3192. return 0;
  3194. bytes.high = 0x00;
  3195. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
  3196. if (!daa_load(&bytes, board))
  3197. return 0;
  3199. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
  3200. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
  3201. if (!daa_load(&bytes, board))
  3202. return 0;
  3204. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
  3205. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
  3206. if (!daa_load(&bytes, board))
  3207. return 0;
  3209. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
  3210. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
  3211. if (!daa_load(&bytes, board))
  3212. return 0;
  3214. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
  3215. bytes.low = 0x00;
  3216. if (!daa_load(&bytes, board))
  3217. return 0;
  3219. if (!SCI_Control(board, SCI_End))
  3220. return 0;
  3221. if (!SCI_WaitLowSCI(board))
  3222. return 0;
  3224. bytes.high = 0x01;
  3225. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
  3226. if (!daa_load(&bytes, board))
  3227. return 0;
  3229. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
  3230. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
  3231. if (!daa_load(&bytes, board))
  3232. return 0;
  3234. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
  3235. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
  3236. if (!daa_load(&bytes, board))
  3237. return 0;
  3239. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
  3240. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
  3241. if (!daa_load(&bytes, board))
  3242. return 0;
  3244. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
  3245. bytes.low = 0x00;
  3246. if (!daa_load(&bytes, board))
  3247. return 0;
  3249. if (!SCI_Control(board, SCI_End))
  3250. return 0;
  3251. if (!SCI_WaitLowSCI(board))
  3252. return 0;
  3254. bytes.high = 0x02;
  3255. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
  3256. if (!daa_load(&bytes, board))
  3257. return 0;
  3259. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
  3260. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
  3261. if (!daa_load(&bytes, board))
  3262. return 0;
  3264. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
  3265. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
  3266. if (!daa_load(&bytes, board))
  3267. return 0;
  3269. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
  3270. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
  3271. if (!daa_load(&bytes, board))
  3272. return 0;
  3274. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
  3275. bytes.low = 0x00;
  3276. if (!daa_load(&bytes, board))
  3277. return 0;
  3279. if (!SCI_Control(board, SCI_End))
  3280. return 0;
  3281. if (!SCI_WaitLowSCI(board))
  3282. return 0;
  3284. bytes.high = 0x03;
  3285. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
  3286. if (!daa_load(&bytes, board))
  3287. return 0;
  3289. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
  3290. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
  3291. if (!daa_load(&bytes, board))
  3292. return 0;
  3294. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
  3295. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
  3296. if (!daa_load(&bytes, board))
  3297. return 0;
  3299. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
  3300. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
  3301. if (!daa_load(&bytes, board))
  3302. return 0;
  3304. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
  3305. bytes.low = 0x00;
  3306. if (!daa_load(&bytes, board))
  3307. return 0;
  3309. if (!SCI_Control(board, SCI_End))
  3310. return 0;
  3311. if (!SCI_WaitLowSCI(board))
  3312. return 0;
  3314. bytes.high = 0x04;
  3315. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
  3316. if (!daa_load(&bytes, board))
  3317. return 0;
  3319. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
  3320. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
  3321. if (!daa_load(&bytes, board))
  3322. return 0;
  3324. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
  3325. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
  3326. if (!daa_load(&bytes, board))
  3327. return 0;
  3329. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
  3330. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
  3331. if (!daa_load(&bytes, board))
  3332. return 0;
  3334. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
  3335. bytes.low = 0x00;
  3336. if (!daa_load(&bytes, board))
  3337. return 0;
  3339. if (!SCI_Control(board, SCI_End))
  3340. return 0;
  3341. if (!SCI_WaitLowSCI(board))
  3342. return 0;
  3344. bytes.high = 0x05;
  3345. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
  3346. if (!daa_load(&bytes, board))
  3347. return 0;
  3349. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
  3350. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
  3351. if (!daa_load(&bytes, board))
  3352. return 0;
  3354. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
  3355. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
  3356. if (!daa_load(&bytes, board))
  3357. return 0;
  3359. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
  3360. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
  3361. if (!daa_load(&bytes, board))
  3362. return 0;
  3364. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
  3365. bytes.low = 0x00;
  3366. if (!daa_load(&bytes, board))
  3367. return 0;
  3369. if (!SCI_Control(board, SCI_End))
  3370. return 0;
  3371. if (!SCI_WaitLowSCI(board))
  3372. return 0;
  3374. bytes.high = 0x06;
  3375. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
  3376. if (!daa_load(&bytes, board))
  3377. return 0;
  3379. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
  3380. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
  3381. if (!daa_load(&bytes, board))
  3382. return 0;
  3384. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
  3385. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
  3386. if (!daa_load(&bytes, board))
  3387. return 0;
  3389. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
  3390. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
  3391. if (!daa_load(&bytes, board))
  3392. return 0;
  3394. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
  3395. bytes.low = 0x00;
  3396. if (!daa_load(&bytes, board))
  3397. return 0;
  3399. if (!SCI_Control(board, SCI_End))
  3400. return 0;
  3401. if (!SCI_WaitLowSCI(board))
  3402. return 0;
  3404. bytes.high = 0x07;
  3405. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
  3406. if (!daa_load(&bytes, board))
  3407. return 0;
  3409. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
  3410. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
  3411. if (!daa_load(&bytes, board))
  3412. return 0;
  3414. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
  3415. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
  3416. if (!daa_load(&bytes, board))
  3417. return 0;
  3419. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
  3420. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
  3421. if (!daa_load(&bytes, board))
  3422. return 0;
  3424. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
  3425. bytes.low = 0x00;
  3426. if (!daa_load(&bytes, board))
  3427. return 0;
  3429. if (!SCI_Control(board, SCI_End))
  3430. return 0;
  3431. if (!SCI_WaitLowSCI(board))
  3432. return 0;
  3434. bytes.high = 0x08;
  3435. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
  3436. if (!daa_load(&bytes, board))
  3437. return 0;
  3439. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
  3440. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
  3441. if (!daa_load(&bytes, board))
  3442. return 0;
  3444. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
  3445. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
  3446. if (!daa_load(&bytes, board))
  3447. return 0;
  3449. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
  3450. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
  3451. if (!daa_load(&bytes, board))
  3452. return 0;
  3454. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
  3455. bytes.low = 0x00;
  3456. if (!daa_load(&bytes, board))
  3457. return 0;
  3459. if (!SCI_Control(board, SCI_End))
  3460. return 0;
  3461. if (!SCI_WaitLowSCI(board))
  3462. return 0;
  3464. bytes.high = 0x09;
  3465. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
  3466. if (!daa_load(&bytes, board))
  3467. return 0;
  3469. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
  3470. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
  3471. if (!daa_load(&bytes, board))
  3472. return 0;
  3474. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
  3475. bytes.low = 0x00;
  3476. if (!daa_load(&bytes, board))
  3477. return 0;
  3479. if (!SCI_Control(board, SCI_End))
  3480. return 0;
  3481. if (!SCI_WaitLowSCI(board))
  3482. return 0;
  3484. bytes.high = 0x0A;
  3485. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
  3486. if (!daa_load(&bytes, board))
  3487. return 0;
  3489. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
  3490. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
  3491. if (!daa_load(&bytes, board))
  3492. return 0;
  3494. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
  3495. bytes.low = 0x00;
  3496. if (!daa_load(&bytes, board))
  3497. return 0;
  3499. if (!SCI_Control(board, SCI_End))
  3500. return 0;
  3501. if (!SCI_WaitLowSCI(board))
  3502. return 0;
  3504. bytes.high = 0x0B;
  3505. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
  3506. if (!daa_load(&bytes, board))
  3507. return 0;
  3509. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
  3510. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
  3511. if (!daa_load(&bytes, board))
  3512. return 0;
  3514. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
  3515. bytes.low = 0x00;
  3516. if (!daa_load(&bytes, board))
  3517. return 0;
  3519. if (!SCI_Control(board, SCI_End))
  3520. return 0;
  3521. if (!SCI_WaitLowSCI(board))
  3522. return 0;
  3524. bytes.high = 0x0C;
  3525. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
  3526. if (!daa_load(&bytes, board))
  3527. return 0;
  3529. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
  3530. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
  3531. if (!daa_load(&bytes, board))
  3532. return 0;
  3534. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
  3535. bytes.low = 0x00;
  3536. if (!daa_load(&bytes, board))
  3537. return 0;
  3539. if (!SCI_Control(board, SCI_End))
  3540. return 0;
  3541. if (!SCI_WaitLowSCI(board))
  3542. return 0;
  3544. bytes.high = 0x0D;
  3545. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
  3546. if (!daa_load(&bytes, board))
  3547. return 0;
  3549. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
  3550. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
  3551. if (!daa_load(&bytes, board))
  3552. return 0;
  3554. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
  3555. bytes.low = 0x00;
  3556. if (!daa_load(&bytes, board))
  3557. return 0;
  3559. if (!SCI_Control(board, SCI_End))
  3560. return 0;
  3561. if (!SCI_WaitLowSCI(board))
  3562. return 0;
  3564. bytes.high = 0x0E;
  3565. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
  3566. if (!daa_load(&bytes, board))
  3567. return 0;
  3569. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
  3570. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
  3571. if (!daa_load(&bytes, board))
  3572. return 0;
  3574. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
  3575. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
  3576. if (!daa_load(&bytes, board))
  3577. return 0;
  3579. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
  3580. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
  3581. if (!daa_load(&bytes, board))
  3582. return 0;
  3584. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
  3585. bytes.low = 0x00;
  3586. if (!daa_load(&bytes, board))
  3587. return 0;
  3589. if (!SCI_Control(board, SCI_End))
  3590. return 0;
  3591. if (!SCI_WaitLowSCI(board))
  3592. return 0;
  3594. bytes.high = 0x0F;
  3595. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
  3596. if (!daa_load(&bytes, board))
  3597. return 0;
  3599. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
  3600. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
  3601. if (!daa_load(&bytes, board))
  3602. return 0;
  3604. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
  3605. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
  3606. if (!daa_load(&bytes, board))
  3607. return 0;
  3609. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
  3610. bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
  3611. if (!daa_load(&bytes, board))
  3612. return 0;
  3614. bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
  3615. bytes.low = 0x00;
  3616. if (!daa_load(&bytes, board))
  3617. return 0;
  3619. udelay(32);
  3620. j->pld_scrr.byte = inb_p(j->XILINXbase);
  3621. if (!SCI_Control(board, SCI_End))
  3622. return 0;
  3624. return 1;
  3625. }
  3627. int ixj_set_tone_off(unsigned short arg, int board)
  3628. {
  3629. ixj[board].tone_off_time = arg;
  3631. if (ixj_WriteDSPCommand(0x6E05, board)) // Set Tone Off Period
  3633. return -1;
  3635. if (ixj_WriteDSPCommand(arg, board))
  3636. return -1;
  3638. return 0;
  3639. }
  3641. static int ixj_get_tone_on(int board)
  3642. {
  3643. if (ixj_WriteDSPCommand(0x6E06, board)) // Get Tone On Period
  3645. return -1;
  3647. return 0;
  3648. }
  3650. static int ixj_get_tone_off(int board)
  3651. {
  3652. if (ixj_WriteDSPCommand(0x6E07, board)) // Get Tone Off Period
  3654. return -1;
  3656. return 0;
  3657. }
  3659. static void ixj_busytone(int board)
  3660. {
  3661. ixj[board].flags.ringback = 0;
  3662. ixj[board].flags.dialtone = 0;
  3663. ixj[board].flags.busytone = 1;
  3665. ixj_set_tone_on(0x07D0, board);
  3666. ixj_set_tone_off(0x07D0, board);
  3667. ixj_play_tone(board, 27);
  3668. }
  3670. static void ixj_dialtone(int board)
  3671. {
  3672. ixj[board].flags.ringback = 0;
  3673. ixj[board].flags.dialtone = 1;
  3674. ixj[board].flags.busytone = 0;
  3676. if (ixj[board].dsp.low == 0x20) {
  3677. return;
  3678. } else {
  3679. ixj_set_tone_on(0xFFFF, board);
  3680. ixj_set_tone_off(0x0000, board);
  3682. ixj_play_tone(board, 25);
  3683. }
  3684. }
  3686. static void ixj_cpt_stop(board)
  3687. {
  3688. IXJ *j = &ixj[board];
  3690. j->flags.dialtone = 0;
  3691. j->flags.busytone = 0;
  3692. j->flags.ringback = 0;
  3694. ixj_set_tone_on(0x0001, board);
  3695. ixj_set_tone_off(0x0000, board);
  3697. ixj_play_tone(board, 0);
  3699. j->tone_state = 0;
  3701. if (j->cadence_t) {
  3702. if (j->cadence_t->ce) {
  3703. kfree(j->cadence_t->ce);
  3704. }
  3705. kfree(j->cadence_t);
  3706. j->cadence_t = NULL;
  3707. }
  3708. if (j->dsp.low == 0x20 || (j->play_mode == -1 && j->rec_mode == -1))
  3709. idle(board);
  3710. if (j->play_mode != -1)
  3711. ixj_play_start(board);
  3712. if (j->rec_mode != -1)
  3713. ixj_record_start(board);
  3714. }
  3716. static void ixj_ringback(int board)
  3717. {
  3718. ixj[board].flags.busytone = 0;
  3719. ixj[board].flags.dialtone = 0;
  3720. ixj[board].flags.ringback = 1;
  3722. ixj_set_tone_on(0x0FA0, board);
  3723. ixj_set_tone_off(0x2EE0, board);
  3724. ixj_play_tone(board, 26);
  3725. }
  3727. static void ixj_testram(int board)
  3728. {
  3729. ixj_WriteDSPCommand(0x3001, board); /* Test External SRAM */
  3730. }
  3732. static int ixj_build_cadence(int board, IXJ_CADENCE * cp)
  3733. {
  3734. IXJ_CADENCE *lcp;
  3735. IXJ_CADENCE_ELEMENT *lcep;
  3736. IXJ_TONE ti;
  3737. IXJ *j = &ixj[board];
  3739. lcp = kmalloc(sizeof(IXJ_CADENCE), GFP_KERNEL);
  3740. if (lcp == NULL)
  3741. return -ENOMEM;
  3743. if (copy_from_user(lcp, (char *) cp, sizeof(IXJ_CADENCE)))
  3744. return -EFAULT;
  3746. lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
  3747. if (lcep == NULL) {
  3748. kfree(lcp);
  3749. return -ENOMEM;
  3750. }
  3751. if (copy_from_user(lcep, lcp->ce, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
  3752. return -EFAULT;
  3754. if (j->cadence_t) {
  3755. kfree(j->cadence_t->ce);
  3756. kfree(j->cadence_t);
  3757. }
  3758. lcp->ce = (void *) lcep;
  3759. j->cadence_t = lcp;
  3760. j->tone_cadence_state = 0;
  3761. ixj_set_tone_on(lcp->ce[0].tone_on_time, board);
  3762. ixj_set_tone_off(lcp->ce[0].tone_off_time, board);
  3763. if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
  3764. ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
  3765. ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
  3766. ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
  3767. ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
  3768. ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
  3769. ixj_init_tone(board, &ti);
  3770. }
  3771. ixj_play_tone(board, lcp->ce[0].index);
  3773. return 1;
  3774. }
  3776. static int ixj_build_filter_cadence(int board, IXJ_FILTER_CADENCE * cp)
  3777. {
  3778. IXJ_FILTER_CADENCE *lcp;
  3779. IXJ *j = &ixj[board];
  3781. lcp = kmalloc(sizeof(IXJ_CADENCE), GFP_KERNEL);
  3782. if (lcp == NULL)
  3783. return -ENOMEM;
  3785. if (copy_from_user(lcp, (char *) cp, sizeof(IXJ_FILTER_CADENCE)))
  3786. return -EFAULT;
  3788. if (lcp->filter > 4)
  3789. return -1;
  3791. j->cadence_f[lcp->filter].state = 0;
  3792. j->cadence_f[lcp->filter].enable = lcp->enable;
  3793. j->cadence_f[lcp->filter].on1 = lcp->on1;
  3794. j->cadence_f[lcp->filter].on1min = 0;
  3795. j->cadence_f[lcp->filter].on1max = 0;
  3796. j->cadence_f[lcp->filter].off1 = lcp->off1;
  3797. j->cadence_f[lcp->filter].off1min = 0;
  3798. j->cadence_f[lcp->filter].off1max = 0;
  3799. j->cadence_f[lcp->filter].on2 = lcp->on2;
  3800. j->cadence_f[lcp->filter].on2min = 0;
  3801. j->cadence_f[lcp->filter].on2max = 0;
  3802. j->cadence_f[lcp->filter].off2 = lcp->off2;
  3803. j->cadence_f[lcp->filter].off2min = 0;
  3804. j->cadence_f[lcp->filter].off2max = 0;
  3805. j->cadence_f[lcp->filter].on3 = lcp->on3;
  3806. j->cadence_f[lcp->filter].on3min = 0;
  3807. j->cadence_f[lcp->filter].on3max = 0;
  3808. j->cadence_f[lcp->filter].off3 = lcp->off3;
  3809. j->cadence_f[lcp->filter].off3min = 0;
  3810. j->cadence_f[lcp->filter].off3max = 0;
  3811. kfree(lcp);
  3812. return 0;
  3813. }
  3815. static void add_caps(int board)
  3816. {
  3817. IXJ *j = &ixj[board];
  3818. j->caps = 0;
  3820. j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
  3821. strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
  3822. j->caplist[j->caps].captype = vendor;
  3823. j->caplist[j->caps].handle = j->caps++;
  3824. j->caplist[j->caps].captype = device;
  3825. switch (j->cardtype) {
  3826. case 100:
  3827. strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
  3828. j->caplist[j->caps].cap = 100;
  3829. break;
  3830. case 300:
  3831. strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
  3832. j->caplist[j->caps].cap = 300;
  3833. break;
  3834. case 400:
  3835. strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
  3836. j->caplist[j->caps].cap = 400;
  3837. break;
  3838. case 500:
  3839. strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
  3840. j->caplist[j->caps].cap = 500;
  3841. break;
  3842. }
  3843. j->caplist[j->caps].handle = j->caps++;
  3844. strcpy(j->caplist[j->caps].desc, "POTS");
  3845. j->caplist[j->caps].captype = port;
  3846. j->caplist[j->caps].cap = pots;
  3847. j->caplist[j->caps].handle = j->caps++;
  3848. switch (ixj[board].cardtype) {
  3849. case 100:
  3850. strcpy(j->caplist[j->caps].desc, "SPEAKER");
  3851. j->caplist[j->caps].captype = port;
  3852. j->caplist[j->caps].cap = speaker;
  3853. j->caplist[j->caps].handle = j->caps++;
  3854. strcpy(j->caplist[j->caps].desc, "HANDSET");
  3855. j->caplist[j->caps].captype = port;
  3856. j->caplist[j->caps].cap = handset;
  3857. j->caplist[j->caps].handle = j->caps++;
  3858. break;
  3859. case 300:
  3860. strcpy(j->caplist[j->caps].desc, "SPEAKER");
  3861. j->caplist[j->caps].captype = port;
  3862. j->caplist[j->caps].cap = speaker;
  3863. j->caplist[j->caps].handle = j->caps++;
  3864. strcpy(j->caplist[j->caps].desc, "PSTN");
  3865. j->caplist[j->caps].captype = port;
  3866. j->caplist[j->caps].cap = pstn;
  3867. j->caplist[j->caps].handle = j->caps++;
  3868. break;
  3869. }
  3870. strcpy(j->caplist[j->caps].desc, "ULAW");
  3871. j->caplist[j->caps].captype = codec;
  3872. j->caplist[j->caps].cap = ULAW;
  3873. j->caplist[j->caps].handle = j->caps++;
  3874. strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
  3875. j->caplist[j->caps].captype = codec;
  3876. j->caplist[j->caps].cap = LINEAR16;
  3877. j->caplist[j->caps].handle = j->caps++;
  3878. strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
  3879. j->caplist[j->caps].captype = codec;
  3880. j->caplist[j->caps].cap = LINEAR8;
  3881. j->caplist[j->caps].handle = j->caps++;
  3882. strcpy(j->caplist[j->caps].desc, "Windows Sound System");
  3883. j->caplist[j->caps].captype = codec;
  3884. j->caplist[j->caps].cap = WSS;
  3885. j->caplist[j->caps].handle = j->caps++;
  3886. if (j->ver.low != 0x12) {
  3887. strcpy(j->caplist[j->caps].desc, "G.723.1 6.3Kbps");
  3888. j->caplist[j->caps].captype = codec;
  3889. j->caplist[j->caps].cap = G723_63;
  3890. j->caplist[j->caps].handle = j->caps++;
  3891. strcpy(j->caplist[j->caps].desc, "G.723.1 5.3Kbps");
  3892. j->caplist[j->caps].captype = codec;
  3893. j->caplist[j->caps].cap = G723_53;
  3894. j->caplist[j->caps].handle = j->caps++;
  3895. strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8Kbps");
  3896. j->caplist[j->caps].captype = codec;
  3897. j->caplist[j->caps].cap = TS48;
  3898. j->caplist[j->caps].handle = j->caps++;
  3899. strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1Kbps");
  3900. j->caplist[j->caps].captype = codec;
  3901. j->caplist[j->caps].cap = TS41;
  3902. j->caplist[j->caps].handle = j->caps++;
  3903. }
  3904. if (j->cardtype == 100) {
  3905. strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5Kbps");
  3906. j->caplist[j->caps].captype = codec;
  3907. j->caplist[j->caps].cap = TS85;
  3908. j->caplist[j->caps].handle = j->caps++;
  3909. }
  3910. }
  3911. static int capabilities_check(int board, struct phone_capability *pcreq)
  3912. {
  3913. int cnt;
  3914. IXJ *j = &ixj[board];
  3915. int retval = 0;
  3917. for (cnt = 0; cnt < j->caps; cnt++) {
  3918. if (pcreq->captype == j->caplist[cnt].captype &&
  3919.     pcreq->cap == j->caplist[cnt].cap) {
  3920. retval = 1;
  3921. break;
  3922. }
  3923. }
  3924. return retval;
  3925. }
  3927. int ixj_ioctl(struct inode *inode, struct file *file_p,
  3928.       unsigned int cmd, unsigned long arg)
  3929. {
  3930. IXJ_TONE ti;
  3931. IXJ_FILTER jf;
  3932. unsigned int minor = MINOR(inode->i_rdev);
  3933. int board = NUM(inode->i_rdev);
  3934. IXJ *j = &ixj[NUM(inode->i_rdev)];
  3935. int retval = 0;
  3937. if (ixjdebug > 1)
  3938. printk(KERN_DEBUG "phone%d ioctl, cmd: 0x%x, arg: 0x%lxn", minor, cmd, arg);
  3939. if (minor >= IXJMAX)
  3940. return -ENODEV;
  3942. /*
  3943.  *    Check ioctls only root can use.
  3944.  */
  3946. if (!capable(CAP_SYS_ADMIN)) {
  3947. switch (cmd) {
  3948. case IXJCTL_TESTRAM:
  3949. case IXJCTL_HZ:
  3950. return -EPERM;
  3951. }
  3952. }
  3953. switch (cmd) {
  3954. case IXJCTL_TESTRAM:
  3955. ixj_testram(board);
  3956. retval = (j->ssr.high << 8) + j->ssr.low;
  3957. break;
  3958. case IXJCTL_CARDTYPE:
  3959. retval = j->cardtype;
  3960. break;
  3961. case IXJCTL_SERIAL:
  3962. retval = j->serial;
  3963. break;
  3964. case PHONE_RING_CADENCE:
  3965. j->ring_cadence = arg;
  3966. break;
  3967. case PHONE_RING_START:
  3968. ixj_ring_start(board);
  3969. break;
  3970. case PHONE_RING_STOP:
  3971. j->flags.cringing = 0;
  3972. ixj_ring_off(board);
  3973. break;
  3974. case PHONE_RING:
  3975. retval = ixj_ring(board);
  3976. break;
  3977. case PHONE_EXCEPTION:
  3978. retval = j->ex.bytes;
  3979. j->ex.bytes &= 0x03;
  3980. break;
  3981. case PHONE_HOOKSTATE:
  3982. j->ex.bits.hookstate = 0;
  3983. retval = j->r_hook;
  3984. break;
  3985. case IXJCTL_SET_LED:
  3986. LED_SetState(arg, board);
  3987. break;
  3988. case PHONE_FRAME:
  3989. retval = set_base_frame(board, arg);
  3990. break;
  3991. case PHONE_REC_CODEC:
  3992. retval = set_rec_codec(board, arg);
  3993. break;
  3994. case PHONE_VAD:
  3995. ixj_vad(board, arg);
  3996. break;
  3997. case PHONE_REC_START:
  3998. ixj_record_start(board);
  3999. break;
  4000. case PHONE_REC_STOP:
  4001. ixj_record_stop(board);
  4002. break;
  4003. case PHONE_REC_DEPTH:
  4004. set_rec_depth(board, arg);
  4005. break;
  4006. case PHONE_REC_VOLUME:
  4007. set_rec_volume(board, arg);
  4008. break;
  4009. case PHONE_REC_LEVEL:
  4010. retval = get_rec_level(board);
  4011. break;
  4012. case IXJCTL_AEC_START:
  4013. ixj_aec_start(board, arg);
  4014. break;
  4015. case IXJCTL_AEC_STOP:
  4016. aec_stop(board);
  4017. break;
  4018. case IXJCTL_AEC_GET_LEVEL:
  4019. retval = j->aec_level;
  4020. break;
  4021. case PHONE_PLAY_CODEC:
  4022. retval = set_play_codec(board, arg);
  4023. break;
  4024. case PHONE_PLAY_START:
  4025. ixj_play_start(board);
  4026. break;
  4027. case PHONE_PLAY_STOP:
  4028. ixj_play_stop(board);
  4029. break;
  4030. case PHONE_PLAY_DEPTH:
  4031. set_play_depth(board, arg);
  4032. break;
  4033. case PHONE_PLAY_VOLUME:
  4034. set_play_volume(board, arg);
  4035. break;
  4036. case PHONE_PLAY_LEVEL:
  4037. retval = get_play_level(board);
  4038. break;
  4039. case IXJCTL_DSP_TYPE:
  4040. retval = (j->dsp.high << 8) + j->dsp.low;
  4041. break;
  4042. case IXJCTL_DSP_VERSION:
  4043. retval = (j->ver.high << 8) + j->ver.low;
  4044. break;
  4045. case IXJCTL_HZ:
  4046. hertz = arg;
  4047. break;
  4048. case IXJCTL_RATE:
  4049. if (arg > hertz)
  4050. retval = -1;
  4051. else
  4052. samplerate = arg;
  4053. break;
  4054. case IXJCTL_DRYBUFFER_READ:
  4055. put_user(j->drybuffer, (unsigned long *) arg);
  4056. break;
  4057. case IXJCTL_DRYBUFFER_CLEAR:
  4058. j->drybuffer = 0;
  4059. break;
  4060. case IXJCTL_FRAMES_READ:
  4061. put_user(j->framesread, (unsigned long *) arg);
  4062. break;
  4063. case IXJCTL_FRAMES_WRITTEN:
  4064. put_user(j->frameswritten, (unsigned long *) arg);
  4065. break;
  4066. case IXJCTL_READ_WAIT:
  4067. put_user(j->read_wait, (unsigned long *) arg);
  4068. break;
  4069. case IXJCTL_WRITE_WAIT:
  4070. put_user(j->write_wait, (unsigned long *) arg);
  4071. break;
  4072. case PHONE_MAXRINGS:
  4073. j->maxrings = arg;
  4074. break;
  4075. case PHONE_SET_TONE_ON_TIME:
  4076. ixj_set_tone_on(arg, board);
  4077. break;
  4078. case PHONE_SET_TONE_OFF_TIME:
  4079. ixj_set_tone_off(arg, board);
  4080. break;
  4081. case PHONE_GET_TONE_ON_TIME:
  4082. if (ixj_get_tone_on(board)) {
  4083. retval = -1;
  4084. } else {
  4085. retval = (j->ssr.high << 8) + j->ssr.low;
  4086. }
  4087. break;
  4088. case PHONE_GET_TONE_OFF_TIME:
  4089. if (ixj_get_tone_off(board)) {
  4090. retval = -1;
  4091. } else {
  4092. retval = (j->ssr.high << 8) + j->ssr.low;
  4093. }
  4094. break;
  4095. case PHONE_PLAY_TONE:
  4096. if (!j->tone_state)
  4097. ixj_play_tone(board, arg);
  4098. break;
  4099. case PHONE_GET_TONE_STATE:
  4100. retval = j->tone_state;
  4101. break;
  4102. case PHONE_DTMF_READY:
  4103. retval = j->ex.bits.dtmf_ready;
  4104. break;
  4105. case PHONE_GET_DTMF:
  4106. if (ixj_hookstate(board)) {
  4107. if (j->dtmf_rp != j->dtmf_wp) {
  4108. retval = j->dtmfbuffer[j->dtmf_rp];
  4109. j->dtmf_rp++;
  4110. if (j->dtmf_rp == 79)
  4111. j->dtmf_rp = 0;
  4112. if (j->dtmf_rp == j->dtmf_wp) {
  4113. j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
  4114. }
  4115. }
  4116. }
  4117. break;
  4118. case PHONE_GET_DTMF_ASCII:
  4119. if (ixj_hookstate(board)) {
  4120. if (j->dtmf_rp != j->dtmf_wp) {
  4121. switch (j->dtmfbuffer[j->dtmf_rp]) {
  4122. case 10:
  4123. retval = 42; //'*';
  4125. break;
  4126. case 11:
  4127. retval = 48; //'0';
  4129. break;
  4130. case 12:
  4131. retval = 35; //'#';
  4133. break;
  4134. case 28:
  4135. retval = 65; //'A';
  4137. break;
  4138. case 29:
  4139. retval = 66; //'B';
  4141. break;
  4142. case 30:
  4143. retval = 67; //'C';
  4145. break;
  4146. case 31:
  4147. retval = 68; //'D';
  4149. break;
  4150. default:
  4151. retval = 48 + j->dtmfbuffer[j->dtmf_rp];
  4152. break;
  4153. }
  4154. j->dtmf_rp++;
  4155. if (j->dtmf_rp == 79)
  4156. j->dtmf_rp = 0;
  4157. //          if(j->dtmf_rp == j->dtmf_wp)
  4158. {
  4159. j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
  4160. }
  4161. }
  4162. }
  4163. break;
  4164. case PHONE_DTMF_OOB:
  4165. j->flags.dtmf_oob = arg;
  4166. break;
  4167. case PHONE_DIALTONE:
  4168. ixj_dialtone(board);
  4169. break;
  4170. case PHONE_BUSY:
  4171. ixj_busytone(board);
  4172. break;
  4173. case PHONE_RINGBACK:
  4174. ixj_ringback(board);
  4175. break;
  4176. case PHONE_CPT_STOP:
  4177. ixj_cpt_stop(board);
  4178. break;
  4179. case IXJCTL_DSP_IDLE:
  4180. idle(board);
  4181. break;
  4182. case IXJCTL_MIXER:
  4183. ixj_mixer(arg, board);
  4184. break;
  4185. case IXJCTL_DAA_COEFF_SET:
  4186. switch (arg) {
  4187. case DAA_US:
  4188. DAA_Coeff_US(board);
  4189. retval = ixj_daa_write(board);
  4190. break;
  4191. case DAA_UK:
  4192. DAA_Coeff_UK(board);
  4193. retval = ixj_daa_write(board);
  4194. break;
  4195. case DAA_FRANCE:
  4196. DAA_Coeff_France(board);
  4197. retval = ixj_daa_write(board);
  4198. break;
  4199. case DAA_GERMANY:
  4200. DAA_Coeff_Germany(board);
  4201. retval = ixj_daa_write(board);
  4202. break;
  4203. case DAA_AUSTRALIA:
  4204. DAA_Coeff_Australia(board);
  4205. retval = ixj_daa_write(board);
  4206. break;
  4207. case DAA_JAPAN:
  4208. DAA_Coeff_Japan(board);
  4209. retval = ixj_daa_write(board);
  4210. break;
  4211. default:
  4212. retval = 1;
  4213. break;
  4214. }
  4215. break;
  4216. case IXJCTL_DAA_AGAIN:
  4217. ixj_daa_cr4(board, arg | 0x02);
  4218. break;
  4219. case IXJCTL_PSTN_LINETEST:
  4220. retval = ixj_linetest(board);
  4221. break;
  4222. case IXJCTL_CID:
  4223. if (copy_to_user((char *) arg, &j->cid, sizeof(IXJ_CID)))
  4224. return -EFAULT;
  4225. j->ex.bits.caller_id = 0;
  4226. break;
  4227. case IXJCTL_WINK_DURATION:
  4228. j->winktime = arg;
  4229. break;
  4230. case IXJCTL_PORT:
  4231. if (arg)
  4232. retval = ixj_set_port(board, arg);
  4233. else
  4234. retval = j->port;
  4235. break;
  4236. case IXJCTL_POTS_PSTN:
  4237. retval = ixj_set_pots(board, arg);
  4238. break;
  4239. case PHONE_CAPABILITIES:
  4240. retval = j->caps;
  4241. break;
  4242. case PHONE_CAPABILITIES_LIST:
  4243. if (copy_to_user((char *) arg, j->caplist, sizeof(struct phone_capability) * j->caps))
  4244.  return -EFAULT;
  4245. break;
  4246. case PHONE_CAPABILITIES_CHECK:
  4247. retval = capabilities_check(board, (struct phone_capability *) arg);
  4248. break;
  4249. case PHONE_PSTN_SET_STATE:
  4250. daa_set_mode(board, arg);
  4251. break;
  4252. case PHONE_PSTN_GET_STATE: