Root/package/pjsip/patches/0002-register-tapi.patch

1--- a/pjmedia/src/pjmedia-audiodev/audiodev.c
2+++ b/pjmedia/src/pjmedia-audiodev/audiodev.c
3@@ -98,6 +98,10 @@ pjmedia_aud_dev_factory* pjmedia_symb_md
4 pjmedia_aud_dev_factory* pjmedia_null_audio_factory(pj_pool_factory *pf);
5 #endif
6 
7+#if PJMEDIA_AUDIO_DEV_HAS_TAPI_DEVICE
8+pjmedia_aud_dev_factory* pjmedia_tapi_factory(pj_pool_factory *pf);
9+#endif
10+
11 #define MAX_DRIVERS 16
12 #define MAX_DEVS 64
13 
14@@ -409,6 +413,9 @@ PJ_DEF(pj_status_t) pjmedia_aud_subsys_i
15 #if PJMEDIA_AUDIO_DEV_HAS_NULL_AUDIO
16     aud_subsys.drv[aud_subsys.drv_cnt++].create = &pjmedia_null_audio_factory;
17 #endif
18+#if PJMEDIA_AUDIO_DEV_HAS_TAPI_DEVICE
19+ aud_subsys.drv[aud_subsys.drv_cnt++].create = &pjmedia_tapi_factory;
20+#endif
21 
22     /* Initialize each factory and build the device ID list */
23     for (i=0; i<aud_subsys.drv_cnt; ++i) {
24--- /dev/null
25+++ b/pjmedia/src/pjmedia-audiodev/tapi_dev.c
26@@ -0,0 +1,1307 @@
27+/******************************************************************************
28+
29+ Copyright (c) 2010
30+ Lantiq Deutschland GmbH
31+ Am Campeon 3; 85579 Neubiberg, Germany
32+
33+ For licensing information, see the file 'LICENSE' in the root folder of
34+ this software module.
35+
36+******************************************************************************/
37+#include <pjmedia-audiodev/audiodev_imp.h>
38+#include <pjmedia/errno.h>
39+#include <pj/assert.h>
40+#include <pj/pool.h>
41+#include <pj/log.h>
42+#include <pj/os.h>
43+
44+#if defined(PJMEDIA_AUDIO_DEV_HAS_TAPI_DEVICE) && PJMEDIA_AUDIO_DEV_HAS_TAPI_DEVICE
45+
46+/* Linux includes */
47+#include <stdio.h>
48+#include <string.h>
49+#include <stdlib.h>
50+#include <ctype.h>
51+#include <sys/stat.h>
52+#include <fcntl.h>
53+#include <sys/types.h>
54+#include <sys/ioctl.h>
55+#include <sys/select.h>
56+#include <sys/time.h>
57+#include <unistd.h>
58+#include <poll.h>
59+
60+/* TAPI includes */
61+#include "drv_tapi_io.h"
62+#include "vmmc_io.h"
63+
64+/* Maximum 2 devices */
65+#define TAPI_AUDIO_PORT_NUM 2
66+#define TAPI_BASE_NAME "TAPI"
67+#define TAPI_LL_DEV_BASE_PATH "/dev/vmmc"
68+#define TAPI_LL_DEV_FIRMWARE_NAME "/lib/firmware/danube_firmware.bin"
69+#define TAPI_LL_BBD_NAME "/lib/firmware/danube_bbd_fxs.bin"
70+
71+#define TAPI_LL_DEV_SELECT_TIMEOUT_MS 2000
72+#define TAPI_LL_DEV_MAX_PACKET_SIZE 800
73+#define TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE 12
74+#define TAPI_LL_DEV_ENC_FRAME_LEN_MS 20
75+#define TAPI_LL_DEV_ENC_SMPL_PER_SEC 8000
76+#define TAPI_LL_DEV_ENC_BITS_PER_SMPLS 16
77+#define TAPI_LL_DEV_ENC_SMPL_PER_FRAME 160
78+#define TAPI_LL_DEV_ENC_BYTES_PER_FRAME (TAPI_LL_DEV_ENC_SMPL_PER_FRAME * (TAPI_LL_DEV_ENC_BITS_PER_SMPLS / 8))
79+
80+#define THIS_FILE "tapi_dev.c"
81+
82+/* Set to 1 to enable tracing */
83+#if 1
84+# define TRACE_(expr) PJ_LOG(1,expr)
85+#else
86+# define TRACE_(expr)
87+#endif
88+
89+pj_int32_t ch_fd[TAPI_AUDIO_PORT_NUM];
90+
91+typedef struct
92+{
93+ pj_int32_t dev_fd;
94+ pj_int32_t ch_fd[TAPI_AUDIO_PORT_NUM];
95+ pj_int8_t data2phone_map[TAPI_AUDIO_PORT_NUM];
96+} tapi_ctx;
97+
98+struct tapi_aud_factory
99+{
100+ pjmedia_aud_dev_factory base;
101+ pj_pool_t *pool;
102+ pj_pool_factory *pf;
103+ pj_uint32_t dev_count;
104+ pjmedia_aud_dev_info *dev_info;
105+ tapi_ctx dev_ctx;
106+};
107+
108+typedef struct tapi_aud_factory tapi_aud_factory_t;
109+
110+struct tapi_aud_stream
111+{
112+ pjmedia_aud_stream base;
113+ pj_pool_t *pool;
114+ pjmedia_aud_param param;
115+ pjmedia_aud_rec_cb rec_cb;
116+ pjmedia_aud_play_cb play_cb;
117+ void *user_data;
118+
119+ pj_thread_desc thread_desc;
120+ pj_thread_t *thread;
121+ tapi_ctx *dev_ctx;
122+ pj_uint8_t run_flag;
123+ pj_timestamp timestamp;
124+};
125+
126+typedef struct tapi_aud_stream tapi_aud_stream_t;
127+
128+/* Factory prototypes */
129+static pj_status_t factory_init(pjmedia_aud_dev_factory *f);
130+static pj_status_t factory_destroy(pjmedia_aud_dev_factory *f);
131+static unsigned factory_get_dev_count(pjmedia_aud_dev_factory *f);
132+static pj_status_t factory_get_dev_info(pjmedia_aud_dev_factory *f,
133+ unsigned index,
134+ pjmedia_aud_dev_info *info);
135+static pj_status_t factory_default_param(pjmedia_aud_dev_factory *f,
136+ unsigned index,
137+ pjmedia_aud_param *param);
138+static pj_status_t factory_create_stream(pjmedia_aud_dev_factory *f,
139+ const pjmedia_aud_param *param,
140+ pjmedia_aud_rec_cb rec_cb,
141+ pjmedia_aud_play_cb play_cb,
142+ void *user_data,
143+ pjmedia_aud_stream **p_aud_strm);
144+
145+/* Stream prototypes */
146+static pj_status_t stream_get_param(pjmedia_aud_stream *strm,
147+ pjmedia_aud_param *param);
148+static pj_status_t stream_get_cap(pjmedia_aud_stream *strm,
149+ pjmedia_aud_dev_cap cap,
150+ void *value);
151+static pj_status_t stream_set_cap(pjmedia_aud_stream *strm,
152+ pjmedia_aud_dev_cap cap,
153+ const void *value);
154+static pj_status_t stream_start(pjmedia_aud_stream *strm);
155+static pj_status_t stream_stop(pjmedia_aud_stream *strm);
156+static pj_status_t stream_destroy(pjmedia_aud_stream *strm);
157+
158+static pjmedia_aud_dev_factory_op tapi_fact_op =
159+{
160+ &factory_init,
161+ &factory_destroy,
162+ &factory_get_dev_count,
163+ &factory_get_dev_info,
164+ &factory_default_param,
165+ &factory_create_stream
166+};
167+
168+static pjmedia_aud_stream_op tapi_strm_op =
169+{
170+ &stream_get_param,
171+ &stream_get_cap,
172+ &stream_set_cap,
173+ &stream_start,
174+ &stream_stop,
175+ &stream_destroy
176+};
177+
178+/* TAPI configuration */
179+static struct tapi_aud_stream streams[TAPI_AUDIO_PORT_NUM];
180+
181+void (*tapi_digit_callback)(pj_uint8_t port, pj_uint8_t digit) = NULL;
182+void (*tapi_hook_callback)(pj_uint8_t port, pj_uint8_t event) = NULL;
183+
184+#define TAPI_TONE_LOCALE_NONE 32
185+#define TAPI_TONE_LOCALE_BUSY_CODE 33
186+#define TAPI_TONE_LOCALE_CONGESTION_CODE 34
187+#define TAPI_TONE_LOCALE_DIAL_CODE 35
188+#define TAPI_TONE_LOCALE_RING_CODE 36
189+#define TAPI_TONE_LOCALE_WAITING_CODE 37
190+
191+static pj_uint8_t tapi_channel_revert = 0;
192+static pj_uint8_t tapi_cid_type = 0;
193+static pj_uint8_t tapi_locale = 0;
194+
195+void tapi_revert_channels(void)
196+{
197+ tapi_channel_revert = 1;
198+ PJ_LOG(3, (THIS_FILE, "using reverted configuration for TAPI channels"));
199+}
200+
201+void tapi_cid_select(char *cid)
202+{
203+ if (!stricmp(cid, "telecordia")) {
204+ tapi_cid_type = IFX_TAPI_CID_STD_TELCORDIA;
205+ PJ_LOG(3, (THIS_FILE, "using TELECORDIA configuration for TAPI CID"));
206+ } else if (!stricmp(cid, "etsi_fsk")) {
207+ tapi_cid_type = IFX_TAPI_CID_STD_ETSI_FSK;
208+ PJ_LOG(3, (THIS_FILE, "using ETSI FSK configuration for TAPI CID"));
209+ } else if (!stricmp(cid, "etsi_dtmf")) {
210+ tapi_cid_type = IFX_TAPI_CID_STD_ETSI_DTMF;
211+ PJ_LOG(3, (THIS_FILE, "using ETSI DTMF configuration for TAPI CID"));
212+ } else if (!stricmp(cid, "sin")) {
213+ tapi_cid_type = IFX_TAPI_CID_STD_SIN;
214+ PJ_LOG(3, (THIS_FILE, "using SIN CID configuration for TAPI CID"));
215+ } else if (!stricmp(cid, "ntt")) {
216+ tapi_cid_type = IFX_TAPI_CID_STD_NTT;
217+ PJ_LOG(3, (THIS_FILE, "using NTT configuration for TAPI CID"));
218+ } else if (!stricmp(cid, "kpn_dtmf")) {
219+ tapi_cid_type = IFX_TAPI_CID_STD_KPN_DTMF;
220+ PJ_LOG(3, (THIS_FILE, "using KPN DTMF configuration for TAPI CID"));
221+ } else if (!stricmp(cid, "kpn_dtmf_fsk")) {
222+ tapi_cid_type = IFX_TAPI_CID_STD_KPN_DTMF_FSK;
223+ PJ_LOG(3, (THIS_FILE, "using KPN DTMF FSK configuration for TAPI CID"));
224+ }
225+}
226+
227+void tapi_locale_select(char *country)
228+{
229+ IFX_TAPI_TONE_t tone;
230+ pj_status_t status;
231+ pj_uint8_t c;
232+
233+ tapi_locale = 1;
234+
235+ if (!stricmp(country, "croatia")) {
236+ PJ_LOG(3, (THIS_FILE, "using localized tones for Croatia"));
237+
238+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
239+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
240+ tone.simple.index = TAPI_TONE_LOCALE_BUSY_CODE;
241+ tone.simple.freqA = 425;
242+ tone.simple.levelA = 0;
243+ tone.simple.cadence[0] = 500;
244+ tone.simple.cadence[1] = 500;
245+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
246+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
247+ tone.simple.loop = 0;
248+ tone.simple.pause = 0;
249+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
250+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
251+ if (status != PJ_SUCCESS)
252+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
253+ }
254+
255+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
256+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
257+ tone.simple.index = TAPI_TONE_LOCALE_CONGESTION_CODE;
258+ tone.simple.freqA = 425;
259+ tone.simple.levelA = 0;
260+ tone.simple.cadence[0] = 250;
261+ tone.simple.cadence[1] = 250;
262+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
263+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
264+ tone.simple.loop = 0;
265+ tone.simple.pause = 0;
266+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
267+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
268+ if (status != PJ_SUCCESS)
269+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
270+ }
271+
272+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
273+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
274+ tone.simple.index = TAPI_TONE_LOCALE_DIAL_CODE;
275+ tone.simple.freqA = 425;
276+ tone.simple.levelA = 0;
277+ tone.simple.cadence[0] = 200;
278+ tone.simple.cadence[1] = 300;
279+ tone.simple.cadence[2] = 700;
280+ tone.simple.cadence[3] = 800;
281+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
282+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
283+ tone.simple.frequencies[2] = IFX_TAPI_TONE_FREQA;
284+ tone.simple.frequencies[3] = IFX_TAPI_TONE_FREQNONE;
285+ tone.simple.loop = 0;
286+ tone.simple.pause = 0;
287+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
288+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
289+ if (status != PJ_SUCCESS)
290+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
291+ }
292+
293+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
294+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
295+ tone.simple.index = TAPI_TONE_LOCALE_RING_CODE;
296+ tone.simple.freqA = 425;
297+ tone.simple.levelA = 0;
298+ tone.simple.cadence[0] = 1000;
299+ tone.simple.cadence[1] = 4000;
300+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
301+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
302+ tone.simple.loop = 0;
303+ tone.simple.pause = 0;
304+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
305+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
306+ if (status != PJ_SUCCESS)
307+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
308+ }
309+
310+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
311+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
312+ tone.simple.index = TAPI_TONE_LOCALE_WAITING_CODE;
313+ tone.simple.freqA = 425;
314+ tone.simple.levelA = 0;
315+ tone.simple.cadence[0] = 300;
316+ tone.simple.cadence[1] = 8000;
317+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
318+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
319+ tone.simple.loop = 0;
320+ tone.simple.pause = 0;
321+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
322+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
323+ if (status != PJ_SUCCESS)
324+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
325+ }
326+ } else if (!stricmp(country, "germany")) {
327+ PJ_LOG(3, (THIS_FILE, "using localized tones for Germany"));
328+
329+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
330+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
331+ tone.simple.index = TAPI_TONE_LOCALE_BUSY_CODE;
332+ tone.simple.freqA = 425;
333+ tone.simple.levelA = 0;
334+ tone.simple.cadence[0] = 480;
335+ tone.simple.cadence[1] = 480;
336+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
337+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
338+ tone.simple.loop = 0;
339+ tone.simple.pause = 0;
340+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
341+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
342+ if (status != PJ_SUCCESS)
343+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
344+ }
345+
346+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
347+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
348+ tone.simple.index = TAPI_TONE_LOCALE_CONGESTION_CODE;
349+ tone.simple.freqA = 425;
350+ tone.simple.levelA = 0;
351+ tone.simple.cadence[0] = 240;
352+ tone.simple.cadence[1] = 240;
353+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
354+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
355+ tone.simple.loop = 0;
356+ tone.simple.pause = 0;
357+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
358+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
359+ if (status != PJ_SUCCESS)
360+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
361+ }
362+
363+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
364+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
365+ tone.simple.index = TAPI_TONE_LOCALE_DIAL_CODE;
366+ tone.simple.freqA = 425;
367+ tone.simple.levelA = 0;
368+ tone.simple.cadence[0] = 1000;
369+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
370+ tone.simple.loop = 0;
371+ tone.simple.pause = 0;
372+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
373+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
374+ if (status != PJ_SUCCESS)
375+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
376+ }
377+
378+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
379+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
380+ tone.simple.index = TAPI_TONE_LOCALE_RING_CODE;
381+ tone.simple.freqA = 425;
382+ tone.simple.levelA = 0;
383+ tone.simple.cadence[0] = 1000;
384+ tone.simple.cadence[1] = 4000;
385+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
386+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
387+ tone.simple.loop = 0;
388+ tone.simple.pause = 0;
389+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
390+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
391+ if (status != PJ_SUCCESS)
392+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
393+ }
394+
395+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
396+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
397+ tone.simple.index = TAPI_TONE_LOCALE_WAITING_CODE;
398+ tone.simple.freqA = 425;
399+ tone.simple.levelA = 0;
400+ tone.simple.cadence[0] = 200;
401+ tone.simple.cadence[1] = 200;
402+ tone.simple.cadence[2] = 200;
403+ tone.simple.cadence[3] = 5000;
404+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA;
405+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
406+ tone.simple.frequencies[2] = IFX_TAPI_TONE_FREQA;
407+ tone.simple.frequencies[3] = IFX_TAPI_TONE_FREQNONE;
408+ tone.simple.loop = 0;
409+ tone.simple.pause = 0;
410+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
411+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
412+ if (status != PJ_SUCCESS)
413+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
414+ }
415+ }
416+}
417+
418+static pj_int32_t
419+tapi_dev_open(char* dev_path, const pj_int32_t ch_num)
420+{
421+ char devname[128] = { 0 };
422+ pj_ansi_sprintf(devname,"%s%u%u", dev_path, 1, ch_num);
423+ return open((const char*)devname, O_RDWR, 0644);
424+}
425+
426+static pj_status_t
427+tapi_dev_binary_buffer_create(const char *pPath, pj_uint8_t **ppBuf, pj_uint32_t *pBufSz)
428+{
429+ pj_status_t status = PJ_SUCCESS;
430+ FILE *fd;
431+ struct stat file_stat;
432+
433+ fd = fopen(pPath, "rb");
434+ if (fd == NULL) {
435+ TRACE_((THIS_FILE, "ERROR - binary file %s open failed!\n", pPath));
436+ return PJ_EUNKNOWN;
437+ }
438+
439+ if (stat(pPath, &file_stat) != 0) {
440+ TRACE_((THIS_FILE, "ERROR - file %s statistics get failed!\n", pPath));
441+ return PJ_EUNKNOWN;
442+ }
443+
444+ *ppBuf = malloc(file_stat.st_size);
445+ if (*ppBuf == NULL) {
446+ TRACE_((THIS_FILE, "ERROR - binary file %s memory allocation failed!\n", pPath));
447+ status = PJ_EUNKNOWN;
448+ goto on_exit;
449+ }
450+
451+ if (fread (*ppBuf, sizeof(pj_uint8_t), file_stat.st_size, fd) <= 0) {
452+ TRACE_((THIS_FILE, "ERROR - file %s read failed!\n", pPath));
453+ status = PJ_EUNKNOWN;
454+ goto on_exit;
455+ }
456+
457+ *pBufSz = file_stat.st_size;
458+
459+on_exit:
460+ if (fd != NULL)
461+ fclose(fd);
462+
463+ if (*ppBuf != NULL && status != PJ_SUCCESS)
464+ free(*ppBuf);
465+
466+ return status;
467+}
468+
469+static void
470+tapi_dev_binary_buffer_delete(pj_uint8_t *pBuf)
471+{
472+ if (pBuf != NULL)
473+ free(pBuf);
474+}
475+
476+static pj_status_t
477+tapi_dev_firmware_download(pj_int32_t fd, const char *pPath)
478+{
479+ pj_status_t status = PJ_SUCCESS;
480+ pj_uint8_t *pFirmware = NULL;
481+ pj_uint32_t binSz = 0;
482+ VMMC_IO_INIT vmmc_io_init;
483+
484+ status = tapi_dev_binary_buffer_create(pPath, &pFirmware, &binSz);
485+ if (status != PJ_SUCCESS) {
486+ TRACE_((THIS_FILE, "ERROR - binary buffer create failed!\n"));
487+ return PJ_EUNKNOWN;
488+ }
489+
490+ memset(&vmmc_io_init, 0, sizeof(VMMC_IO_INIT));
491+ vmmc_io_init.pPRAMfw = pFirmware;
492+ vmmc_io_init.pram_size = binSz;
493+
494+ status = ioctl(fd, FIO_FW_DOWNLOAD, &vmmc_io_init);
495+ if (status != PJ_SUCCESS)
496+ TRACE_((THIS_FILE, "ERROR - FIO_FW_DOWNLOAD ioctl failed!"));
497+
498+ tapi_dev_binary_buffer_delete(pFirmware);
499+
500+ return status;
501+}
502+
503+/* NOT USED */
504+#if 0
505+static int
506+tapi_dev_bbd_download(int fd, const char *pPath)
507+{
508+ int status = PJ_SUCCESS;
509+ unsigned char *pFirmware = NULL;
510+ unsigned int binSz = 0;
511+ VMMC_DWLD_t bbd_data;
512+
513+
514+ /* Create binary buffer */
515+ status = tapi_dev_binary_buffer_create(pPath, &pFirmware, &binSz);
516+ if (status != PJ_SUCCESS) {
517+ TRACE_((THIS_FILE, "ERROR - binary buffer create failed!\n"));
518+ return status;
519+ }
520+
521+ /* Download Voice Firmware */
522+ memset(&bbd_data, 0, sizeof(VMMC_DWLD_t));
523+ bbd_data.buf = pFirmware;
524+ bbd_data.size = binSz;
525+
526+ status = ioctl(fd, FIO_BBD_DOWNLOAD, &bbd_data);
527+ if (status != PJ_SUCCESS) {
528+ TRACE_((THIS_FILE, "ERROR - FIO_BBD_DOWNLOAD failed!\n"));
529+ }
530+
531+ /* Delete binary buffer */
532+ tapi_dev_binary_buffer_delete(pFirmware);
533+
534+ return status;
535+}
536+#endif
537+
538+static pj_status_t tapi_dev_start(tapi_aud_factory_t *f)
539+{
540+ pj_uint8_t c, hook_status;
541+ IFX_TAPI_TONE_t tone;
542+ IFX_TAPI_DEV_START_CFG_t tapistart;
543+ IFX_TAPI_MAP_DATA_t datamap;
544+ IFX_TAPI_ENC_CFG_t enc_cfg;
545+ IFX_TAPI_LINE_VOLUME_t line_vol;
546+ IFX_TAPI_WLEC_CFG_t lec_cfg;
547+ IFX_TAPI_JB_CFG_t jb_cfg;
548+ IFX_TAPI_CID_CFG_t cid_cfg;
549+ pj_status_t status;
550+
551+ /* Open device */
552+ f->dev_ctx.dev_fd = tapi_dev_open(TAPI_LL_DEV_BASE_PATH, 0);
553+
554+ if (f->dev_ctx.dev_fd < 0) {
555+ TRACE_((THIS_FILE, "ERROR - TAPI device open failed!"));
556+ return PJ_EUNKNOWN;
557+ }
558+
559+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
560+ if (tapi_channel_revert)
561+ ch_fd[c] = f->dev_ctx.ch_fd[c] = tapi_dev_open(TAPI_LL_DEV_BASE_PATH, c + 1);
562+ else
563+ ch_fd[c] = f->dev_ctx.ch_fd[c] = tapi_dev_open(TAPI_LL_DEV_BASE_PATH, TAPI_AUDIO_PORT_NUM - c);
564+
565+ if (f->dev_ctx.dev_fd < 0) {
566+ TRACE_((THIS_FILE, "ERROR - TAPI channel%d open failed!", c));
567+ return PJ_EUNKNOWN;
568+ }
569+ if (tapi_channel_revert)
570+ f->dev_ctx.data2phone_map[c] = c & 0x1 ? 1 : 0;
571+ else
572+ f->dev_ctx.data2phone_map[c] = c & 0x1 ? 0 : 1;
573+ }
574+
575+ status = tapi_dev_firmware_download(f->dev_ctx.dev_fd, TAPI_LL_DEV_FIRMWARE_NAME);
576+ if (status != PJ_SUCCESS) {
577+ TRACE_((THIS_FILE, "ERROR - Voice Firmware Download failed!"));
578+ return PJ_EUNKNOWN;
579+ }
580+
581+ /* Download coefficients */
582+ /*
583+ status = tapi_dev_bbd_download(f->dev_ctx.dev_fd, TAPI_LL_BBD_NAME);
584+ if (status != PJ_SUCCESS) {
585+ TRACE_((THIS_FILE, "ERROR - Voice Coefficients Download failed!"));
586+ return PJ_EUNKNOWN;
587+ }
588+ */
589+
590+ memset(&tapistart, 0x0, sizeof(IFX_TAPI_DEV_START_CFG_t));
591+ tapistart.nMode = IFX_TAPI_INIT_MODE_VOICE_CODER;
592+
593+ /* Start TAPI */
594+ status = ioctl(f->dev_ctx.dev_fd, IFX_TAPI_DEV_START, &tapistart);
595+ if (status != PJ_SUCCESS) {
596+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_DEV_START ioctl failed"));
597+ return PJ_EUNKNOWN;
598+ }
599+
600+
601+ /* OpenWrt default tone */
602+ memset(&tone, 0, sizeof(IFX_TAPI_TONE_t));
603+ tone.simple.format = IFX_TAPI_TONE_TYPE_SIMPLE;
604+ tone.simple.index = TAPI_TONE_LOCALE_NONE;
605+ tone.simple.freqA = 400;
606+ tone.simple.levelA = 0;
607+ tone.simple.freqB = 450;
608+ tone.simple.levelB = 0;
609+ tone.simple.freqC = 550;
610+ tone.simple.levelC = 0;
611+ tone.simple.freqD = 600;
612+ tone.simple.levelD = 0;
613+ tone.simple.cadence[0] = 100;
614+ tone.simple.cadence[1] = 150;
615+ tone.simple.cadence[2] = 100;
616+ tone.simple.cadence[3] = 150;
617+ tone.simple.frequencies[0] = IFX_TAPI_TONE_FREQA | IFX_TAPI_TONE_FREQB;
618+ tone.simple.frequencies[1] = IFX_TAPI_TONE_FREQNONE;
619+ tone.simple.frequencies[2] = IFX_TAPI_TONE_FREQC | IFX_TAPI_TONE_FREQD;
620+ tone.simple.frequencies[3] = IFX_TAPI_TONE_FREQNONE;
621+ tone.simple.loop = 0;
622+ tone.simple.pause = 0;
623+ for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
624+ /* OpenWrt default tone */
625+ status = ioctl(ch_fd[c], IFX_TAPI_TONE_TABLE_CFG_SET, &tone);
626+ if (status != PJ_SUCCESS)
627+ TRACE_((THIS_FILE, "IFX_TAPI_TONE_TABLE_CFG_SET failed!\n"));
628+
629+ /* Perform mapping */
630+ memset(&datamap, 0x0, sizeof(IFX_TAPI_MAP_DATA_t));
631+ datamap.nDstCh = f->dev_ctx.data2phone_map[c];
632+ datamap.nChType = IFX_TAPI_MAP_TYPE_PHONE;
633+
634+ status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_MAP_DATA_ADD, &datamap);
635+ if (status != PJ_SUCCESS) {
636+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_MAP_DATA_ADD ioctl failed"));
637+ return PJ_EUNKNOWN;
638+ }
639+
640+ /* Set Line feed */
641+ status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_LINE_FEED_SET, IFX_TAPI_LINE_FEED_STANDBY);
642+ if (status != PJ_SUCCESS) {
643+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed"));
644+ return PJ_EUNKNOWN;
645+ }
646+
647+ /* Configure encoder for linear stream */
648+ memset(&enc_cfg, 0x0, sizeof(IFX_TAPI_ENC_CFG_t));
649+ enc_cfg.nFrameLen = IFX_TAPI_COD_LENGTH_20;
650+ enc_cfg.nEncType = IFX_TAPI_COD_TYPE_LIN16_8;
651+
652+ status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_ENC_CFG_SET, &enc_cfg);
653+ if (status != PJ_SUCCESS) {
654+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_ENC_CFG_SET ioctl failed"));
655+ return PJ_EUNKNOWN;
656+ }
657+
658+ /* Suppress TAPI volume, otherwise PJSIP starts autogeneration */
659+ memset(&line_vol, 0, sizeof(line_vol));
660+ line_vol.nGainRx = -8;
661+ line_vol.nGainTx = -8;
662+
663+ status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_PHONE_VOLUME_SET, &line_vol);
664+ if (status != PJ_SUCCESS) {
665+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_PHONE_VOLUME_SET ioctl failed"));
666+ return PJ_EUNKNOWN;
667+ }
668+
669+ /* Configure line echo canceller */
670+ memset(&lec_cfg, 0, sizeof(lec_cfg));
671+ lec_cfg.nType = IFX_TAPI_WLEC_TYPE_NFE;
672+ lec_cfg.bNlp = IFX_TAPI_LEC_NLP_OFF;
673+
674+ status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_WLEC_PHONE_CFG_SET, &lec_cfg);
675+ if (status != PJ_SUCCESS) {
676+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_WLEC_PHONE_CFG_SET ioctl failed"));
677+ return PJ_EUNKNOWN;
678+ }
679+
680+ /* Configure jitter buffer */
681+ memset(&jb_cfg, 0, sizeof(jb_cfg));
682+ jb_cfg.nJbType = IFX_TAPI_JB_TYPE_ADAPTIVE;
683+ jb_cfg.nPckAdpt = IFX_TAPI_JB_PKT_ADAPT_VOICE;
684+ jb_cfg.nLocalAdpt = IFX_TAPI_JB_LOCAL_ADAPT_ON;
685+ jb_cfg.nScaling = 0x10;
686+ jb_cfg.nInitialSize = 0x2d0;
687+ jb_cfg.nMinSize = 0x50;
688+ jb_cfg.nMaxSize = 0x5a0;
689+
690+ status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_JB_CFG_SET, &jb_cfg);
691+ if (status != PJ_SUCCESS) {
692+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_JB_CFG_SET ioctl failed"));
693+ return PJ_EUNKNOWN;
694+ }
695+
696+ /* Configure Caller ID type */
697+ if (tapi_cid_type) {
698+ memset(&cid_cfg, 0, sizeof(cid_cfg));
699+ cid_cfg.nStandard = tapi_cid_type;
700+ status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_CID_CFG_SET, &cid_cfg);
701+ if (status != PJ_SUCCESS) {
702+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_CID_CFG_SET ioctl failed"));
703+ return PJ_EUNKNOWN;
704+ }
705+ }
706+
707+ /* check hook status */
708+ hook_status = 0;
709+ status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_LINE_HOOK_STATUS_GET, &hook_status);
710+ if (status != PJ_SUCCESS) {
711+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_HOOK_STATUS_GET ioctl failed!"));
712+ return PJ_EUNKNOWN;
713+ }
714+
715+ /* if off hook do initialization */
716+ if (hook_status) {
717+ status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_LINE_FEED_SET, IFX_TAPI_LINE_FEED_ACTIVE);
718+ if (status != PJ_SUCCESS) {
719+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed!"));
720+ return PJ_EUNKNOWN;
721+ }
722+ status = ioctl(c, IFX_TAPI_ENC_START, 0);
723+ if (status != PJ_SUCCESS) {
724+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_ENC_START ioctl failed!"));
725+ return PJ_EUNKNOWN;
726+ }
727+
728+ status = ioctl(c, IFX_TAPI_DEC_START, 0);
729+ if (status != PJ_SUCCESS) {
730+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_DEC_START ioctl failed!"));
731+ return PJ_EUNKNOWN;
732+ }
733+ }
734+ }
735+
736+ return status;
737+}
738+
739+static pj_status_t
740+tapi_dev_stop(tapi_aud_factory_t *f)
741+{
742+ pj_status_t status = PJ_SUCCESS;
743+ pj_uint8_t c;
744+
745+ if (ioctl(f->dev_ctx.dev_fd, IFX_TAPI_DEV_STOP, 0) != PJ_SUCCESS) {
746+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_DEV_STOP ioctl failed"));
747+ status = PJ_EUNKNOWN;
748+ }
749+
750+ close(f->dev_ctx.dev_fd);
751+ for (c = TAPI_AUDIO_PORT_NUM; c > 0; c--)
752+ close(f->dev_ctx.ch_fd[TAPI_AUDIO_PORT_NUM-c]);
753+
754+ return status;
755+}
756+
757+static pj_status_t
758+tapi_dev_codec_control(pj_int32_t fd, pj_uint8_t start)
759+{
760+ if (ioctl(fd, start ? IFX_TAPI_ENC_START : IFX_TAPI_ENC_STOP, 0) != PJ_SUCCESS) {
761+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_ENC_%s ioctl failed!",
762+ start ? "START" : "STOP"));
763+ return PJ_EUNKNOWN;
764+ }
765+
766+ if (ioctl(fd, start ? IFX_TAPI_DEC_START : IFX_TAPI_DEC_STOP, 0) != IFX_SUCCESS) {
767+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_DEC_%s ioctl failed!",
768+ start ? "START" : "STOP"));
769+ return PJ_EUNKNOWN;
770+ }
771+
772+ return PJ_SUCCESS;
773+}
774+
775+static pj_status_t tapi_dev_event_on_hook(tapi_ctx *dev_ctx, pj_uint32_t dev_idx)
776+{
777+ PJ_LOG(1,(THIS_FILE, "TAPI: ONHOOK"));
778+
779+ if (ioctl(dev_ctx->ch_fd[dev_idx], IFX_TAPI_LINE_FEED_SET,
780+ IFX_TAPI_LINE_FEED_STANDBY) != PJ_SUCCESS) {
781+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed!"));
782+ return PJ_EUNKNOWN;
783+ }
784+
785+ /* enc/dec stop */
786+ if (tapi_dev_codec_control(dev_ctx->ch_fd[dev_idx], 0) != PJ_SUCCESS) {
787+ TRACE_((THIS_FILE, "ERROR - codec start failed!"));
788+ return PJ_EUNKNOWN;
789+ }
790+
791+ return PJ_SUCCESS;
792+}
793+
794+static pj_status_t tapi_dev_event_off_hook(tapi_ctx *dev_ctx, pj_uint32_t dev_idx)
795+{
796+ PJ_LOG(1,(THIS_FILE, "TAPI: OFFHOOK"));
797+
798+ if (ioctl(dev_ctx->ch_fd[dev_idx], IFX_TAPI_LINE_FEED_SET,
799+ IFX_TAPI_LINE_FEED_ACTIVE) != PJ_SUCCESS) {
800+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed!"));
801+ return PJ_EUNKNOWN;
802+ }
803+
804+ /* enc/dec stop */
805+ if (tapi_dev_codec_control(dev_ctx->ch_fd[dev_idx], 1) != PJ_SUCCESS) {
806+ TRACE_((THIS_FILE, "ERROR - codec start failed!"));
807+ return PJ_EUNKNOWN;
808+ }
809+
810+ return PJ_SUCCESS;
811+}
812+
813+static pj_status_t
814+tapi_dev_event_digit(tapi_ctx *dev_ctx, pj_uint32_t dev_idx)
815+{
816+ PJ_LOG(1,(THIS_FILE, "TAPI: OFFHOOK"));
817+
818+ if (ioctl(dev_ctx->ch_fd[dev_idx], IFX_TAPI_LINE_FEED_SET,
819+ IFX_TAPI_LINE_FEED_ACTIVE) != PJ_SUCCESS) {
820+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed!"));
821+ return PJ_EUNKNOWN;
822+ }
823+
824+ /* enc/dec stop */
825+ if (tapi_dev_codec_control(dev_ctx->ch_fd[dev_idx], 1) != PJ_SUCCESS) {
826+ TRACE_((THIS_FILE, "ERROR - codec start failed!"));
827+ return PJ_EUNKNOWN;
828+ }
829+
830+ return PJ_SUCCESS;
831+}
832+
833+static pj_status_t
834+tapi_dev_event_handler(tapi_aud_stream_t *stream)
835+{
836+ IFX_TAPI_EVENT_t tapiEvent;
837+ tapi_ctx *dev_ctx = stream->dev_ctx;
838+ pj_status_t status = PJ_SUCCESS;
839+ unsigned int i;
840+
841+ for (i = 0; i < TAPI_AUDIO_PORT_NUM; i++) {
842+ memset (&tapiEvent, 0, sizeof(tapiEvent));
843+ tapiEvent.ch = dev_ctx->data2phone_map[i];
844+ status = ioctl(dev_ctx->dev_fd, IFX_TAPI_EVENT_GET, &tapiEvent);
845+
846+ if ((status == PJ_SUCCESS) && (tapiEvent.id != IFX_TAPI_EVENT_NONE)) {
847+ switch(tapiEvent.id) {
848+ case IFX_TAPI_EVENT_FXS_ONHOOK:
849+ status = tapi_dev_event_on_hook(dev_ctx, i);
850+ if(tapi_hook_callback)
851+ tapi_hook_callback(i, 0);
852+ break;
853+ case IFX_TAPI_EVENT_FXS_OFFHOOK:
854+ status = tapi_dev_event_off_hook(dev_ctx, i);
855+ if(tapi_hook_callback)
856+ tapi_hook_callback(i, 1);
857+ break;
858+ case IFX_TAPI_EVENT_DTMF_DIGIT:
859+ if(tapi_digit_callback)
860+ tapi_digit_callback(i, tapiEvent.data.dtmf.ascii);
861+ break;
862+ case IFX_TAPI_EVENT_PULSE_DIGIT:
863+ if(tapi_digit_callback)
864+ if(tapiEvent.data.pulse.digit == 0xB)
865+ tapi_digit_callback(i, '0');
866+ else
867+ tapi_digit_callback(i, '0' + tapiEvent.data.pulse.digit);
868+ break;
869+ case IFX_TAPI_EVENT_COD_DEC_CHG:
870+ case IFX_TAPI_EVENT_TONE_GEN_END:
871+ case IFX_TAPI_EVENT_CID_TX_SEQ_END:
872+ break;
873+ default:
874+ PJ_LOG(1,(THIS_FILE, "unknown tapi event %08X", tapiEvent.id));
875+ break;
876+ }
877+ }
878+ }
879+
880+ return status;
881+}
882+
883+static pj_status_t
884+tapi_dev_data_handler(tapi_aud_stream_t *stream) {
885+ pj_status_t status = PJ_SUCCESS;
886+ tapi_ctx *dev_ctx = stream->dev_ctx;
887+ pj_uint32_t dev_idx = stream->param.rec_id;
888+ pj_uint8_t buf_rec[TAPI_LL_DEV_ENC_BYTES_PER_FRAME + TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE]={0};
889+ pj_uint8_t buf_play[TAPI_LL_DEV_ENC_BYTES_PER_FRAME + TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE]={0};
890+ pjmedia_frame frame_rec, frame_play;
891+ pj_int32_t ret;
892+
893+ /* Get data from driver */
894+ ret = read(dev_ctx->ch_fd[dev_idx], buf_rec, sizeof(buf_rec));
895+ if (ret < 0) {
896+ TRACE_((THIS_FILE, "ERROR - no data available from device!"));
897+ return PJ_EUNKNOWN;
898+ }
899+
900+ if (ret > 0) {
901+ frame_rec.type = PJMEDIA_FRAME_TYPE_AUDIO;
902+ frame_rec.buf = buf_rec + TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE;
903+ frame_rec.size = ret - TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE;
904+ frame_rec.timestamp.u64 = stream->timestamp.u64;
905+
906+ status = stream->rec_cb(stream->user_data, &frame_rec);
907+ if (status != PJ_SUCCESS)
908+ PJ_LOG(1, (THIS_FILE, "rec_cb() failed %d", status));
909+
910+ frame_play.type = PJMEDIA_FRAME_TYPE_AUDIO;
911+ frame_play.buf = buf_play + TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE;
912+ frame_play.size = TAPI_LL_DEV_ENC_BYTES_PER_FRAME;
913+ frame_play.timestamp.u64 = stream->timestamp.u64;
914+
915+ status = (*stream->play_cb)(stream->user_data, &frame_play);
916+ if (status != PJ_SUCCESS) {
917+ PJ_LOG(1, (THIS_FILE, "play_cb() failed %d", status));
918+ } else {
919+ memcpy(buf_play, buf_rec, TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE);
920+
921+ ret = write(dev_ctx->ch_fd[dev_idx], buf_play, sizeof(buf_play));
922+
923+ if (ret < 0) {
924+ PJ_LOG(1, (THIS_FILE, "ERROR - device data writing failed!"));
925+ return PJ_EUNKNOWN;
926+ }
927+
928+ if (ret == 0) {
929+ PJ_LOG(1, (THIS_FILE, "ERROR - no data written to device!"));
930+ return PJ_EUNKNOWN;
931+ }
932+ }
933+
934+ stream->timestamp.u64 += TAPI_LL_DEV_ENC_SMPL_PER_FRAME;
935+ }
936+
937+ return PJ_SUCCESS;
938+}
939+
940+static int
941+PJ_THREAD_FUNC tapi_dev_thread(void *arg) {
942+ tapi_ctx *dev_ctx = streams[0].dev_ctx;
943+ pj_uint32_t sretval;
944+ struct pollfd fds[3];
945+
946+ PJ_LOG(1,(THIS_FILE, "TAPI: thread starting..."));
947+
948+ streams[0].run_flag = 1;
949+ streams[1].run_flag = 1;
950+
951+ fds[0].fd = dev_ctx->dev_fd;
952+ fds[0].events = POLLIN;
953+ fds[1].fd = dev_ctx->ch_fd[0];
954+ fds[1].events = POLLIN;
955+ fds[2].fd = dev_ctx->ch_fd[1];
956+ fds[2].events = POLLIN;
957+
958+ while(1)
959+ {
960+ sretval = poll(fds, TAPI_AUDIO_PORT_NUM + 1, TAPI_LL_DEV_SELECT_TIMEOUT_MS);
961+
962+ if (!streams[0].run_flag && !streams[0].run_flag)
963+ break;
964+ if (sretval <= 0)
965+ continue;
966+
967+ if (fds[0].revents == POLLIN) {
968+ if (tapi_dev_event_handler(&streams[0]) != PJ_SUCCESS) {
969+ PJ_LOG(1, (THIS_FILE, "TAPI: event hanldler failed"));
970+ break;
971+ }
972+ }
973+
974+ if (fds[1].revents == POLLIN) {
975+ if (tapi_dev_data_handler(&streams[0]) != PJ_SUCCESS) {
976+ PJ_LOG(1, (THIS_FILE, "TAPI: data hanldler failed"));
977+ break;
978+ }
979+ }
980+
981+ if (fds[2].revents == POLLIN) {
982+ if (tapi_dev_data_handler(&streams[1]) != PJ_SUCCESS) {
983+ PJ_LOG(1, (THIS_FILE, "TAPI: data hanldler failed"));
984+ break;
985+ }
986+ }
987+ }
988+ PJ_LOG(1, (THIS_FILE, "TAPI: thread stopping..."));
989+
990+ return 0;
991+}
992+
993+/* Factory operations */
994+
995+pjmedia_aud_dev_factory*
996+pjmedia_tapi_factory(pj_pool_factory *pf) {
997+ struct tapi_aud_factory *f;
998+ pj_pool_t *pool;
999+
1000+ TRACE_((THIS_FILE, "pjmedia_tapi_factory()"));
1001+
1002+ pool = pj_pool_create(pf, "tapi", 512, 512, NULL);
1003+ f = PJ_POOL_ZALLOC_T(pool, struct tapi_aud_factory);
1004+ f->pf = pf;
1005+ f->pool = pool;
1006+ f->base.op = &tapi_fact_op;
1007+
1008+ return &f->base;
1009+}
1010+
1011+static pj_status_t
1012+factory_init(pjmedia_aud_dev_factory *f)
1013+{
1014+ struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
1015+ pj_uint8_t i;
1016+
1017+ TRACE_((THIS_FILE, "factory_init()"));
1018+
1019+ af->dev_count = TAPI_AUDIO_PORT_NUM;
1020+ af->dev_info = (pjmedia_aud_dev_info*)
1021+ pj_pool_calloc(af->pool, af->dev_count, sizeof(pjmedia_aud_dev_info));
1022+ for (i = 0; i < TAPI_AUDIO_PORT_NUM; i++) {
1023+ pj_ansi_sprintf(af->dev_info[i].name,"%s_%02d", TAPI_BASE_NAME, i);
1024+ af->dev_info[i].input_count = af->dev_info[i].output_count = 1;
1025+ af->dev_info[i].default_samples_per_sec = TAPI_LL_DEV_ENC_SMPL_PER_SEC;
1026+ pj_ansi_strcpy(af->dev_info[i].driver, "/dev/vmmc");
1027+ af->dev_info[i].caps = PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING |
1028+ PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY |
1029+ PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY;
1030+ af->dev_info[i].routes = PJMEDIA_AUD_DEV_ROUTE_DEFAULT ;
1031+ }
1032+ if (tapi_dev_start(af) != PJ_SUCCESS) {
1033+ TRACE_((THIS_FILE, "ERROR - TAPI device init failed!"));
1034+ return PJ_EUNKNOWN;
1035+ }
1036+
1037+ return PJ_SUCCESS;
1038+}
1039+
1040+static pj_status_t
1041+factory_destroy(pjmedia_aud_dev_factory *f)
1042+{
1043+ struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
1044+ pj_pool_t *pool;
1045+ pj_status_t status = PJ_SUCCESS;
1046+
1047+ TRACE_((THIS_FILE, "factory_destroy()"));
1048+
1049+ if (tapi_dev_stop(af) != PJ_SUCCESS) {
1050+ TRACE_((THIS_FILE, "ERROR - TAPI device stop failed!"));
1051+ status = PJ_EUNKNOWN;
1052+ }
1053+ pool = af->pool;
1054+ af->pool = NULL;
1055+ pj_pool_release(pool);
1056+
1057+ return status;
1058+}
1059+
1060+static unsigned
1061+factory_get_dev_count(pjmedia_aud_dev_factory *f)
1062+{
1063+ struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
1064+ TRACE_((THIS_FILE, "factory_get_dev_count()"));
1065+
1066+ return af->dev_count;
1067+}
1068+
1069+static pj_status_t
1070+factory_get_dev_info(pjmedia_aud_dev_factory *f, unsigned index, pjmedia_aud_dev_info *info)
1071+{
1072+ struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
1073+
1074+ TRACE_((THIS_FILE, "factory_get_dev_info()"));
1075+ PJ_ASSERT_RETURN(index < af->dev_count, PJMEDIA_EAUD_INVDEV);
1076+
1077+ pj_memcpy(info, &af->dev_info[index], sizeof(*info));
1078+
1079+ return PJ_SUCCESS;
1080+}
1081+
1082+static pj_status_t
1083+factory_default_param(pjmedia_aud_dev_factory *f, unsigned index, pjmedia_aud_param *param)
1084+{
1085+ struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
1086+ struct pjmedia_aud_dev_info *di = &af->dev_info[index];
1087+
1088+ TRACE_((THIS_FILE, "factory_default_param."));
1089+ PJ_ASSERT_RETURN(index < af->dev_count, PJMEDIA_EAUD_INVDEV);
1090+
1091+ pj_bzero(param, sizeof(*param));
1092+ if (di->input_count && di->output_count) {
1093+ param->dir = PJMEDIA_DIR_CAPTURE_PLAYBACK;
1094+ param->rec_id = index;
1095+ param->play_id = index;
1096+ } else if (di->input_count) {
1097+ param->dir = PJMEDIA_DIR_CAPTURE;
1098+ param->rec_id = index;
1099+ param->play_id = PJMEDIA_AUD_INVALID_DEV;
1100+ } else if (di->output_count) {
1101+ param->dir = PJMEDIA_DIR_PLAYBACK;
1102+ param->play_id = index;
1103+ param->rec_id = PJMEDIA_AUD_INVALID_DEV;
1104+ } else {
1105+ return PJMEDIA_EAUD_INVDEV;
1106+ }
1107+
1108+ param->clock_rate = TAPI_LL_DEV_ENC_SMPL_PER_SEC; //di->default_samples_per_sec;
1109+ param->channel_count = 1;
1110+ param->samples_per_frame = TAPI_LL_DEV_ENC_SMPL_PER_FRAME;
1111+ param->bits_per_sample = TAPI_LL_DEV_ENC_BITS_PER_SMPLS;
1112+ param->flags = PJMEDIA_AUD_DEV_CAP_OUTPUT_ROUTE | di->caps;
1113+ param->output_route = PJMEDIA_AUD_DEV_ROUTE_DEFAULT;
1114+
1115+ return PJ_SUCCESS;
1116+}
1117+
1118+
1119+static pj_status_t
1120+factory_create_stream(pjmedia_aud_dev_factory *f, const pjmedia_aud_param *param,
1121+ pjmedia_aud_rec_cb rec_cb, pjmedia_aud_play_cb play_cb,
1122+ void *user_data, pjmedia_aud_stream **p_aud_strm)
1123+{
1124+ struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
1125+ pj_pool_t *pool;
1126+ pj_status_t status;
1127+ int id = param->rec_id;
1128+ struct tapi_aud_stream *strm = &streams[param->rec_id];
1129+ TRACE_((THIS_FILE, "factory_create_stream() rec_id:%d play_id:%d", param->rec_id, param->play_id));
1130+
1131+ /* Can only support 16bits per sample */
1132+ PJ_ASSERT_RETURN(param->bits_per_sample == TAPI_LL_DEV_ENC_BITS_PER_SMPLS, PJ_EINVAL);
1133+ PJ_ASSERT_RETURN(param->clock_rate == TAPI_LL_DEV_ENC_SMPL_PER_SEC, PJ_EINVAL);
1134+ PJ_ASSERT_RETURN(param->samples_per_frame == TAPI_LL_DEV_ENC_SMPL_PER_FRAME, PJ_EINVAL);
1135+
1136+ /* Can only support bidirectional stream */
1137+ PJ_ASSERT_RETURN(param->dir & PJMEDIA_DIR_CAPTURE_PLAYBACK, PJ_EINVAL);
1138+
1139+ if (id == 0) {
1140+ /* Initialize our stream data */
1141+ pool = pj_pool_create(af->pf, "tapi-dev", 1000, 1000, NULL);
1142+ PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
1143+
1144+ strm->pool = pool;
1145+ } else {
1146+ pool = strm->pool = streams[0].pool;
1147+ }
1148+
1149+ strm->rec_cb = rec_cb;
1150+ strm->play_cb = play_cb;
1151+ strm->user_data = user_data;
1152+
1153+ pj_memcpy(&strm->param, param, sizeof(*param));
1154+
1155+ if ((strm->param.flags & PJMEDIA_AUD_DEV_CAP_EXT_FORMAT) == 0) {
1156+ strm->param.ext_fmt.id = PJMEDIA_FORMAT_L16;
1157+ }
1158+
1159+ strm->timestamp.u64 = 0;
1160+ strm->dev_ctx = &(af->dev_ctx);
1161+
1162+ /* Create and start the thread */
1163+ if (id == 1) {
1164+ status = pj_thread_create(pool, "tapi", &tapi_dev_thread, strm, 0, 0, &streams[0].thread);
1165+ if (status != PJ_SUCCESS) {
1166+ stream_destroy(&strm->base);
1167+ return status;
1168+ }
1169+ }
1170+
1171+ /* Done */
1172+ strm->base.op = &tapi_strm_op;
1173+ *p_aud_strm = &strm->base;
1174+
1175+ return PJ_SUCCESS;
1176+}
1177+
1178+static pj_status_t
1179+stream_get_param(pjmedia_aud_stream *s, pjmedia_aud_param *pi)
1180+{
1181+ struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
1182+
1183+ PJ_ASSERT_RETURN(strm && pi, PJ_EINVAL);
1184+ pj_memcpy(pi, &strm->param, sizeof(*pi));
1185+
1186+ if (stream_get_cap(s, PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING,
1187+ &pi->output_vol) == PJ_SUCCESS)
1188+ pi->flags |= PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING;
1189+
1190+ if (stream_get_cap(s, PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY,
1191+ &pi->output_latency_ms) == PJ_SUCCESS)
1192+ pi->flags |= PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY;
1193+
1194+ if (stream_get_cap(s, PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY,
1195+ &pi->input_latency_ms) == PJ_SUCCESS)
1196+ pi->flags |= PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY;
1197+
1198+ return PJ_SUCCESS;
1199+}
1200+
1201+static pj_status_t
1202+stream_get_cap(pjmedia_aud_stream *s, pjmedia_aud_dev_cap cap, void *pval)
1203+{
1204+ // struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
1205+ return PJ_SUCCESS;
1206+}
1207+
1208+static pj_status_t
1209+stream_set_cap(pjmedia_aud_stream *s, pjmedia_aud_dev_cap cap, const void *pval)
1210+{
1211+ // struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
1212+ return PJ_SUCCESS;
1213+}
1214+
1215+static pj_status_t
1216+stream_start(pjmedia_aud_stream *s)
1217+{
1218+ struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
1219+ pj_uint32_t dev_idx;
1220+
1221+ TRACE_((THIS_FILE, "stream_start()"));
1222+
1223+ dev_idx = strm->param.rec_id;
1224+
1225+ return PJ_SUCCESS;
1226+}
1227+
1228+static pj_status_t
1229+stream_stop(pjmedia_aud_stream *s)
1230+{
1231+ struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
1232+ tapi_ctx *dev_ctx = strm->dev_ctx;
1233+ pj_uint32_t dev_idx;
1234+
1235+ TRACE_((THIS_FILE, "stream_stop()"));
1236+ dev_idx = strm->param.rec_id;
1237+
1238+ if (tapi_dev_codec_control(dev_ctx->ch_fd[dev_idx], 0) != PJ_SUCCESS) {
1239+ TRACE_((THIS_FILE, "ERROR - codec start failed!"));
1240+ return PJ_EUNKNOWN;
1241+ }
1242+
1243+ return PJ_SUCCESS;
1244+}
1245+
1246+static pj_status_t
1247+stream_destroy(pjmedia_aud_stream *s)
1248+{
1249+ pj_status_t state = PJ_SUCCESS;
1250+ struct tapi_aud_stream *stream = (struct tapi_aud_stream*)s;
1251+ pj_pool_t *pool;
1252+
1253+ PJ_ASSERT_RETURN(stream != NULL, PJ_EINVAL);
1254+ TRACE_((THIS_FILE, "stream_destroy()"));
1255+
1256+ stream_stop(&stream->base);
1257+ stream->run_flag = 0;
1258+
1259+ if (stream->thread)
1260+ {
1261+ pj_thread_join(stream->thread);
1262+ pj_thread_destroy(stream->thread);
1263+ stream->thread = NULL;
1264+ }
1265+
1266+ pool = stream->pool;
1267+ pj_bzero(stream, sizeof(stream));
1268+ pj_pool_release(pool);
1269+
1270+ return state;
1271+}
1272+
1273+pj_status_t
1274+tapi_hook_status(pj_uint8_t port, pj_int32_t *status)
1275+{
1276+ PJ_ASSERT_RETURN(port < TAPI_AUDIO_PORT_NUM, PJ_EINVAL);
1277+
1278+ if (ioctl(ch_fd[port], IFX_TAPI_LINE_HOOK_STATUS_GET, status)
1279+ != PJ_SUCCESS) {
1280+ TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_HOOK_STATUS_GET ioctl failed!"));
1281+ return PJ_EUNKNOWN;
1282+ }
1283+
1284+ return PJ_SUCCESS;
1285+}
1286+
1287+pj_status_t
1288+tapi_ring(pj_uint8_t port, pj_uint8_t state, char *caller_number)
1289+{
1290+ PJ_ASSERT_RETURN(port < TAPI_AUDIO_PORT_NUM, PJ_EINVAL);
1291+
1292+ if (state) {
1293+ if (tapi_cid_type && caller_number) {
1294+ IFX_TAPI_CID_MSG_t cid_msg;
1295+ IFX_TAPI_CID_MSG_ELEMENT_t cid_msg_el[1];
1296+ memset(&cid_msg, 0, sizeof(cid_msg));
1297+ memset(&cid_msg_el, 0, sizeof(cid_msg_el));
1298+
1299+ cid_msg_el[0].string.elementType = IFX_TAPI_CID_ST_CLI;
1300+ cid_msg_el[0].string.len = strlen(caller_number);
1301+ strncpy(cid_msg_el[0].string.element, caller_number, sizeof(cid_msg_el[0].string.element));
1302+
1303+ cid_msg.txMode = IFX_TAPI_CID_HM_ONHOOK;
1304+ cid_msg.messageType = IFX_TAPI_CID_MT_CSUP;
1305+ cid_msg.nMsgElements = 1;
1306+ cid_msg.message = cid_msg_el;
1307+ ioctl(ch_fd[port], IFX_TAPI_CID_TX_SEQ_START, &cid_msg);
1308+ } else {
1309+ ioctl(ch_fd[port], IFX_TAPI_RING_START, 0);
1310+ }
1311+ } else {
1312+ ioctl(ch_fd[port], IFX_TAPI_RING_STOP, 0);
1313+ }
1314+
1315+ return PJ_SUCCESS;
1316+}
1317+
1318+pj_status_t
1319+tapi_tone(pj_uint8_t port, pj_uint8_t code)
1320+{
1321+ PJ_ASSERT_RETURN(port < TAPI_AUDIO_PORT_NUM, PJ_EINVAL);
1322+
1323+ if (tapi_locale && code)
1324+ ioctl(ch_fd[port], IFX_TAPI_TONE_LOCAL_PLAY, code);
1325+ else if (code)
1326+ ioctl(ch_fd[port], IFX_TAPI_TONE_LOCAL_PLAY, TAPI_TONE_LOCALE_NONE);
1327+ else
1328+ ioctl(ch_fd[port], IFX_TAPI_TONE_LOCAL_PLAY, 0);
1329+
1330+ return PJ_SUCCESS;
1331+}
1332+
1333+#endif /* PJMEDIA_AUDIO_DEV_HAS_TAPI_DEVICE */
1334

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive