diff -Naur zapata-1.0.0/goertzel.c zapata-1.0.0.oden/goertzel.c --- zapata-1.0.0/goertzel.c 2002-12-12 20:38:32.000000000 +0100 +++ zapata-1.0.0.oden/goertzel.c 2004-12-26 09:13:11.928099485 +0100 @@ -40,7 +40,7 @@ #include <stdio.h> #include <memory.h> #include <sys/ioctl.h> -#include <linux/zaptel.h> +#include "linux/zaptel.h" #include <errno.h> #define PI 3.1414926535 diff -Naur zapata-1.0.0/include/linux/zaptel.h zapata-1.0.0.oden/include/linux/zaptel.h --- zapata-1.0.0/include/linux/zaptel.h 1970-01-01 01:00:00.000000000 +0100 +++ zapata-1.0.0.oden/include/linux/zaptel.h 2004-09-27 21:50:03.000000000 +0200 @@ -0,0 +1,1444 @@ +/* + * Zapata Telephony Interface + * + * Written by Mark Spencer <markster@linux-suppot.net> + * Based on previous works, designs, and architectures conceived and + * written by Jim Dixon <jim@lambdatel.com>. + * + * Copyright (C) 2001 Jim Dixon / Zapata Telephony. + * Copyright (C) 2001, Linux Support Services, Inc. + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * $Id: zaptel.h,v 1.38 2004/09/27 19:50:03 markster Exp $ + */ + +#ifndef _LINUX_ZAPTEL_H +#define _LINUX_ZAPTEL_H + +#ifdef __KERNEL__ +#include "zconfig.h" +#include <linux/config.h> +#include <linux/version.h> +#ifdef CONFIG_ZAPATA_NET +#include <linux/hdlc.h> +#endif +#ifdef CONFIG_ZAPATA_PPP +#include <linux/ppp_channel.h> +#include <linux/skbuff.h> +#include <linux/interrupt.h> +#endif +#include <linux/fs.h> + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) +#define LINUX26 +#endif + +#include "ecdis.h" +#include "fasthdlc.h" +#endif +#ifdef CONFIG_DEVFS_FS +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) +#include <linux/devfs_fs_kernel.h> +#else +#undef CONFIG_DEVFS_FS +//#warning "Zaptel doesn't support DEVFS in post 2.4 kernels. Disabling DEVFS in zaptel" +#endif +#endif /* CONFIG_DEVFS_FS */ +#include <linux/ioctl.h> + +#ifndef ELAST +#define ELAST 500 +#endif + +/* Per-span configuration values */ +#define ZT_CONFIG_TXLEVEL 7 /* bits 0-2 are tx level */ + +/* Line configuration */ +/* These apply to T1 */ +#define ZT_CONFIG_D4 (1 << 4) +#define ZT_CONFIG_ESF (1 << 5) +#define ZT_CONFIG_AMI (1 << 6) +#define ZT_CONFIG_B8ZS (1 << 7) +/* These apply to E1 */ +#define ZT_CONFIG_CCS (1 << 8) /* CCS (ISDN) instead of CAS (Robbed Bit) */ +#define ZT_CONFIG_HDB3 (1 << 9) /* HDB3 instead of AMI (line coding) */ +#define ZT_CONFIG_CRC4 (1 << 10) /* CRC4 framing */ +#define ZT_CONFIG_NOTOPEN (1 << 16) + +/* Signalling types */ +#define __ZT_SIG_FXO (1 << 12) /* Never use directly */ +#define __ZT_SIG_FXS (1 << 13) /* Never use directly */ + +#define ZT_SIG_NONE (0) /* Channel not configured */ +#define ZT_SIG_FXSLS ((1 << 0) | __ZT_SIG_FXS) /* FXS, Loopstart */ +#define ZT_SIG_FXSGS ((1 << 1) | __ZT_SIG_FXS) /* FXS, Groundstart */ +#define ZT_SIG_FXSKS ((1 << 2) | __ZT_SIG_FXS) /* FXS, Kewlstart */ + +#define ZT_SIG_FXOLS ((1 << 3) | __ZT_SIG_FXO) /* FXO, Loopstart */ +#define ZT_SIG_FXOGS ((1 << 4) | __ZT_SIG_FXO) /* FXO, Groupstart */ +#define ZT_SIG_FXOKS ((1 << 5) | __ZT_SIG_FXO) /* FXO, Kewlstart */ + +#define ZT_SIG_EM (1 << 6) /* Ear & Mouth (E&M) */ + +/* The following are all variations on clear channel */ + +#define __ZT_SIG_DACS (1 << 16) + +#define ZT_SIG_CLEAR (1 << 7) /* Clear channel */ +#define ZT_SIG_HDLCRAW ((1 << 8) | ZT_SIG_CLEAR) /* Raw unchecked HDLC */ +#define ZT_SIG_HDLCFCS ((1 << 9) | ZT_SIG_HDLCRAW) /* HDLC with FCS calculation */ +#define ZT_SIG_HDLCNET ((1 << 10) | ZT_SIG_HDLCFCS) /* HDLC Network */ +#define ZT_SIG_SLAVE (1 << 11) /* Slave to another channel */ +#define ZT_SIG_SF (1 << 14) /* Single Freq. tone only, no sig bits */ +#define ZT_SIG_CAS (1 << 15) /* Just get bits */ +#define ZT_SIG_DACS (__ZT_SIG_DACS | ZT_SIG_CLEAR) /* Cross connect */ +#define ZT_SIG_EM_E1 (1 << 17) /* E1 E&M Variation */ +#define ZT_SIG_DACS_RBS ((1 << 18) | __ZT_SIG_DACS) /* Cross connect w/ RBS */ + +/* tone flag values */ +#define ZT_REVERSE_RXTONE 1 /* reverse polarity rx tone logic */ +#define ZT_REVERSE_TXTONE 2 /* reverse polarity tx tone logic */ + +#define ZT_ABIT 8 +#define ZT_BBIT 4 +#define ZT_CBIT 2 +#define ZT_DBIT 1 + +#define ZT_MAJOR 196 + +#define ZT_CODE 'J' + +/* Default chunk size for conferences and such -- static right now, might make + variable sometime. 8 samples = 1 ms = most frequent service interval possible + for a USB device */ +#define ZT_CHUNKSIZE 8 +#define ZT_MIN_CHUNKSIZE ZT_CHUNKSIZE +#define ZT_DEFAULT_CHUNKSIZE ZT_CHUNKSIZE +#define ZT_MAX_CHUNKSIZE ZT_CHUNKSIZE +#define ZT_CB_SIZE 2 + +#define ZT_MAX_BLOCKSIZE 8192 +#define ZT_DEFAULT_NUM_BUFS 2 +#define ZT_MAX_NUM_BUFS 32 +#define ZT_MAX_BUF_SPACE 32768 + +#define ZT_DEFAULT_BLOCKSIZE 1024 +#define ZT_DEFAULT_MTR_MRU 2048 + +#define ZT_POLICY_IMMEDIATE 0 /* Start play/record immediately */ +#define ZT_POLICY_WHEN_FULL 1 /* Start play/record when buffer is full */ + +#define RING_DEBOUNCE_TIME 2000 /* 2000 ms ring debounce time */ + +#ifdef __KERNEL__ +/* Echo cancellation */ +#if defined(ECHO_CAN_STEVE) +#include "sec.h" +#elif defined(ECHO_CAN_STEVE2) +#include "sec-2.h" +#elif defined(ECHO_CAN_MARK) +#include "mec.h" +#elif defined(ECHO_CAN_MARK2) +#include "mec2.h" +#else +#include "mec3.h" +#endif +#endif + +typedef struct zt_params +{ +int channo; /* Channel number */ +int spanno; /* Span itself */ +int chanpos; /* Channel number in span */ +int sigtype; /* read-only */ +int sigcap; /* read-only */ +int rxisoffhook; /* read-only */ +int rxbits; /* read-only */ +int txbits; /* read-only */ +int txhooksig; /* read-only */ +int rxhooksig; /* read-only */ +int curlaw; /* read-only -- one of ZT_LAW_MULAW or ZT_LAW_ALAW */ +int idlebits; /* read-only -- What is considered the idle state */ +char name[40]; /* Name of channel */ +int prewinktime; +int preflashtime; +int winktime; +int flashtime; +int starttime; +int rxwinktime; +int rxflashtime; +int debouncetime; +int pulsebreaktime; +int pulsemaketime; +int pulseaftertime; +} ZT_PARAMS; + +typedef struct zt_spaninfo +{ +int spanno; /* span number (or -1 to use name) */ +char name[20]; /* Name of span */ +char desc[40]; /* Description of span */ +int alarms; /* alarms status */ +int txlevel; /* what TX level is set to */ +int rxlevel; /* current RX level */ +int bpvcount; /* current BPV count */ +int crc4count; /* current CRC4 error count */ +int ebitcount; /* current E-bit error count */ +int fascount; /* current FAS error count */ +int irqmisses; /* current IRQ misses */ +int syncsrc; /* span # of current sync source, or 0 for free run */ +int numchans; /* number of configured channels on this span */ +int totalchans; /* total number of channels on the span */ +int totalspans; /* total number of zaptel spans in entire system */ +} ZT_SPANINFO; + +typedef struct zt_maintinfo +{ +int spanno; /* span number 1-2 */ +int command; /* command */ +} ZT_MAINTINFO; + +typedef struct zt_confinfo +{ +int chan; /* channel number, 0 for current */ +int confno; /* conference number */ +int confmode; /* conferencing mode */ +} ZT_CONFINFO; + +typedef struct zt_gains +{ +int chan; /* channel number, 0 for current */ +unsigned char rxgain[256]; /* Receive gain table */ +unsigned char txgain[256]; /* Transmit gain table */ +} ZT_GAINS; + +typedef struct zt_lineconfig +{ +int span; /* Which span number (0 to use name) */ +char name[20]; /* Name of span to use */ +int lbo; /* line build-outs */ +int lineconfig; /* line config parameters (framing, coding) */ +int sync; /* what level of sync source we are */ +} ZT_LINECONFIG; + +typedef struct zt_chanconfig +{ +int chan; /* Channel we're applying this to (0 to use name) */ +char name[40]; /* Name of channel to use */ +int sigtype; /* Signal type */ +int deflaw; /* Default law (ZT_LAW_DEFAULT, ZT_LAW_MULAW, or ZT_LAW_ALAW */ +int master; /* Master channel if sigtype is ZT_SLAVE */ +int idlebits; /* Idle bits (if this is a CAS channel) or + channel to monitor (if this is DACS channel) */ +} ZT_CHANCONFIG; + +typedef struct zt_sfconfig +{ +int chan; /* Channel we're applying this to (0 to use name) */ +char name[40]; /* Name of channel to use */ +long rxp1; /* receive tone det. p1 */ +long rxp2; /* receive tone det. p2 */ +long rxp3; /* receive tone det. p3 */ +int txtone; /* Tx tone factor */ +int tx_v2; /* initial v2 value */ +int tx_v3; /* initial v3 value */ +int toneflag; /* Tone flags */ +} ZT_SFCONFIG; + +typedef struct zt_bufferinfo +{ +int txbufpolicy; /* Policy for handling receive buffers */ +int rxbufpolicy; /* Policy for handling receive buffers */ +int numbufs; /* How many buffers to use */ +int bufsize; /* How big each buffer is */ +int readbufs; /* How many read buffers are full (read-only) */ +int writebufs; /* How many write buffers are full (read-only) */ +} ZT_BUFFERINFO; + +typedef struct zt_dialparams +{ +int mfv1_tonelen; /* MF tone length (KP = this * 5/3) */ +int dtmf_tonelen; /* DTMF tone length */ +int reserved[4]; /* Reserved for future expansion -- always set to 0 */ +} ZT_DIAL_PARAMS; + + +typedef struct zt_dynamic_span { + char driver[20]; /* Which low-level driver to use */ + char addr[40]; /* Destination address */ + int numchans; /* Number of channels */ + int timing; /* Timing source preference */ + int spanno; /* Span number (filled in by zaptel) */ +} ZT_DYNAMIC_SPAN; + +/* Define the max # of outgoing DTMF or MFv1 digits to queue in-kernel */ +#define ZT_MAX_DTMF_BUF 256 + +#define ZT_DIAL_OP_APPEND 1 +#define ZT_DIAL_OP_REPLACE 2 +#define ZT_DIAL_OP_CANCEL 3 + +#define ZT_LAW_DEFAULT 0 /* Default law for span */ +#define ZT_LAW_MULAW 1 /* Mu-law */ +#define ZT_LAW_ALAW 2 /* A-law */ + +typedef struct zt_dialoperation +{ +int op; +char dialstr[ZT_MAX_DTMF_BUF]; +} ZT_DIAL_OPERATION; + + +/* ioctl definitions */ +#define ZT_CODE 'J' + +/* + * Get Transfer Block Size. + */ +#define ZT_GET_BLOCKSIZE _IOR (ZT_CODE, 1, int) + +/* + * Set Transfer Block Size. + */ +#define ZT_SET_BLOCKSIZE _IOW (ZT_CODE, 2, int) + +/* + * Flush Buffer(s) and stop I/O + */ +#define ZT_FLUSH _IOW (ZT_CODE, 3, int) + +/* + * Wait for Write to Finish + */ +#define ZT_SYNC _IOW (ZT_CODE, 4, int) + +/* + * Get channel parameters + */ +#define ZT_GET_PARAMS _IOR (ZT_CODE, 5, struct zt_params) + +/* + * Get channel parameters + */ +#define ZT_SET_PARAMS _IOW (ZT_CODE, 6, struct zt_params) + +/* + * Set Hookswitch Status + */ +#define ZT_HOOK _IOW (ZT_CODE, 7, int) + +/* + * Get Signalling Event + */ +#define ZT_GETEVENT _IOR (ZT_CODE, 8, int) + +/* + * Wait for something to happen (IO Mux) + */ +#define ZT_IOMUX _IOWR (ZT_CODE, 9, int) + +/* + * Get Span Status + */ +#define ZT_SPANSTAT _IOWR (ZT_CODE, 10, struct zt_spaninfo) + +/* + * Set Maintenance Mode + */ +#define ZT_MAINT _IOW (ZT_CODE, 11, struct zt_maintinfo) + +/* + * Get Conference Mode + */ +#define ZT_GETCONF _IOWR (ZT_CODE, 12, struct zt_confinfo) + +/* + * Set Conference Mode + */ +#define ZT_SETCONF _IOWR (ZT_CODE, 13, struct zt_confinfo) + +/* + * Setup or Remove Conference Link + */ +#define ZT_CONFLINK _IOW (ZT_CODE, 14, struct zt_confinfo) + +/* + * Display Conference Diagnostic Information on Console + */ +#define ZT_CONFDIAG _IOR (ZT_CODE, 15, int) + +/* + * Get Channel audio gains + */ +#define ZT_GETGAINS _IOWR (ZT_CODE, 16, struct zt_gains) + +/* + * Set Channel audio gains + */ +#define ZT_SETGAINS _IOWR (ZT_CODE, 17, struct zt_gains) + +/* + * Set Line (T1) Configurations and start system + */ +#define ZT_SPANCONFIG _IOW (ZT_CODE, 18, struct zt_lineconfig) + +/* + * Set Channel Configuration + */ +#define ZT_CHANCONFIG _IOW (ZT_CODE, 19, struct zt_chanconfig) + +/* + * Set Conference to mute mode + */ +#define ZT_CONFMUTE _IOW (ZT_CODE, 20, int) + +/* + * Send a particular tone (see ZT_TONE_*) + */ +#define ZT_SENDTONE _IOW (ZT_CODE, 21, int) + +/* + * Set your region for tones (see ZT_TONE_ZONE_*) + */ +#define ZT_SETTONEZONE _IOW (ZT_CODE, 22, int) + +/* + * Retrieve current region for tones (see ZT_TONE_ZONE_*) + */ +#define ZT_GETTONEZONE _IOR (ZT_CODE, 23, int) + +/* + * Master unit only -- set default zone (see ZT_TONE_ZONE_*) + */ +#define ZT_DEFAULTZONE _IOW (ZT_CODE, 24, int) + +/* + * Load a tone zone from a ZT_tone_def_header, see + * below... + */ +#define ZT_LOADZONE _IOW (ZT_CODE, 25, struct zt_tone_def_header) + +/* + * Free a tone zone + */ +#define ZT_FREEZONE _IOW (ZT_CODE, 26, int) + +/* + * Set buffer policy + */ +#define ZT_SET_BUFINFO _IOW (ZT_CODE, 27, struct zt_bufferinfo) + +/* + * Get current buffer info + */ +#define ZT_GET_BUFINFO _IOR (ZT_CODE, 28, struct zt_bufferinfo) + +/* + * Get dialing parameters + */ +#define ZT_GET_DIALPARAMS _IOR (ZT_CODE, 29, struct zt_dialparams) + +/* + * Set dialing parameters + */ +#define ZT_SET_DIALPARAMS _IOW (ZT_CODE, 30, struct zt_dialparams) + +/* + * Append, replace, or cancel a dial string + */ +#define ZT_DIAL _IOW (ZT_CODE, 31, struct zt_dialoperation) + +/* + * Set a clear channel into audio mode + */ +#define ZT_AUDIOMODE _IOW (ZT_CODE, 32, int) + +/* + * Enable or disable echo cancellation on a channel + * The number is zero to disable echo cancellation and non-zero + * to enable echo cancellation. If the number is between 32 + * and 256, it will also set the number of taps in the echo canceller + */ +#define ZT_ECHOCANCEL _IOW (ZT_CODE, 33, int) + +/* + * Return a channel's channel number (useful for the /dev/zap/pseudo type interfaces + */ +#define ZT_CHANNO _IOR (ZT_CODE, 34, int) + +/* + * Return a flag indicating whether channel is currently dialing + */ +#define ZT_DIALING _IOR (ZT_CODE, 35, int) + +/* Numbers 60 to 90 are reserved for private use of low level hardware + drivers */ + +/* + * Set a clear channel into HDLC w/out FCS checking/calculation mode + */ +#define ZT_HDLCRAWMODE _IOW (ZT_CODE, 36, int) + +/* + * Set a clear channel into HDLC w/ FCS mode + */ +#define ZT_HDLCFCSMODE _IOW (ZT_CODE, 37, int) + +/* + * Specify a channel on /dev/zap/chan -- must be done before any other ioctl's and is only + * valid on /dev/zap/chan + */ +#define ZT_SPECIFY _IOW (ZT_CODE, 38, int) + +/* + * Temporarily set the law on a channel to + * ZT_LAW_DEFAULT, ZT_LAW_ALAW, or ZT_LAW_MULAW. Is reset on close. + */ +#define ZT_SETLAW _IOW (ZT_CODE, 39, int) + +/* + * Temporarily set the channel to operate in linear mode when non-zero + * or default law if 0 + */ +#define ZT_SETLINEAR _IOW (ZT_CODE, 40, int) + +/* + * Set a clear channel into HDLC w/ PPP interface mode + */ +#define ZT_HDLCPPP _IOW (ZT_CODE, 41, int) + +/* + * Set the ring cadence for FXS interfaces + */ +#define ZT_SETCADENCE _IOW (ZT_CODE, 42, struct zt_ring_cadence) + +/* + * Set the bits going out for CAS interface + */ +#define ZT_SETTXBITS _IOW (ZT_CODE, 43, int) + + +/* + * Display Channel Diagnostic Information on Console + */ +#define ZT_CHANDIAG _IOR (ZT_CODE, 44, int) + +/* + * Obtain received signalling + */ +#define ZT_GETRXBITS _IOR (ZT_CODE, 45, int) + +/* + * Set Channel's SF Tone Configuration + */ +#define ZT_SFCONFIG _IOW (ZT_CODE, 46, struct zt_sfconfig) + +/* + * Set timer expiration (in samples) + */ +#define ZT_TIMERCONFIG _IOW (ZT_CODE, 47, int) + +/* + * Acknowledge timer expiration (number to acknowledge, or -1 for all) + */ +#define ZT_TIMERACK _IOW (ZT_CODE, 48, int) + +/* + * Get Conference to mute mode + */ +#define ZT_GETCONFMUTE _IOR (ZT_CODE, 49, int) + +/* + * Request echo training in some number of ms (with muting in the mean time) + */ +#define ZT_ECHOTRAIN _IOW (ZT_CODE, 50, int) + +/* + * Set on hook transfer for n number of ms -- implemnted by low level driver + */ +#define ZT_ONHOOKTRANSFER _IOW (ZT_CODE, 51, int) + +/* + * Queue Ping + */ +#define ZT_TIMERPING _IOW (ZT_CODE, 42, int) /* Should be 52, but works */ + +/* + * Acknowledge ping + */ +#define ZT_TIMERPONG _IOW (ZT_CODE, 53, int) + +/* + * Set/get signalling freeze + */ +#define ZT_SIGFREEZE _IOW (ZT_CODE, 54, int) +#define ZT_GETSIGFREEZE _IOR (ZT_CODE, 55, int) + +/* + * 60-80 are reserved for private drivers + * 80-85 are reserved for dynamic span stuff + */ + +/* + * Create a dynamic span + */ +#define ZT_DYNAMIC_CREATE _IOWR (ZT_CODE, 80, struct zt_dynamic_span) + +/* + * Destroy a dynamic span + */ +#define ZT_DYNAMIC_DESTROY _IOW (ZT_CODE, 81, struct zt_dynamic_span) + +/* + * Startup or Shutdown a span + */ +#define ZT_STARTUP _IOW (ZT_CODE, 99, int) +#define ZT_SHUTDOWN _IOW (ZT_CODE, 100, int) + +#define ZT_TONE_ZONE_MAX 128 + +#define ZT_TONE_ZONE_DEFAULT -1 /* To restore default */ + +#define ZT_TONE_STOP -1 +#define ZT_TONE_DIALTONE 0 +#define ZT_TONE_BUSY 1 +#define ZT_TONE_RINGTONE 2 +#define ZT_TONE_CONGESTION 3 +#define ZT_TONE_CALLWAIT 4 +#define ZT_TONE_DIALRECALL 5 +#define ZT_TONE_RECORDTONE 6 +#define ZT_TONE_INFO 7 +#define ZT_TONE_CUST1 8 +#define ZT_TONE_CUST2 9 +#define ZT_TONE_STUTTER 10 +#define ZT_TONE_MAX 16 + +#define ZT_MAX_CADENCE 16 + +struct zt_ring_cadence { + int ringcadence [ZT_MAX_CADENCE]; +}; + +struct zt_tone_def_header { + int count; /* How many samples follow */ + int zone; /* Which zone we are loading */ + int ringcadence[ZT_MAX_CADENCE]; /* Ring cadence in ms (0=on, 1=off, ends with 0 value) */ + char name[40]; /* Informational name of zone */ + /* Immediately follow the ZT_tone_def_header by ZT_tone_def's */ +}; + +struct zt_tone_def { /* Structure for zone programming */ + int tone; /* See ZT_TONE_* */ + int next; /* What the next position in the cadence is + (They're numbered by the order the appear here) */ + int samples; /* How many samples to play for this cadence */ + /* Now come the constants we need to make tones */ + int shift; /* How much to scale down the volume (2 is nice) */ + + /* + Calculate the next 6 factors using the following equations: + l = <level in dbm>, f1 = <freq1>, f2 = <freq2> + gain = pow(10.0, (l - 3.14) / 20.0) * 65536.0 / 2.0; + + // Frequency factor 1 + fac_1 = 2.0 * cos(2.0 * M_PI * (f1/8000.0)) * 32768.0; + // Last previous two samples + init_v2_1 = sin(-4.0 * M_PI * (f1/8000.0)) * gain; + init_v3_1 = sin(-2.0 * M_PI * (f1/8000.0)) * gain; + + // Frequency factor 2 + fac_2 = 2.0 * cos(2.0 * M_PI * (f2/8000.0)) * 32768.0; + // Last previous two samples + init_v2_2 = sin(-4.0 * M_PI * (f2/8000.0)) * gain; + init_v3_2 = sin(-2.0 * M_PI * (f2/8000.0)) * gain; + */ + int fac1; + int init_v2_1; + int init_v3_1; + int fac2; + int init_v2_2; + int init_v3_2; + int modulate; + +}; + +#ifdef __KERNEL__ +#endif /* KERNEL */ + +/* Define the maximum block size */ +#define ZT_MAX_BLOCKSIZE 8192 + +/* Define the default network block size */ +#define ZT_DEFAULT_MTU_MRU 2048 + +/* Flush and stop the read (input) process */ +#define ZT_FLUSH_READ 1 + +/* Flush and stop the write (output) process */ +#define ZT_FLUSH_WRITE 2 + +/* Flush and stop both (input and output) processes */ +#define ZT_FLUSH_BOTH (ZT_FLUSH_READ | ZT_FLUSH_WRITE) + +/* Flush the event queue */ +#define ZT_FLUSH_EVENT 4 + +/* Flush everything */ +#define ZT_FLUSH_ALL (ZT_FLUSH_READ | ZT_FLUSH_WRITE | ZT_FLUSH_EVENT) + + +/* Value for ZT_HOOK, set to ON hook */ +#define ZT_ONHOOK 0 + +/* Value for ZT_HOOK, set to OFF hook */ +#define ZT_OFFHOOK 1 + +/* Value for ZT_HOOK, wink (off hook momentarily) */ +#define ZT_WINK 2 + +/* Value for ZT_HOOK, flash (on hook momentarily) */ +#define ZT_FLASH 3 + +/* Value for ZT_HOOK, start line */ +#define ZT_START 4 + +/* Value for ZT_HOOK, ring line (same as start line) */ +#define ZT_RING 5 + +/* Value for ZT_HOOK, turn ringer off */ +#define ZT_RINGOFF 6 + +/* Ret. Value for GET/WAIT Event, no event */ +#define ZT_EVENT_NONE 0 + +/* Ret. Value for GET/WAIT Event, Went Onhook */ +#define ZT_EVENT_ONHOOK 1 + +/* Ret. Value for GET/WAIT Event, Went Offhook or got Ring */ +#define ZT_EVENT_RINGOFFHOOK 2 + +/* Ret. Value for GET/WAIT Event, Got Wink or Flash */ +#define ZT_EVENT_WINKFLASH 3 + +/* Ret. Value for GET/WAIT Event, Got Alarm */ +#define ZT_EVENT_ALARM 4 + +/* Ret. Value for GET/WAIT Event, Got No Alarm (after alarm) */ +#define ZT_EVENT_NOALARM 5 + +/* Ret. Value for GET/WAIT Event, HDLC Abort frame */ +#define ZT_EVENT_ABORT 6 + +/* Ret. Value for GET/WAIT Event, HDLC Frame overrun */ +#define ZT_EVENT_OVERRUN 7 + +/* Ret. Value for GET/WAIT Event, Bad FCS */ +#define ZT_EVENT_BADFCS 8 + +/* Ret. Value for dial complete */ +#define ZT_EVENT_DIALCOMPLETE 9 + +/* Ret Value for ringer going on */ +#define ZT_EVENT_RINGERON 10 + +/* Ret Value for ringer going off */ +#define ZT_EVENT_RINGEROFF 11 + +/* Ret Value for hook change complete */ +#define ZT_EVENT_HOOKCOMPLETE 12 + +/* Ret Value for bits changing on a CAS / User channel */ +#define ZT_EVENT_BITSCHANGED 13 + +/* Ret value for the beginning of a pulse coming on its way */ +#define ZT_EVENT_PULSE_START 14 + +/* Timer event -- timer expired */ +#define ZT_EVENT_TIMER_EXPIRED 15 + +/* Timer event -- ping ready */ +#define ZT_EVENT_TIMER_PING 16 + +/* Polarity reversal event */ +#define ZT_EVENT_POLARITY 17 + +#define ZT_EVENT_PULSEDIGIT (1 << 16) /* This is OR'd with the digit received */ +#define ZT_EVENT_DTMFDIGIT (1 << 17) /* Ditto for DTMF */ + +/* Flag Value for IOMUX, read avail */ +#define ZT_IOMUX_READ 1 + +/* Flag Value for IOMUX, write avail */ +#define ZT_IOMUX_WRITE 2 + +/* Flag Value for IOMUX, write done */ +#define ZT_IOMUX_WRITEEMPTY 4 + +/* Flag Value for IOMUX, signalling event avail */ +#define ZT_IOMUX_SIGEVENT 8 + +/* Flag Value for IOMUX, Do Not Wait if nothing to report */ +#define ZT_IOMUX_NOWAIT 0x100 + +/* Alarm Condition bits */ +#define ZT_ALARM_NONE 0 /* No alarms */ +#define ZT_ALARM_RECOVER 1 /* Recovering from alarm */ +#define ZT_ALARM_LOOPBACK 2 /* In loopback */ +#define ZT_ALARM_YELLOW 4 /* Yellow Alarm */ +#define ZT_ALARM_RED 8 /* Red Alarm */ +#define ZT_ALARM_BLUE 16 /* Blue Alarm */ +#define ZT_ALARM_NOTOPEN 32 +/* Maintenance modes */ +#define ZT_MAINT_NONE 0 /* Normal Mode */ +#define ZT_MAINT_LOCALLOOP 1 /* Local Loopback */ +#define ZT_MAINT_REMOTELOOP 2 /* Remote Loopback */ +#define ZT_MAINT_LOOPUP 3 /* send loopup code */ +#define ZT_MAINT_LOOPDOWN 4 /* send loopdown code */ +#define ZT_MAINT_LOOPSTOP 5 /* stop sending loop codes */ + + +/* Conference modes */ +#define ZT_CONF_MODE_MASK 0xff /* mask for modes */ +#define ZT_CONF_NORMAL 0 /* normal mode */ +#define ZT_CONF_MONITOR 1 /* monitor mode (rx of other chan) */ +#define ZT_CONF_MONITORTX 2 /* monitor mode (tx of other chan) */ +#define ZT_CONF_MONITORBOTH 3 /* monitor mode (rx & tx of other chan) */ +#define ZT_CONF_CONF 4 /* conference mode */ +#define ZT_CONF_CONFANN 5 /* conference announce mode */ +#define ZT_CONF_CONFMON 6 /* conference monitor mode */ +#define ZT_CONF_CONFANNMON 7 /* conference announce/monitor mode */ +#define ZT_CONF_REALANDPSEUDO 8 /* real and pseudo port both on conf */ +#define ZT_CONF_DIGITALMON 9 /* Do not decode or interpret */ +#define ZT_CONF_FLAG_MASK 0xff00 /* mask for flags */ +#define ZT_CONF_LISTENER 0x100 /* is a listener on the conference */ +#define ZT_CONF_TALKER 0x200 /* is a talker on the conference */ +#define ZT_CONF_PSEUDO_LISTENER 0x400 /* pseudo is a listener on the conference */ +#define ZT_CONF_PSEUDO_TALKER 0x800 /* pseudo is a talker on the conference */ + + +#define ZT_DEFAULT_WINKTIME 150 /* 150 ms default wink time */ +#define ZT_DEFAULT_FLASHTIME 750 /* 750 ms default flash time */ + +#define ZT_DEFAULT_PREWINKTIME 50 /* 50 ms before wink */ +#define ZT_DEFAULT_PREFLASHTIME 50 /* 50 ms before flash */ +#define ZT_DEFAULT_STARTTIME 1500 /* 1500 ms of start */ +#define ZT_DEFAULT_RINGTIME 2000 /* 2000 ms of ring on (start, FXO) */ +#if 0 +#define ZT_DEFAULT_RXWINKTIME 250 /* 250ms longest rx wink */ +#endif +#define ZT_DEFAULT_RXWINKTIME 300 /* 300ms longest rx wink (to work with the Atlas) */ +#define ZT_DEFAULT_RXFLASHTIME 1250 /* 1250ms longest rx flash */ +#define ZT_DEFAULT_DEBOUNCETIME 600 /* 600ms of FXS GS signalling debounce */ +#define ZT_DEFAULT_PULSEMAKETIME 50 /* 50 ms of line closed when dial pulsing */ +#define ZT_DEFAULT_PULSEBREAKTIME 50 /* 50 ms of line open when dial pulsing */ +#define ZT_DEFAULT_PULSEAFTERTIME 750 /* 750ms between dial pulse digits */ + +#define ZT_MINPULSETIME (15 * 8) /* 15 ms minimum */ +#define ZT_MAXPULSETIME (150 * 8) /* 150 ms maximum */ +#define ZT_PULSETIMEOUT ((ZT_MAXPULSETIME / 8) + 50) + +#define ZT_RINGTRAILER (50 * 8) /* Don't consider a ring "over" until it's been gone at least this + much time */ + +#define ZT_LOOPCODE_TIME 10000 /* send loop codes for 10 secs */ +#define ZT_ALARMSETTLE_TIME 5000 /* allow alarms to settle for 5 secs */ +#define ZT_AFTERSTART_TIME 500 /* 500ms after start */ + +#define ZT_RINGOFFTIME 4000 /* Turn off ringer for 4000 ms */ +#define ZT_KEWLTIME 500 /* 500ms for kewl pulse */ +#define ZT_AFTERKEWLTIME 300 /* 300ms after kewl pulse */ + +#define ZT_MAX_PRETRAINING 1000 /* 1000ms max pretraining time */ + +#define ZT_MAX_SPANS 128 /* Max, 128 spans */ +#define ZT_MAX_CHANNELS 1024 /* Max, 1024 channels */ +#define ZT_MAX_CONF 1024 /* Max, 1024 conferences */ + +#ifdef __KERNEL__ + +#include <linux/types.h> +#include <linux/poll.h> + +#define ZT_MAX_EVENTSIZE 64 /* 64 events max in buffer */ + +struct zt_span; +struct zt_chan; + +struct zt_tone_state { + int v1_1; + int v2_1; + int v3_1; + int v1_2; + int v2_2; + int v3_2; + int modulate; +}; + +#ifdef CONFIG_ZAPATA_NET +struct zt_hdlc { +#ifdef LINUX26 + struct net_device *netdev; +#else + hdlc_device netdev; +#endif + struct zt_chan *chan; +}; +#endif + +/* Conference queue stucture */ +struct confq { + u_char buffer[ZT_CHUNKSIZE * ZT_CB_SIZE]; + u_char *buf[ZT_CB_SIZE]; + int inbuf; + int outbuf; +}; + +typedef struct +{ + long x1; + long x2; + long y1; + long y2; + long e1; + long e2; + int samps; + int lastdetect; +} sf_detect_state_t; + +struct zt_chan { +#ifdef CONFIG_ZAPATA_NET + /* Must be first */ + struct zt_hdlc *hdlcnetdev; +#endif +#ifdef CONFIG_ZAPATA_PPP + struct ppp_channel *ppp; + struct tasklet_struct ppp_calls; + int do_ppp_wakeup; + int do_ppp_error; + struct sk_buff_head ppp_rq; +#endif + spinlock_t lock; + char name[40]; /* Name */ + /* Specified by zaptel */ + int channo; /* Zaptel Channel number */ + int chanpos; + int flags; + long rxp1; + long rxp2; + long rxp3; + int txtone; + int tx_v2; + int tx_v3; + int v1_1; + int v2_1; + int v3_1; + int toneflags; + sf_detect_state_t rd; + + struct zt_chan *master; /* Our Master channel (could be us) */ + /* Next slave (if appropriate) */ + int nextslave; + + u_char *writechunk; /* Actual place to write to */ + u_char swritechunk[ZT_MAX_CHUNKSIZE]; /* Buffer to be written */ + u_char *readchunk; /* Actual place to read from */ + u_char sreadchunk[ZT_MAX_CHUNKSIZE]; /* Preallocated static area */ + + /* Pointer to tx and rx gain tables */ + u_char *rxgain; + u_char *txgain; + + /* Whether or not we have allocated gains or are using the default */ + int gainalloc; + + /* Specified by driver, readable by zaptel */ + void *pvt; /* Private channel data */ + struct file *file; /* File structure */ + + + struct zt_span *span; /* Span we're a member of */ + int sig; /* Signalling */ + int sigcap; /* Capability for signalling */ + + + /* Used only by zaptel -- NO DRIVER SERVICEABLE PARTS BELOW */ + /* Buffer declarations */ + u_char *readbuf[ZT_MAX_NUM_BUFS]; /* read buffer */ + int inreadbuf; + int outreadbuf; + wait_queue_head_t readbufq; /* read wait queue */ + + u_char *writebuf[ZT_MAX_NUM_BUFS]; /* write buffers */ + int inwritebuf; + int outwritebuf; + wait_queue_head_t writebufq; /* write wait queue */ + + int blocksize; /* Block size */ + + int eventinidx; /* out index in event buf (circular) */ + int eventoutidx; /* in index in event buf (circular) */ + unsigned int eventbuf[ZT_MAX_EVENTSIZE]; /* event circ. buffer */ + wait_queue_head_t eventbufq; /* event wait queue */ + + wait_queue_head_t txstateq; /* waiting on the tx state to change */ + + int readn[ZT_MAX_NUM_BUFS]; /* # of bytes ready in read buf */ + int readidx[ZT_MAX_NUM_BUFS]; /* current read pointer */ + int writen[ZT_MAX_NUM_BUFS]; /* # of bytes ready in write buf */ + int writeidx[ZT_MAX_NUM_BUFS]; /* current write pointer */ + + int numbufs; /* How many buffers in channel */ + int txbufpolicy; /* Buffer policy */ + int rxbufpolicy; /* Buffer policy */ + int txdisable; /* Disable transmitter */ + int rxdisable; /* Disable receiver */ + + + /* Tone zone stuff */ + struct zt_zone *curzone; /* Zone for selecting tones */ + int tonezone; /* Tone zone for this channel */ + struct zt_tone *curtone; /* Current tone we're playing (if any) */ + int tonep; /* Current position in tone */ + struct zt_tone_state ts; /* Tone state */ + + /* Pulse dial stuff */ + int pdialcount; /* pulse dial count */ + + /* Ring cadence */ + int ringcadence[ZT_MAX_CADENCE]; + int firstcadencepos; /* Where to restart ring cadence */ + + /* Digit string dialing stuff */ + int digitmode; /* What kind of tones are we sending? */ + char txdialbuf[ZT_MAX_DTMF_BUF]; + int dialing; + int afterdialingtimer; + int cadencepos; /* Where in the cadence we are */ + + /* I/O Mask */ + int iomask; /* I/O Mux signal mask */ + wait_queue_head_t sel; /* thingy for select stuff */ + + /* HDLC state machines */ + struct fasthdlc_state txhdlc; + struct fasthdlc_state rxhdlc; + int infcs; + + /* Conferencing stuff */ + int confna; /* conference number (alias) */ + int _confn; /* Actual conference number */ + int confmode; /* conference mode */ + int confmute; /* conference mute mode */ + + /* Incoming and outgoing conference chunk queues for + communicating between zaptel master time and + other boards */ + struct confq confin; + struct confq confout; + + short getlin[ZT_MAX_CHUNKSIZE]; /* Last transmitted samples */ + unsigned char getraw[ZT_MAX_CHUNKSIZE]; /* Last received raw data */ + short getlin_lastchunk[ZT_MAX_CHUNKSIZE]; /* Last transmitted samples from last chunk */ + short putlin[ZT_MAX_CHUNKSIZE]; /* Last received samples */ + unsigned char putraw[ZT_MAX_CHUNKSIZE]; /* Last received raw data */ + short conflast[ZT_MAX_CHUNKSIZE]; /* Last conference sample -- base part of channel */ + short conflast1[ZT_MAX_CHUNKSIZE]; /* Last conference sample -- pseudo part of channel */ + short conflast2[ZT_MAX_CHUNKSIZE]; /* Previous last conference sample -- pseudo part of channel */ + + + /* Is echo cancellation enabled or disabled */ + int echocancel; + echo_can_state_t *ec; + echo_can_disable_detector_state_t txecdis; + echo_can_disable_detector_state_t rxecdis; + + int echostate; /* State of echo canceller */ + int echolastupdate; /* Last echo can update pos */ + int echotimer; /* Timer for echo update */ + + /* RBS timings */ + int prewinktime; /* pre-wink time (ms) */ + int preflashtime; /* pre-flash time (ms) */ + int winktime; /* wink time (ms) */ + int flashtime; /* flash time (ms) */ + int starttime; /* start time (ms) */ + int rxwinktime; /* rx wink time (ms) */ + int rxflashtime; /* rx flash time (ms) */ + int debouncetime; /* FXS GS sig debounce time (ms) */ + int pulsebreaktime; /* pulse line open time (ms) */ + int pulsemaketime; /* pulse line closed time (ms) */ + int pulseaftertime; /* pulse time between digits (ms) */ + + /* RING debounce timer */ + int ringdebtimer; + + /* RING trailing detector to make sure a RING is really over */ + int ringtrailer; + + /* PULSE digit receiver stuff */ + int pulsecount; + int pulsetimer; + + /* RBS timers */ + int itimerset; /* what the itimer was set to last */ + int itimer; + int otimer; + + /* RBS state */ + int gotgs; + int txstate; + int rxsig; + int txsig; + int rxsigstate; + + /* non-RBS rx state */ + int rxhooksig; + int txhooksig; + int kewlonhook; + + /* Idle signalling if CAS signalling */ + int idlebits; + + int deflaw; /* 1 = mulaw, 2=alaw, 0=undefined */ + short *xlaw; +#ifdef CONFIG_CALC_XLAW + unsigned char (*lineartoxlaw)(short a); +#else + unsigned char *lin2x; +#endif + +#ifdef CONFIG_DEVFS_FS + devfs_handle_t fhandle; /* File handle in devfs for the channel */ + devfs_handle_t fhandle_symlink; +#endif /* CONFIG_DEVFS_FS */ +}; + +/* defines for transmit signalling */ +typedef enum { + ZT_TXSIG_ONHOOK, /* On hook */ + ZT_TXSIG_OFFHOOK, /* Off hook */ + ZT_TXSIG_START, /* Start / Ring */ + ZT_TXSIG_KEWL /* Drop battery if possible */ +} zt_txsig_t; + +typedef enum { + ZT_RXSIG_ONHOOK, + ZT_RXSIG_OFFHOOK, + ZT_RXSIG_START, + ZT_RXSIG_RING, + ZT_RXSIG_INITIAL +} zt_rxsig_t; + + +/* Span flags */ +#define ZT_FLAG_REGISTERED (1 << 0) +#define ZT_FLAG_RUNNING (1 << 1) +#define ZT_FLAG_RBS (1 << 12) /* Span uses RBS signalling */ + +/* Channel flags */ +#define ZT_FLAG_DTMFDECODE (1 << 2) /* Channel supports native DTMF decode */ +#define ZT_FLAG_MFDECODE (1 << 3) /* Channel supports native MFr2 decode */ +#define ZT_FLAG_ECHOCANCEL (1 << 4) /* Channel supports native echo cancellation */ + +#define ZT_FLAG_HDLC (1 << 5) /* Perform HDLC */ +#define ZT_FLAG_NETDEV (1 << 6) /* Send to network */ +#define ZT_FLAG_PSEUDO (1 << 7) /* Pseudo channel */ +#define ZT_FLAG_CLEAR (1 << 8) /* Clear channel */ +#define ZT_FLAG_AUDIO (1 << 9) /* Audio mode channel */ + +#define ZT_FLAG_OPEN (1 << 10) /* Channel is open */ +#define ZT_FLAG_FCS (1 << 11) /* Calculate FCS */ +/* Reserve 12 for uniqueness with span flags */ +#define ZT_FLAG_LINEAR (1 << 13) /* Talk to user space in linear */ +#define ZT_FLAG_PPP (1 << 14) /* PPP is available */ +#define ZT_FLAG_T1PPP (1 << 15) +#define ZT_FLAG_SIGFREEZE (1 << 16) /* Freeze signalling */ + +struct zt_span { + spinlock_t lock; + void *pvt; /* Private stuff */ + char name[40]; /* Span name */ + char desc[80]; /* Span description */ + int deflaw; /* Default law (ZT_MULAW or ZT_ALAW) */ + int alarms; /* Pending alarms on span */ + int flags; + int irq; /* IRQ for this span's hardware */ + int lbo; /* Span Line-Buildout */ + int lineconfig; /* Span line configuration */ + int linecompat; /* Span line compatibility */ + int channels; /* Number of channels in span */ + int txlevel; /* Tx level */ + int rxlevel; /* Rx level */ + int syncsrc; /* current sync src (gets copied here) */ + unsigned int bpvcount; /* BPV counter */ + unsigned int crc4count; /* CRC4 error counter */ + unsigned int ebitcount; /* current E-bit error count */ + unsigned int fascount; /* current FAS error count */ + + int maintstat; /* Maintenance state */ + wait_queue_head_t maintq; /* Maintenance queue */ + int mainttimer; /* Maintenance timer */ + + int irqmisses; /* Interrupt misses */ + + struct zt_chan *chans; /* Member channel structures */ + + /* ==== Span Callback Operations ==== */ + /* Req: Set the requested chunk size. This is the unit in which you must + report results for conferencing, etc */ + int (*setchunksize)(struct zt_span *span, int chunksize); + + /* Opt: Configure the span (if appropriate) */ + int (*spanconfig)(struct zt_span *span, struct zt_lineconfig *lc); + + /* Opt: Start the span */ + int (*startup)(struct zt_span *span); + + /* Opt: Shutdown the span */ + int (*shutdown)(struct zt_span *span); + + /* Opt: Enable maintenance modes */ + int (*maint)(struct zt_span *span, int mode); + + /* ==== Channel Callback Operations ==== */ + /* Opt: Set signalling type (if appropriate) */ + int (*chanconfig)(struct zt_chan *chan, int sigtype); + + /* Opt: Prepare a channel for I/O */ + int (*open)(struct zt_chan *chan); + + /* Opt: Close channel for I/O */ + int (*close)(struct zt_chan *chan); + + /* Opt: IOCTL */ + int (*ioctl)(struct zt_chan *chan, unsigned int cmd, unsigned long data); + + /* Okay, now we get to the signalling. You have several options: */ + + /* Option 1: If you're a T1 like interface, you can just provide a + rbsbits function and we'll assert robbed bits for you. Be sure to + set the ZT_FLAG_RBS in this case. */ + + /* Opt: If the span uses A/B bits, set them here */ + int (*rbsbits)(struct zt_chan *chan, int bits); + + /* Option 2: If you don't know about sig bits, but do have their + equivalents (i.e. you can disconnect battery, detect off hook, + generate ring, etc directly) then you can just specify a + sethook function, and we'll call you with appropriate hook states + to set. Still set the ZT_FLAG_RBS in this case as well */ + int (*hooksig)(struct zt_chan *chan, zt_txsig_t hookstate); + + /* Option 3: If you can't use sig bits, you can write a function + which handles the individual hook states */ + int (*sethook)(struct zt_chan *chan, int hookstate); + + /* Used by zaptel only -- no user servicable parts inside */ + int spanno; /* Span number for zaptel */ + int offset; /* Offset within a given card */ + int lastalarms; /* Previous alarms */ + +#ifdef CONFIG_DEVFS_FS + devfs_handle_t dhandle; /* Directory name */ +#endif + /* If the watchdog detects no received data, it will call the + watchdog routine */ + int (*watchdog)(struct zt_span *span, int cause); +#ifdef CONFIG_ZAPTEL_WATCHDOG + int watchcounter; + int watchstate; +#endif +}; + +#define ZT_WATCHDOG_NOINTS (1 << 0) + +#define ZT_WATCHDOG_INIT 1000 + +#define ZT_WATCHSTATE_UNKNOWN 0 +#define ZT_WATCHSTATE_OK 1 +#define ZT_WATCHSTATE_RECOVERING 2 +#define ZT_WATCHSTATE_FAILED 3 + + +struct zt_dynamic_driver { + /* Driver name (e.g. Eth) */ + char name[20]; + + /* Driver description */ + char desc[80]; + + /* Create a new transmission pipe */ + void *(*create)(struct zt_span *span, char *address); + + /* Destroy a created transmission pipe */ + void (*destroy)(void *tpipe); + + /* Transmit a given message */ + int (*transmit)(void *tpipe, unsigned char *msg, int msglen); + + struct zt_dynamic_driver *next; +}; + +/* Receive a dynamic span message */ +extern void zt_dynamic_receive(struct zt_span *span, unsigned char *msg, int msglen); + +/* Register a dynamic driver */ +extern int zt_dynamic_register(struct zt_dynamic_driver *driver); + +/* Unregister a dynamic driver */ +extern void zt_dynamic_unregister(struct zt_dynamic_driver *driver); + +/* Receive on a span. The zaptel interface will handle all the calculations for + all member channels of the span, pulling the data from the readchunk buffer */ +extern int zt_receive(struct zt_span *span); + +/* Prepare writechunk buffers on all channels for this span */ +extern int zt_transmit(struct zt_span *span); + + +/* Register a span. Returns 0 on success, -1 on failure. Pref-master is non-zero if + we should have preference in being the master device */ +extern int zt_register(struct zt_span *span, int prefmaster); + +/* Unregister a span */ +extern int zt_unregister(struct zt_span *span); + +/* Gives a name to an LBO */ +extern char *zt_lboname(int lbo); + +/* Tell Zaptel about changes in received rbs bits */ +extern void zt_rbsbits(struct zt_chan *chan, int bits); + +/* Tell Zaptel abou changes in received signalling */ +extern void zt_hooksig(struct zt_chan *chan, zt_rxsig_t rxsig); + +/* Queue an event on a channel */ +extern void zt_qevent_nolock(struct zt_chan *chan, int event); + +/* Queue an event on a channel, locking it first */ +extern void zt_qevent_lock(struct zt_chan *chan, int event); + +/* Notify a change possible change in alarm status */ +extern void zt_alarm_notify(struct zt_span *span); + +/* Initialize a tone state */ +extern void zt_init_tone_state(struct zt_tone_state *ts, struct zt_tone *zt); + +/* Get a given DTMF or MF tone struct, suitable for zt_tone_nextsample. + Set 'mf' to 0 for DTMF or 1 for MFv1 */ +extern struct zt_tone *zt_dtmf_tone(char digit, int mf); + +/* Echo cancel a receive and transmit chunk for a given channel. This + should be called by the low-level driver as close to the interface + as possible. ECHO CANCELLATION IS NO LONGER AUTOMATICALLY DONE + AT THE ZAPTEL LEVEL. zt_ec_chunk will not echo cancel if it should + not be doing so. rxchunk is modified in-place */ + +extern void zt_ec_chunk(struct zt_chan *chan, unsigned char *rxchunk, const unsigned char *txchunk); + +/* Don't use these directly -- they're not guaranteed to + be there. */ +extern short __zt_mulaw[256]; +extern short __zt_alaw[256]; +#ifdef CONFIG_CALC_XLAW +extern u_char __zt_lineartoulaw(short a); +extern u_char __zt_lineartoalaw(short a); +#else +extern u_char __zt_lin2mu[16384]; +extern u_char __zt_lin2a[16384]; +#endif + +/* Used by dynamic zaptel -- don't use directly */ +extern void zt_set_dynamic_ioctl(int (*func)(unsigned int cmd, unsigned long data)); + +/* Used privately by zaptel. Avoid touching directly */ +struct zt_tone { + int fac1; + int init_v2_1; + int init_v3_1; + + int fac2; + int init_v2_2; + int init_v3_2; + + int tonesamples; /* How long to play this tone before + going to the next (in samples) */ + struct zt_tone *next; /* Next tone in this sequence */ + + int modulate; +}; + +static inline short zt_tone_nextsample(struct zt_tone_state *ts, struct zt_tone *zt) +{ + /* follow the curves, return the sum */ + + int p; + + ts->v1_1 = ts->v2_1; + ts->v2_1 = ts->v3_1; + ts->v3_1 = (zt->fac1 * ts->v2_1 >> 15) - ts->v1_1; + + ts->v1_2 = ts->v2_2; + ts->v2_2 = ts->v3_2; + ts->v3_2 = (zt->fac2 * ts->v2_2 >> 15) - ts->v1_2; + + /* Return top 16 bits */ + if (!ts->modulate) return ts->v3_1 + ts->v3_2; + /* we are modulating */ + p = ts->v3_2 - 32768; + if (p < 0) p = -p; + p = ((p * 9) / 10) + 1; + return (ts->v3_1 * p) >> 15; + +} + +static inline short zt_txtone_nextsample(struct zt_chan *ss) +{ + /* follow the curves, return the sum */ + + ss->v1_1 = ss->v2_1; + ss->v2_1 = ss->v3_1; + ss->v3_1 = (ss->txtone * ss->v2_1 >> 15) - ss->v1_1; + return ss->v3_1; +} + +/* These are the right functions to use. */ + +#define ZT_MULAW(a) (__zt_mulaw[(a)]) +#define ZT_ALAW(a) (__zt_alaw[(a)]) +#define ZT_XLAW(a,c) (c->xlaw[(a)]) + +#ifdef CONFIG_CALC_XLAW +#define ZT_LIN2MU(a) (__zt_lineartoulaw((a))) +#define ZT_LIN2A(a) (__zt_lineartoalaw((a))) + +#define ZT_LIN2X(a,c) ((c)->lineartoxlaw((a))) + +#else +/* Use tables */ +#define ZT_LIN2MU(a) (__zt_lin2mu[((unsigned short)(a)) >> 2]) +#define ZT_LIN2A(a) (__zt_lin2a[((unsigned short)(a)) >> 2]) + +/* Manipulate as appropriate for x-law */ +#define ZT_LIN2X(a,c) ((c)->lin2x[((unsigned short)(a)) >> 2]) + +#endif /* CONFIG_CALC_XLAW */ + +#endif /* __KERNEL__ */ + +#endif /* _LINUX_ZAPTEL_H */ diff -Naur zapata-1.0.0/zap.c zapata-1.0.0.oden/zap.c --- zapata-1.0.0/zap.c 2002-12-12 20:38:32.000000000 +0100 +++ zapata-1.0.0.oden/zap.c 2004-12-26 09:13:11.930100158 +0100 @@ -568,7 +568,7 @@ #include <math.h> #include <time.h> #include <sys/ioctl.h> -#include <linux/zaptel.h> +#include "linux/zaptel.h" #include <string.h> #include <unistd.h> #include <stdlib.h>