retronetworking
/
wanpipe
13
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
wanpipe/edac/ed_asterisk_cvs.patch

897 lines
29 KiB
Diff
Raw Blame History

--- asterisk/channels/chan_zap.c.orig 2005-08-17 14:21:29.109149424 -0400
+++ asterisk/channels/chan_zap.c 2005-08-17 15:06:12.820163336 -0400
@@ -166,6 +166,138 @@
#define DCHAN_AVAILABLE (DCHAN_PROVISIONED | DCHAN_NOTINALARM | DCHAN_UP)
+
+////////////////////////////////////////////////////////////////////////
+
+#define TDMV_SAMPLE_STATE_DECODE(state) \
+ ((state == ECHO_PRESENT) ? "On" : \
+ (state == ECHO_ABSENT) ? "Off" : \
+ (state == INDETERMINATE) ? "?" : "Invalid")
+
+#define TMP_BUFF_LEN 512
+
+static unsigned short u2s[] = {
+ /* negative */
+0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84,
+0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684, 0xBA84, 0xBE84,
+0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84,
+0xD184, 0xD384, 0xD584, 0xD784, 0xD984, 0xDB84, 0xDD84, 0xDF84,
+0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804,
+0xE904, 0xEA04, 0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004,
+0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444,
+0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844,
+0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4, 0xFA24, 0xFA64,
+0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64,
+0xFC94, 0xFCB4, 0xFCD4, 0xFCF4, 0xFD14, 0xFD34, 0xFD54, 0xFD74,
+0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74,
+0xFE8C, 0xFE9C, 0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC,
+0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C,
+0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0,
+0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0, 0xFFF8, 0x0000,
+/* positive */
+0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C,
+0x5D7C, 0x597C, 0x557C, 0x517C, 0x4D7C, 0x497C, 0x457C, 0x417C,
+0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C,
+0x2E7C, 0x2C7C, 0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C,
+0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC,
+0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC,
+0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC, 0x0C3C, 0x0BBC,
+0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC,
+0x075C, 0x071C, 0x06DC, 0x069C, 0x065C, 0x061C, 0x05DC, 0x059C,
+0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C,
+0x036C, 0x034C, 0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C,
+0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C,
+0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104,
+0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4, 0x0094, 0x0084,
+0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040,
+0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000
+};
+
+#if 1
+//ZAPTEL table
+static unsigned short a2s[] = {
+
+0xEB00, 0xEC00, 0xE900, 0xEA00, 0xEF00, 0xF000, 0xED00, 0xEE00,
+0xE300, 0xE400, 0xE100, 0xE200, 0xE700, 0xE800, 0xE500, 0xE600,
+0xF580, 0xF600, 0xF480, 0xF500, 0xF780, 0xF800, 0xF680, 0xF700,
+0xF180, 0xF200, 0xF080, 0xF100, 0xF380, 0xF400, 0xF280, 0xF300,
+0xAC00, 0xB000, 0xA400, 0xA800, 0xBC00, 0xC000, 0xB400, 0xB800,
+0x8C00, 0x9000, 0x8400, 0x8800, 0x9C00, 0xA000, 0x9400, 0x9800,
+0xD600, 0xD800, 0xD200, 0xD400, 0xDE00, 0xE000, 0xDA00, 0xDC00,
+0xC600, 0xC800, 0xC200, 0xC400, 0xCE00, 0xD000, 0xCA00, 0xCC00,
+0xFEB0, 0xFEC0, 0xFE90, 0xFEA0, 0xFEF0, 0xFF00, 0xFED0, 0xFEE0,
+0xFE30, 0xFE40, 0xFE10, 0xFE20, 0xFE70, 0xFE80, 0xFE50, 0xFE60,
+0xFFB0, 0xFFC0, 0xFF90, 0xFFA0, 0xFFF0, 0x0000, 0xFFD0, 0xFFE0,
+0xFF30, 0xFF40, 0xFF10, 0xFF20, 0xFF70, 0xFF80, 0xFF50, 0xFF60,
+0xFAC0, 0xFB00, 0xFA40, 0xFA80, 0xFBC0, 0xFC00, 0xFB40, 0xFB80,
+0xF8C0, 0xF900, 0xF840, 0xF880, 0xF9C0, 0xFA00, 0xF940, 0xF980,
+0xFD60, 0xFD80, 0xFD20, 0xFD40, 0xFDE0, 0xFE00, 0xFDA0, 0xFDC0,
+0xFC60, 0xFC80, 0xFC20, 0xFC40, 0xFCE0, 0xFD00, 0xFCA0, 0xFCC0,
+
+0x1500, 0x1400, 0x1700, 0x1600, 0x1100, 0x1000, 0x1300, 0x1200,
+0x1D00, 0x1C00, 0x1F00, 0x1E00, 0x1900, 0x1800, 0x1B00, 0x1A00,
+0x0A80, 0x0A00, 0x0B80, 0x0B00, 0x0880, 0x0800, 0x0980, 0x0900,
+0x0E80, 0x0E00, 0x0F80, 0x0F00, 0x0C80, 0x0C00, 0x0D80, 0x0D00,
+0x5400, 0x5000, 0x5C00, 0x5800, 0x4400, 0x4000, 0x4C00, 0x4800,
+0x7400, 0x7000, 0x7C00, 0x7800, 0x6400, 0x6000, 0x6C00, 0x6800,
+0x2A00, 0x2800, 0x2E00, 0x2C00, 0x2200, 0x2000, 0x2600, 0x2400,
+0x3A00, 0x3800, 0x3E00, 0x3C00, 0x3200, 0x3000, 0x3600, 0x3400,
+0x0150, 0x0140, 0x0170, 0x0160, 0x0110, 0x0100, 0x0130, 0x0120,
+0x01D0, 0x01C0, 0x01F0, 0x01E0, 0x0190, 0x0180, 0x01B0, 0x01A0,
+0x0050, 0x0040, 0x0070, 0x0060, 0x0010, 0x0000, 0x0030, 0x0020,
+0x00D0, 0x00C0, 0x00F0, 0x00E0, 0x0090, 0x0080, 0x00B0, 0x00A0,
+0x0540, 0x0500, 0x05C0, 0x0580, 0x0440, 0x0400, 0x04C0, 0x0480,
+0x0740, 0x0700, 0x07C0, 0x0780, 0x0640, 0x0600, 0x06C0, 0x0680,
+0x02A0, 0x0280, 0x02E0, 0x02C0, 0x0220, 0x0200, 0x0260, 0x0240,
+0x03A0, 0x0380, 0x03E0, 0x03C0, 0x0320, 0x0300, 0x0360, 0x0340
+};
+#endif
+
+#if 0
+//YATE table
+static unsigned short a2s[] = {
+/* negative */
+0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80,
+0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780, 0xE480, 0xE580,
+0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0,
+0xF140, 0xF1C0, 0xF040, 0xF0C0, 0xF340, 0xF3C0, 0xF240, 0xF2C0,
+0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600,
+0x8A00, 0x8E00, 0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600,
+0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00,
+0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00,
+0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8, 0xFEC8, 0xFED8,
+0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58,
+0xFFA8, 0xFFB8, 0xFF88, 0xFF98, 0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8,
+0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58,
+0xFAA0, 0xFAE0, 0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60,
+0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960,
+0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0,
+0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0, 0xFC90, 0xFCB0,
+/* positive */
+0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280,
+0x1D80, 0x1C80, 0x1F80, 0x1E80, 0x1980, 0x1880, 0x1B80, 0x1A80,
+0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940,
+0x0EC0, 0x0E40, 0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40,
+0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00,
+0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00,
+0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100, 0x2700, 0x2500,
+0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500,
+0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128,
+0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8,
+0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028,
+0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8,
+0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0,
+0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620, 0x06E0, 0x06A0,
+0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250,
+0x03B0, 0x0390, 0x03F0, 0x03D0, 0x0330, 0x0310, 0x0370, 0x0350
+};
+#endif
+
+////////////////////////////////////////////////////////////////////////
+
+
+
+
static int cur_emdigitwait = 250; /* Wait time in ms for digits on EM channel */
static char context[AST_MAX_CONTEXT] = "default";
@@ -654,6 +786,13 @@
#endif
int polarity;
+ int echo_detection_state;
+ pthread_t polling_thread_id;
+ int is_call_active;
+ int ed_enabled;
+ unsigned int num_of_echo_absent_calls;
+ unsigned int num_of_echo_present_calls;
+
} *iflist = NULL, *ifend = NULL;
static struct ast_channel *zt_request(const char *type, int format, void *data, int *cause);
@@ -694,6 +833,32 @@
#define GET_CHANNEL(p) ((p)->channel)
#endif
+static int sangoma_get_echo_state(struct zt_pvt* pvt, echo_detect_struct_t * ioctl_result);
+static int sangoma_write_call_started_str(struct zt_pvt *pvt);
+static int sangoma_write_call_ended_str(struct zt_pvt *pvt);
+static char* sangoma_get_date_and_time(void);
+static void sangoma_ed_control(int fd, struct zt_pvt *tmp, int control_code);
+static void sangoma_linearize_spike_buffer(int fd, unsigned char *spike_buff, int *linearized_buff, int law);
+static int sangoma_write_spike_buffer_to_file(struct zt_pvt *pvt, int *linearized_buff, int fd);
+static int sangoma_write_buffer_to_file(char * full_file_path, char* string);
+static void sangoma_summary_of_linear_spike_buffer(int fd, int *linearized_buff, struct zt_pvt *tmp);
+static void sangoma_analyze_db_loss(int fd, struct zt_pvt *tmp);
+
+#define INITIAL_LINEAR_TX_SPIKE 16384
+#define NO 0
+#define YES 1
+#define DB_LOSS_THRESHOLD -45.00//-50.00//-60.00
+#define DB_SILENCE 80.00
+
+typedef struct{
+ float db_loss;
+ short linear_power_value;
+}db_sample_t;
+
+db_sample_t db_loss[SANGOMA_SPIKE_SAMPLE_LEN];
+
+void proc_sample(unsigned short, int);
+
struct zt_pvt *round_robin[32];
#ifdef ZAPATA_PRI
@@ -1364,6 +1529,12 @@
}
x = p->echocancel;
res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
+
+ if(p->ed_enabled == 1 && p->is_call_active == 0){
+ p->is_call_active = 1;
+ sangoma_write_call_started_str(p);
+ }
+
if (res)
ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d\n", p->channel);
else {
@@ -1394,9 +1565,42 @@
{
int x;
int res;
+
+ echo_detect_struct_t ioctl_result;
+ char log_str_buff[TMP_BUFF_LEN];
+ char log_file_name_buff[TMP_BUFF_LEN];
+
+
if (p->echocancel) {
x = 0;
res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
+
+ if(p->is_call_active == 1){
+ /* This function is called twice, without obvious reason,
+ but end of call should be recorded only once.
+ */
+ p->is_call_active = 0;
+
+ if(!sangoma_get_echo_state(p, &ioctl_result)){
+
+ snprintf(log_file_name_buff, TMP_BUFF_LEN,
+ "/etc/wanpipe/span_%d_chan_%d.log", p->span, p->channel);
+
+ //if(ioctl_result.echo_state != INDETERMINATE){
+ snprintf(log_str_buff, TMP_BUFF_LEN,
+ " %-3s ", TDMV_SAMPLE_STATE_DECODE(ioctl_result.echo_state));
+ sangoma_write_buffer_to_file(log_file_name_buff, log_str_buff);
+ //}
+
+ if(ioctl_result.echo_state == ECHO_ABSENT){
+ p->num_of_echo_absent_calls++;
+ }if(ioctl_result.echo_state == ECHO_PRESENT){
+ p->num_of_echo_present_calls++;
+ }
+ }//if()
+ sangoma_write_call_ended_str(p);
+ }//if(p->is_call_active == 1)
+
if (res)
ast_log(LOG_WARNING, "Unable to disable echo cancellation on channel %d\n", p->channel);
else
@@ -1446,11 +1650,167 @@
g.txgain[j] = j;
}
}
-
- /* set 'em */
+
+ /* set 'em */
return(ioctl(fd,ZT_SETGAINS,&g));
}
+int usecsleep(int sec, int usecs)
+{
+ struct timeval tv;
+
+ tv.tv_sec = sec;
+ tv.tv_usec = usecs;
+
+ return select(0, NULL, NULL, NULL, &tv);
+}
+
+static char* sangoma_get_date_and_time()
+{
+ struct timeval tv;
+ struct timezone tz;
+ time_t now;
+ static char tmp_str[TMP_BUFF_LEN];
+ int ind;
+
+ gettimeofday(&tv, &tz);
+ now = tv.tv_sec;
+
+ snprintf(tmp_str, TMP_BUFF_LEN, ctime(&now));
+ /* replace 'new line' with 'null' */
+ for(ind = 0; ind < TMP_BUFF_LEN; ind++){
+ if(tmp_str[ind] == '\n'){
+ tmp_str[ind] = '\0';
+ }
+ }
+
+ return tmp_str;
+}
+
+#define MAX_LOG_FILE_SIZE 500000 // 500 Kb is the maximum
+
+int sangoma_write_buffer_to_file(char * full_file_path, char* string)
+{
+ FILE * file;
+ struct stat statbuf;
+
+ file = fopen(full_file_path, "a");
+ if(file == NULL){
+ ast_log(LOG_WARNING, "Failed to open %s file for writing!\n", full_file_path);
+ return 1;
+ }
+
+ //file exist, let's make sure it's not too big
+ if(lstat(full_file_path, &statbuf)){
+ ast_log(LOG_WARNING, "Failed to get file size ! File: %s.\n", full_file_path);
+ return 2;
+ }
+
+ if(statbuf.st_size > MAX_LOG_FILE_SIZE){
+ ast_log(LOG_WARNING, "File %s reached maximum size!\n", full_file_path);
+ return 3;
+ }
+
+ fputs(string, file);
+ fclose(file);
+ return 0;
+}
+
+static int sangoma_write_spike_buffer_to_file(struct zt_pvt *pvt, int *linearized_buff, int fd)
+{
+ FILE *file;
+ int ind;
+ char strbuff[50];
+ char log_file_name_buff[TMP_BUFF_LEN];
+
+ snprintf(log_file_name_buff, TMP_BUFF_LEN,
+ "/etc/wanpipe/span_%d_chan_%d.spike", pvt->span, pvt->channel);
+
+ /* trancate and open the file for writing */
+ file = fopen(log_file_name_buff, "w");
+ if(file == NULL){
+ ast_log(LOG_WARNING, "Failed to open %s file for writing!\n", log_file_name_buff);
+ return 1;
+ }
+
+ for(ind = 0; ind < SANGOMA_SPIKE_SAMPLE_LEN; ind++){
+ snprintf(strbuff, 50, "%d\n", linearized_buff[ind]);
+ fputs(strbuff, file);
+ }/* for() */
+ fclose(file);
+
+ ast_cli(fd, "Echo spike was written to '%s' file.\n", log_file_name_buff);
+
+ return 0;
+}
+
+static int sangoma_do_echo_detect_ioctl(int zfd, int echo_detect_ioctl, int * ioctl_result)
+{
+ if (ioctl(zfd, echo_detect_ioctl, ioctl_result)){
+ perror("sangoma_do_echo_detect_ioctl():\n");
+ return 1;
+ }else{
+ return 0;
+ }
+}
+
+static int sangoma_get_echo_state(struct zt_pvt* pvt, echo_detect_struct_t* ioctl_result)
+{
+ if(pvt == NULL){
+ ast_log(LOG_WARNING, "%s():pvt is NULL!!!\n", __FUNCTION__);
+ return 1;
+ }
+
+// ast_log(LOG_WARNING, "span: %d, channel: %d\n", pvt->span, pvt->channel);
+// ast_log(LOG_WARNING, "zdf: %d\n", pvt->subs[SUB_REAL].zfd);
+
+ if(!sangoma_do_echo_detect_ioctl(pvt->subs[SUB_REAL].zfd, SANGOMA_GET_ED_STATE, (int*)ioctl_result)){
+ return 0;
+ }else{
+ return 3;
+ }
+}
+
+static int sangoma_write_call_started_str(struct zt_pvt *pvt)
+{
+ char log_str_buff[TMP_BUFF_LEN];
+ char log_file_name_buff[TMP_BUFF_LEN];
+
+ snprintf(log_file_name_buff, TMP_BUFF_LEN,
+ "/etc/wanpipe/span_%d_chan_%d.log", pvt->span, pvt->channel);
+
+ snprintf(log_str_buff, TMP_BUFF_LEN, "START: [%-24s]",
+ sangoma_get_date_and_time());
+ sangoma_write_buffer_to_file(log_file_name_buff, log_str_buff);
+
+ if(pvt->owner){
+ snprintf(log_str_buff, TMP_BUFF_LEN, "[exten:%s, callerid:%s]",
+ (pvt->owner->exten == NULL ? "----" : pvt->owner->exten),
+ (pvt->owner->callerid == NULL? "----" : pvt->owner->callerid));
+ }else{
+ snprintf(log_str_buff, TMP_BUFF_LEN, "[context:%s, exten:%s, callerid:%s]",
+ "----", "----", "----");
+ }
+
+ return sangoma_write_buffer_to_file(log_file_name_buff, log_str_buff);
+}
+
+static int sangoma_write_call_ended_str(struct zt_pvt *pvt)
+{
+ char log_str_buff[TMP_BUFF_LEN];
+ char log_file_name_buff[TMP_BUFF_LEN];
+
+ snprintf(log_file_name_buff, TMP_BUFF_LEN,
+ "/etc/wanpipe/span_%d_chan_%d.log", pvt->span, pvt->channel);
+
+ snprintf(log_str_buff, TMP_BUFF_LEN, "END: [%s][eabs:%u,epres:%u]\n",
+ sangoma_get_date_and_time(),
+ pvt->num_of_echo_absent_calls,
+ pvt->num_of_echo_present_calls);
+
+ return sangoma_write_buffer_to_file(log_file_name_buff, log_str_buff);
+}
+
static inline int zt_set_hook(int fd, int hs)
{
int x, res;
@@ -9442,6 +9802,382 @@
return RESULT_FAILURE;
}
+static int sangoma_show_channels_func(int fd, int argc, char **argv)
+{
+ struct zt_pvt *tmp = NULL;
+ ast_mutex_t *lock;
+ struct zt_pvt *start;
+ echo_detect_struct_t ioctl_result;
+ int active_chans_counter;
+
+ lock = &iflock;
+ start = iflist;
+
+ ast_mutex_lock(lock);
+ tmp = start;
+
+ ast_cli(fd, "\nSpan\tChannel\t\tEcho\tContext\t\tExtension\tCallerID\n");
+
+ active_chans_counter = 0;
+ while (tmp){
+ if(tmp->channel < 0 ||
+ sangoma_get_echo_state(tmp, &ioctl_result) ||
+ ioctl_result.echo_detection_state != ECHO_DETECT_ON){/* show only active channels*/
+ tmp = tmp->next;
+ continue;
+ }
+
+ active_chans_counter++;
+
+ ast_cli(fd, "%02d\t%02d\t\t%-5s\t%-10s\t%-10s\t%-10s\n",
+ tmp->span,
+ tmp->channel,
+ TDMV_SAMPLE_STATE_DECODE(ioctl_result.echo_state),
+
+ (tmp->owner->context == NULL ? "----" : tmp->owner->context),
+ (tmp->owner->exten == NULL ? "----" : tmp->owner->exten),
+ (tmp->owner->callerid == NULL? "----" : tmp->owner->callerid)
+ );
+
+ tmp = tmp->next;
+ }/* while() */
+ ast_cli(fd, "%d active channel(s)\n", active_chans_counter);
+
+ ast_mutex_unlock(lock);
+ return RESULT_SUCCESS;
+}
+
+static int sangoma_dbg_channel(int fd, int argc, char **argv)
+{
+ int channel;
+ struct zt_pvt *tmp = NULL;
+ ast_mutex_t *lock;
+ struct zt_pvt *start;
+
+ lock = &iflock;
+ start = iflist;
+
+ if (argc != 4){
+ return RESULT_SHOWUSAGE;
+ }
+
+ channel = atoi(argv[3]);
+
+ ast_mutex_lock(lock);
+ tmp = start;
+
+ /* The ED algorithm can be enabled/disabled on all channels or
+ for an individual channel.
+ */
+ if(!strcmp(argv[3], "all")){
+ while (tmp) {
+ if(tmp->channel > 0){
+ if(!strcmp(argv[1], "enable")){
+ sangoma_ed_control(fd, tmp, SANGOMA_ENABLE_ED);
+ }else if(!strcmp(argv[1], "disable")){
+ sangoma_ed_control(fd, tmp, SANGOMA_DISABLE_ED);
+ }else{
+ ast_cli(fd, "%s(): Invalid command switch: %s!\n",
+ argv[2], __FUNCTION__);
+ }
+ }
+ tmp = tmp->next;
+ }/* while() */
+ ast_mutex_unlock(lock);
+ return RESULT_SUCCESS;
+ }else{
+ while (tmp) {
+ if (tmp->channel == channel) {
+
+ if(!strcmp(argv[1], "enable")){
+ sangoma_ed_control(fd, tmp, SANGOMA_ENABLE_ED);
+ }else if(!strcmp(argv[1], "disable")){
+ sangoma_ed_control(fd, tmp, SANGOMA_DISABLE_ED);
+ }else{
+ ast_cli(fd, "%s(): Invalid command switch: %s!\n",
+ argv[2], __FUNCTION__);
+ }
+
+ ast_mutex_unlock(lock);
+ return RESULT_SUCCESS;
+ }
+ tmp = tmp->next;
+ }/* while() */
+ }/* if() */
+
+ ast_cli(fd, "Unable to find given channel %d\n", channel);
+ ast_mutex_unlock(lock);
+ return RESULT_FAILURE;
+}
+
+static void sangoma_ed_control(int fd, struct zt_pvt *tmp, int control_code)
+{
+ echo_detect_struct_t ioctl_result;
+
+ switch(control_code)
+ {
+ case SANGOMA_ENABLE_ED:
+ ast_cli(fd,
+ "Enabling Sangoma ED on Span: %d, Channel: %d, File Descriptor: %d.\n",
+ tmp->span, tmp->channel, tmp->subs[SUB_REAL].zfd);
+ tmp->ed_enabled = 1;
+
+ sangoma_do_echo_detect_ioctl(tmp->subs[SUB_REAL].zfd, SANGOMA_ENABLE_ED,
+ (int*)&ioctl_result);
+ break;
+
+ case SANGOMA_DISABLE_ED:
+ ast_cli(fd,
+ "Disabling Sangoma ED on Span: %d, Channel: %d, File Descriptor: %d.\n",
+ tmp->span, tmp->channel, tmp->subs[SUB_REAL].zfd);
+ tmp->ed_enabled = 0;
+
+ sangoma_do_echo_detect_ioctl(tmp->subs[SUB_REAL].zfd, SANGOMA_DISABLE_ED,
+ (int*)&ioctl_result);
+ break;
+ default:
+ ast_cli(fd, "%s(): invalid IOCTL code.\n", __FUNCTION__);
+ }
+}
+
+static int sangoma_send_echo_spike(int fd, int argc, char **argv)
+{
+ int channel;
+ struct zt_pvt *tmp = NULL;
+ ast_mutex_t *lock;
+ struct zt_pvt *start;
+ unsigned char spike_buff[sizeof(echo_spike_struct_t)];
+ echo_spike_struct_t *echo_spike_struct_ptr = (echo_spike_struct_t *)spike_buff;
+
+ lock = &iflock;
+ start = iflist;
+
+ if (argc != 4){
+ return RESULT_SHOWUSAGE;
+ }
+
+ channel = atoi(argv[3]);
+
+ ast_mutex_lock(lock);
+ tmp = start;
+
+ while (tmp) {
+ if (tmp->channel == channel) {
+ if(sangoma_do_echo_detect_ioctl( tmp->subs[SUB_REAL].zfd,
+ SANGOMA_SEND_SPIKE,
+ (int*)spike_buff) != 0){
+ ast_cli(fd,
+ "Command failed on channel %d! Please check kernel messages log.\n",
+ channel);
+ }else if(echo_spike_struct_ptr->return_code == SANGOMA_NO_ACTIVE_CALL_OR_EC_OFF){
+ ast_cli(fd,
+ "Command failed on channel %d! \
+ Possible reasons: 1. the 'echocancel' is set to 'no' 2. call is not up.\n", channel);
+ }else{
+ ;/* no error. do nothing. */
+ }
+ ast_mutex_unlock(lock);
+ return RESULT_SUCCESS;
+ }
+ tmp = tmp->next;
+ }/* while() */
+
+ ast_cli(fd, "Unable to find given channel %d\n", channel);
+ ast_mutex_unlock(lock);
+ return RESULT_FAILURE;
+}
+
+static int sangoma_get_echo_spike(int fd, int argc, char **argv)
+{
+ int channel;
+ struct zt_pvt *tmp = NULL;
+ ast_mutex_t *lock;
+ struct zt_pvt *start;
+ static unsigned char spike_buff[sizeof(echo_spike_struct_t) + SANGOMA_SPIKE_SAMPLE_LEN];
+ echo_spike_struct_t *echo_spike_struct_ptr = (echo_spike_struct_t *)spike_buff;
+ unsigned char *spike_sample_buff_ptr = &spike_buff[sizeof(echo_spike_struct_t)];
+ int linearized_buff[SANGOMA_SPIKE_SAMPLE_LEN];
+
+ lock = &iflock;
+ start = iflist;
+
+ if (argc != 4){
+ return RESULT_SHOWUSAGE;
+ }
+
+ channel = atoi(argv[3]);
+
+ ast_mutex_lock(lock);
+ tmp = start;
+
+ while (tmp) {
+ if (tmp->channel == channel) {
+ if(sangoma_do_echo_detect_ioctl(tmp->subs[SUB_REAL].zfd,
+ SANGOMA_GET_ECHO_SPIKE_SAMPLE,
+ (int*)spike_buff) == 0){
+ if(echo_spike_struct_ptr->return_code == SANGOMA_OK){
+ /*
+ int ind;
+ ast_cli(fd, "SANGOMA_SPIKE_SAMPLE_LEN:%d\n", SANGOMA_SPIKE_SAMPLE_LEN);
+ ast_cli(fd, "NOT liniarized buffer:\n");
+ for(ind = 0; ind < SANGOMA_SPIKE_SAMPLE_LEN; ind++){
+ ast_cli(fd, "0x%02X\n", spike_sample_buff_ptr[ind]);
+ }
+ */
+ sangoma_linearize_spike_buffer(fd, spike_sample_buff_ptr, linearized_buff,
+ tmp->law);
+
+ sangoma_write_spike_buffer_to_file(tmp, linearized_buff, fd);
+
+ sangoma_summary_of_linear_spike_buffer(fd, linearized_buff, tmp);
+ }else{
+ ast_cli(fd,
+ "Command failed on channel %d! \
+ Possible reasons: 1. the 'echocancel' is set to 'no' 2. call is not up.\n", channel);
+ }
+ }
+ ast_mutex_unlock(lock);
+ return RESULT_SUCCESS;
+ }
+ tmp = tmp->next;
+ }/* while() */
+
+ ast_cli(fd, "Unable to find given channel %d\n", channel);
+ ast_mutex_unlock(lock);
+ return RESULT_FAILURE;
+}
+
+static void sangoma_linearize_spike_buffer(int fd, unsigned char *spike_buff, int *linearized_buff, int law)
+{
+ int ind;
+ unsigned short *linear_table;
+
+ if(law == ZT_LAW_MULAW){
+ ast_cli(fd, "Using MULAW table...\n");
+ linear_table = u2s;
+ }else{
+ ast_cli(fd, "Using ALAW table...\n");
+ linear_table = a2s;
+ }
+
+ memset(linearized_buff, 0x00, SANGOMA_SPIKE_SAMPLE_LEN);
+
+ //ast_cli(fd, "linearized buffer (v2 len: %d)\n", SANGOMA_SPIKE_SAMPLE_LEN);
+ for(ind = 0; ind < SANGOMA_SPIKE_SAMPLE_LEN; ind++){
+
+ if(linear_table[spike_buff[ind]] == 0){
+ linearized_buff[ind] = 0;
+ }else if(spike_buff[ind] < 128){
+ /* make it negative */
+ linearized_buff[ind] = -65535 + linear_table[spike_buff[ind]];
+ }else{
+ linearized_buff[ind] = linear_table[spike_buff[ind]];
+ }
+ //ast_cli(fd, "%d\n", linearized_buff[ind]);
+ }/* for() */
+}
+
+static void sangoma_summary_of_linear_spike_buffer(int fd, int *linearized_buff, struct zt_pvt *tmp)
+{
+ int i;
+
+ for(i = 0; i < SANGOMA_SPIKE_SAMPLE_LEN; i ++) {
+ proc_sample(linearized_buff[i], i);
+ }
+ sangoma_analyze_db_loss(fd, tmp);
+}
+
+void proc_sample(unsigned short linear, int sample_no)
+{
+ unsigned short val;
+ float d;
+ float db;
+ int neg_voltage = NO;
+
+ db_loss[sample_no].linear_power_value = linear;
+
+ if(linear & 0xF000) {
+ neg_voltage = YES;
+ val = linear ^ 0xFFFF;
+ } else {
+ val = linear;
+ }
+
+ val = val >> 3;
+ val &= 0x0FFF;
+ d = (float)val / (float)(INITIAL_LINEAR_TX_SPIKE >> 3);
+
+ if(d != 0.00) {
+ db = 20 * log10(d);
+ } else {
+ db = -DB_SILENCE;
+ }
+
+ db_loss[sample_no].db_loss = db;
+
+// printf("sample[%04d]%2.5f\n", sample_no, db);
+ return;
+}
+
+static void sangoma_analyze_db_loss(int fd, struct zt_pvt *tmp)
+{
+ float min_db_loss = -DB_SILENCE;
+ int min_db_loss_sample_no=0;
+ float first_db_loss_th;
+ int sample_no_first_db_loss_th = 0xFFFF;
+ float last_db_loss_th;
+ int sample_no_last_db_loss_th = 0xFFFF;
+ int i;
+
+ for(i = 0; i < SANGOMA_SPIKE_SAMPLE_LEN; i ++) {
+ if(db_loss[i].db_loss > min_db_loss) {
+ min_db_loss = db_loss[i].db_loss;
+ min_db_loss_sample_no = i;
+ }
+ if(sample_no_first_db_loss_th == 0xFFFF) {
+ if(db_loss[i].db_loss > DB_LOSS_THRESHOLD) {
+ sample_no_first_db_loss_th = i;
+ first_db_loss_th = db_loss[i].db_loss;
+ }
+ }
+ if(db_loss[i].db_loss > DB_LOSS_THRESHOLD) {
+ last_db_loss_th = db_loss[i].db_loss;
+ sample_no_last_db_loss_th = i;
+ }
+ }
+
+ if(min_db_loss == -DB_SILENCE) {
+ ast_cli(fd, "The line is silent. No conclusion can be made.\n");
+ } else {
+ ast_cli(fd, "\nEcho Spike reached it's maximum at sample %d, linear power is %d\n",
+ min_db_loss_sample_no + 1,
+ db_loss[min_db_loss_sample_no].linear_power_value);
+
+ ast_cli(fd, "First sample containing Echo Spike is %d, linear power is %d\n",
+ sample_no_first_db_loss_th + 1,
+ db_loss[sample_no_first_db_loss_th].linear_power_value);
+
+ ast_cli(fd, "Last sample containing Echo Spike is %d, linear power is %d\n",
+ sample_no_last_db_loss_th + 1,
+ db_loss[sample_no_last_db_loss_th].linear_power_value);
+
+ //suggest something depending on number of Echo Cancellor taps
+ ast_cli(fd, "\nYour Echo Cancellor set to use %d taps.\n", tmp->echocancel);
+ if(tmp->echocancel < sample_no_first_db_loss_th + 1){
+ ast_cli(fd, "It can not cancel the echo because delay is longer than %d taps.\n",
+ tmp->echocancel);
+
+ }else if(tmp->echocancel > sample_no_first_db_loss_th + 1 &&
+ tmp->echocancel < sample_no_last_db_loss_th + 1){
+ ast_cli(fd, "Echo starts WITHIN %d taps, but ends AFTER %d taps, it means\n\
+echo can not be cancelled completely.\n", tmp->echocancel, tmp->echocancel);
+ }else{
+ ast_cli(fd, "Echo starts and ends WITHIN %d taps, it should be cancelled properly.\n",
+ tmp->echocancel);
+ }
+ }
+}
+
static char zap_show_cadences_help[] =
"Usage: zap show cadences\n"
" Shows all cadences currently defined\n";
@@ -9563,6 +10299,61 @@
"Show all Zaptel cards status", zap_show_status_usage },
};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+static char sangoma_show_channels_usage[] = "Usage: sangoma show channels\n";
+
+static struct ast_cli_entry sangoma_show_channels = {
+ {"sangoma", "show", "channels", NULL},
+ sangoma_show_channels_func,
+ "Show Sangoma channels. Only shows channels with ED enabled and a call up.",
+ sangoma_show_channels_usage,
+ NULL };
+
+//--------------------------------------------------------------------------------------
+static char sangoma_show_chan_debug_usage[] = "Usage: sangoma enable edchannel <chan num> OR <all>\n";
+
+static struct ast_cli_entry sangoma_debug_chan = {
+ {"sangoma", "enable", "edchannel", NULL},
+ sangoma_dbg_channel,
+ "Enable ED algorithm on Sangoma channel(s)",
+ sangoma_show_chan_debug_usage,
+ NULL };
+
+//--------------------------------------------------------------------------------------
+static char sangoma_show_chan_nodebug_usage[] = "Usage: sangoma disable edchannel <chan num> OR <all>\n";
+
+static struct ast_cli_entry sangoma_nodebug_chan = {
+ {"sangoma", "disable", "edchannel", NULL},
+ sangoma_dbg_channel,
+ "Disable ED algorithm on Sangoma channel(s)",
+ sangoma_show_chan_nodebug_usage,
+ NULL };
+
+//--------------------------------------------------------------------------------------
+static char sangoma_get_echo_spike_sample_usage[] = "Usage: sangoma get espike <chan num>\n";
+
+static struct ast_cli_entry sangoma_get_echo_spike_chan = {
+ {"sangoma", "get", "espike", NULL},
+ sangoma_get_echo_spike,
+ "Get Echo spike sample buffer for a channel",
+ sangoma_get_echo_spike_sample_usage,
+ NULL };
+
+//--------------------------------------------------------------------------------------
+static char sangoma_send_echo_spike_usage[] = "Usage: sangoma send espike <chan num>\n";
+
+static struct ast_cli_entry sangoma_send_echo_spike_chan = {
+ {"sangoma", "send", "espike", NULL},
+ sangoma_send_echo_spike,
+ "Send Echo spike on a channel",
+ sangoma_send_echo_spike_usage,
+ NULL };
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+
+
#define TRANSFER 0
#define HANGUP 1
@@ -9760,6 +10551,18 @@
ast_cli_unregister_multiple(zap_r2_cli, sizeof(zap_r2_cli) / sizeof(zap_r2_cli[0]));
#endif
ast_cli_unregister_multiple(zap_cli, sizeof(zap_cli) / sizeof(zap_cli[0]));
+
+ ast_cli_unregister_multiple(sangoma_show_channels,
+ sizeof(sangoma_show_channels)/sizeof(sangoma_show_channels[0]);
+ ast_cli_unregister_multiple(sangoma_debug_chan,
+ sizeof(sangoma_debug_chan)/sizeof(sangoma_debug_chan[0]));
+ ast_cli_unregister_multiple(sangoma_nodebug_chan,
+ sizeof(sangoma_nodebug_chan)/sizeof(sangoma_nodebug_chan[0]));
+ ast_cli_unregister_multiple(sangoma_get_echo_spike_chan,
+ sizeof(sangoma_get_echo_spike_chan)/sizeof(sangoma_get_echo_spike_chan[0]));
+ ast_cli_unregister_multiple(sangoma_send_echo_spike_chan,
+ sizeof(sangoma_send_echo_spike_chan)/sizeof(sangoma_send_echo_spike_chan[0]));
+
ast_manager_unregister( "ZapDialOffhook" );
ast_manager_unregister( "ZapHangup" );
ast_manager_unregister( "ZapTransfer" );
@@ -10660,6 +11463,17 @@
ast_cli_register_multiple(zap_r2_cli, sizeof(zap_r2_cli) / sizeof(zap_r2_cli[0]));
#endif
ast_cli_register_multiple(zap_cli, sizeof(zap_cli) / sizeof(zap_cli[0]));
+
+ ast_cli_register_multiple(sangoma_show_channels,
+ sizeof(sangoma_show_channels)/sizeof(sangoma_show_channels[0]);
+ ast_cli_register_multiple(sangoma_debug_chan,
+ sizeof(sangoma_debug_chan)/sizeof(sangoma_debug_chan[0]));
+ ast_cli_register_multiple(sangoma_nodebug_chan,
+ sizeof(sangoma_nodebug_chan)/sizeof(sangoma_nodebug_chan[0]));
+ ast_cli_register_multiple(sangoma_get_echo_spike_chan,
+ sizeof(sangoma_get_echo_spike_chan)/sizeof(sangoma_get_echo_spike_chan[0]));
+ ast_cli_register_multiple(sangoma_send_echo_spike_chan,
+ sizeof(sangoma_send_echo_spike_chan)/sizeof(sangoma_send_echo_spike_chan[0]));
memset(round_robin, 0, sizeof(round_robin));
ast_manager_register( "ZapTransfer", 0, action_transfer, "Transfer Zap Channel" );
Reference in New Issue View Git Blame Copy Permalink