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>
distrib
>
Mandriva
>
current
>
i586
>
media
>
contrib-release-src
>
by-pkgid
>
6ec57a988bb323d1b4c02f8398129152
>
files
>
1
