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

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

流媒体/Mpeg4/MP4

开发平台：

C/C++

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