/* * Zapata Telephony Interface * * Written by Mark Spencer * Based on previous works, designs, and architectures conceived and * written by Jim Dixon . * * 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$ */ #ifndef _LINUX_ZAPTEL_H #define _LINUX_ZAPTEL_H #ifdef __KERNEL__ #include "zconfig.h" #include #include #ifdef CONFIG_ZAPATA_NET #include #endif #ifdef CONFIG_ZAPATA_PPP #include #include #include #endif #include #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) #define LINUX26 #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) #define zap_pci_module pci_register_driver #else #define zap_pci_module pci_module_init #endif #include "ecdis.h" #include "fasthdlc.h" #endif #ifdef CONFIG_DEVFS_FS #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) #include #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 #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; typedef struct zt_indirect_data { int chan; int op; void *data; } ZT_INDIRECT_DATA; /* 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) /* * Do a channel IOCTL from the /dev/zap/ctl interface */ #define ZT_INDIRECT _IOWR (ZT_CODE, 56, struct zt_indirect_data) /* * 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) /* * Enable tone detection -- implemented by low level driver */ #define ZT_TONEDETECT _IOW (ZT_CODE, 91, int) /* * 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 #define ZT_TONEDETECT_ON (1 << 0) /* Detect tones */ #define ZT_TONEDETECT_MUTE (1 << 1) /* Mute audio in received channel */ 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 = , f1 = , f2 = 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_DTMFDOWN (1 << 17) /* Ditto for DTMF key down event */ #define ZT_EVENT_DTMFUP (1 << 18) /* Ditto for DTMF key up event */ /* 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 (200 * 8) /* 200 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 #include #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); /* Opt: Native echo cancellation */ int (*echocan)(struct zt_chan *chan, int ecval); /* 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); /* Opt: Dacs the contents of chan2 into chan1 if possible */ int (*dacs)(struct zt_chan *chan1, struct zt_chan *chan2); /* 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); extern void zt_ec_span(struct zt_span *span); /* 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 */