replace ZT_ with DAHDI_, zt_ with dahdi_

git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/trunk@4320 a0bf4364-ded3-4de4-8d8a-66a801d63aff

34 files changed, 3453 insertions, 3453 deletions

diff --git a/drivers/dahdi/adt_lec.c b/drivers/dahdi/adt_lec.c
index d191e2b..541cce9 100644
--- a/drivers/dahdi/adt_lec.c
+++ b/drivers/dahdi/adt_lec.c
@@ -33,7 +33,7 @@ static inline void adt_lec_init_defaults(struct adt_lec_params *params, __u32 ta
 	params->tap_length = tap_length;
 }
 
-static int adt_lec_parse_params(struct adt_lec_params *params, struct zt_echocanparams *ecp, struct zt_echocanparam *p)
+static int adt_lec_parse_params(struct adt_lec_params *params, struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p)
 {
 	unsigned int x;
 	char *c;
diff --git a/drivers/dahdi/arith.h b/drivers/dahdi/arith.h
index 3059db5..760dcc8 100644
--- a/drivers/dahdi/arith.h
+++ b/drivers/dahdi/arith.h
@@ -7,7 +7,7 @@
  */
 
 #ifdef CONFIG_ZAPTEL_MMX
-#ifdef ZT_CHUNKSIZE
+#ifdef DAHDI_CHUNKSIZE
 static inline void __ACSS(volatile short *dst, const short *src)
 {
 	__asm__ __volatile__ (
@@ -49,24 +49,24 @@ static inline void __SCSS(volatile short *dst, const short *src)
 
 }
 
-#if (ZT_CHUNKSIZE == 8)
+#if (DAHDI_CHUNKSIZE == 8)
 #define ACSS(a,b) __ACSS(a,b)
 #define SCSS(a,b) __SCSS(a,b)
-#elif (ZT_CHUNKSIZE > 8)
+#elif (DAHDI_CHUNKSIZE > 8)
 static inline void ACSS(volatile short *dst, const short *src)
 {
 	int x;
-	for (x=0;x<ZT_CHUNKSIZE;x+=8)
+	for (x=0;x<DAHDI_CHUNKSIZE;x+=8)
 		__ACSS(dst + x, src + x);
 }
 static inline void SCSS(volatile short *dst, const short *src)
 {
 	int x;
-	for (x=0;x<ZT_CHUNKSIZE;x+=8)
+	for (x=0;x<DAHDI_CHUNKSIZE;x+=8)
 		__SCSS(dst + x, src + x);
 }
 #else
-#error No MMX for ZT_CHUNKSIZE < 8
+#error No MMX for DAHDI_CHUNKSIZE < 8
 #endif
 #endif
 static inline int CONVOLVE(const int *coeffs, const short *hist, int len)
@@ -258,7 +258,7 @@ static inline short MAX16(const short *y, int len, int *pos)
 
 #else
 
-#ifdef ZT_CHUNKSIZE
+#ifdef DAHDI_CHUNKSIZE
 static inline void ACSS(short *dst, short *src)
 {
 	int x;
@@ -266,12 +266,12 @@ static inline void ACSS(short *dst, short *src)
 	/* Add src to dst with saturation, storing in dst */
 
 #ifdef BFIN
-	for (x = 0; x < ZT_CHUNKSIZE; x++)
+	for (x = 0; x < DAHDI_CHUNKSIZE; x++)
 		dst[x] = __builtin_bfin_add_fr1x16(dst[x], src[x]);
 #else
 	int sum;
 
-	for (x = 0; x < ZT_CHUNKSIZE; x++) {
+	for (x = 0; x < DAHDI_CHUNKSIZE; x++) {
 		sum = dst[x] + src[x];
 		if (sum > 32767)
 			sum = 32767;
@@ -288,12 +288,12 @@ static inline void SCSS(short *dst, short *src)
 
 	/* Subtract src from dst with saturation, storing in dst */
 #ifdef BFIN
-	for (x = 0; x < ZT_CHUNKSIZE; x++)
+	for (x = 0; x < DAHDI_CHUNKSIZE; x++)
 		dst[x] = __builtin_bfin_sub_fr1x16(dst[x], src[x]);
 #else
 	int sum;
 
-	for (x = 0; x < ZT_CHUNKSIZE; x++) {
+	for (x = 0; x < DAHDI_CHUNKSIZE; x++) {
 		sum = dst[x] - src[x];
 		if (sum > 32767)
 			sum = 32767;
@@ -304,7 +304,7 @@ static inline void SCSS(short *dst, short *src)
 #endif
 }
 
-#endif	/* ZT_CHUNKSIZE */
+#endif	/* DAHDI_CHUNKSIZE */
 
 static inline int CONVOLVE(const int *coeffs, const short *hist, int len)
 {
diff --git a/drivers/dahdi/dahdi-base.c b/drivers/dahdi/dahdi-base.c
index 0408c29..2d22e90 100644
--- a/drivers/dahdi/dahdi-base.c
+++ b/drivers/dahdi/dahdi-base.c
@@ -92,8 +92,8 @@
 #include <asm/i387.h>
 #endif
 
-#define hdlc_to_ztchan(h) (((struct zt_hdlc *)(h))->chan)
-#define dev_to_ztchan(h) (((struct zt_hdlc *)(dev_to_hdlc(h)->priv))->chan)
+#define hdlc_to_ztchan(h) (((struct dahdi_hdlc *)(h))->chan)
+#define dev_to_ztchan(h) (((struct dahdi_hdlc *)(dev_to_hdlc(h)->priv))->chan)
 #ifdef LINUX26
 #define ztchan_to_dev(h) ((h)->hdlcnetdev->netdev)
 #else
@@ -104,7 +104,7 @@
 #define	UNIT(file) MINOR(file->f_dentry->d_inode->i_rdev)
 
 /* names of tx level settings */
-static char *zt_txlevelnames[] = {
+static char *dahdi_txlevelnames[] = {
 "0 db (CSU)/0-133 feet (DSX-1)",
 "133-266 feet (DSX-1)",
 "266-399 feet (DSX-1)",
@@ -115,41 +115,41 @@ static char *zt_txlevelnames[] = {
 "-22.5db (CSU)"
 } ;
 
-EXPORT_SYMBOL(zt_transcode_fops);
-EXPORT_SYMBOL(zt_init_tone_state);
-EXPORT_SYMBOL(zt_mf_tone);
-EXPORT_SYMBOL(zt_register);
-EXPORT_SYMBOL(zt_unregister);
-EXPORT_SYMBOL(__zt_mulaw);
-EXPORT_SYMBOL(__zt_alaw);
+EXPORT_SYMBOL(dahdi_transcode_fops);
+EXPORT_SYMBOL(dahdi_init_tone_state);
+EXPORT_SYMBOL(dahdi_mf_tone);
+EXPORT_SYMBOL(dahdi_register);
+EXPORT_SYMBOL(dahdi_unregister);
+EXPORT_SYMBOL(__dahdi_mulaw);
+EXPORT_SYMBOL(__dahdi_alaw);
 #ifdef CONFIG_CALC_XLAW
-EXPORT_SYMBOL(__zt_lineartoulaw);
-EXPORT_SYMBOL(__zt_lineartoalaw);
+EXPORT_SYMBOL(__dahdi_lineartoulaw);
+EXPORT_SYMBOL(__dahdi_lineartoalaw);
 #else
-EXPORT_SYMBOL(__zt_lin2mu);
-EXPORT_SYMBOL(__zt_lin2a);
+EXPORT_SYMBOL(__dahdi_lin2mu);
+EXPORT_SYMBOL(__dahdi_lin2a);
 #endif
-EXPORT_SYMBOL(zt_lboname);
-EXPORT_SYMBOL(zt_transmit);
-EXPORT_SYMBOL(zt_receive);
-EXPORT_SYMBOL(zt_rbsbits);
-EXPORT_SYMBOL(zt_qevent_nolock);
-EXPORT_SYMBOL(zt_qevent_lock);
-EXPORT_SYMBOL(zt_hooksig);
-EXPORT_SYMBOL(zt_alarm_notify);
-EXPORT_SYMBOL(zt_set_dynamic_ioctl);
-EXPORT_SYMBOL(zt_ec_chunk);
-EXPORT_SYMBOL(zt_ec_span);
-EXPORT_SYMBOL(zt_hdlc_abort);
-EXPORT_SYMBOL(zt_hdlc_finish);
-EXPORT_SYMBOL(zt_hdlc_getbuf);
-EXPORT_SYMBOL(zt_hdlc_putbuf);
-EXPORT_SYMBOL(zt_alarm_channel);
-EXPORT_SYMBOL(zt_register_chardev);
-EXPORT_SYMBOL(zt_unregister_chardev);
+EXPORT_SYMBOL(dahdi_lboname);
+EXPORT_SYMBOL(dahdi_transmit);
+EXPORT_SYMBOL(dahdi_receive);
+EXPORT_SYMBOL(dahdi_rbsbits);
+EXPORT_SYMBOL(dahdi_qevent_nolock);
+EXPORT_SYMBOL(dahdi_qevent_lock);
+EXPORT_SYMBOL(dahdi_hooksig);
+EXPORT_SYMBOL(dahdi_alarm_notify);
+EXPORT_SYMBOL(dahdi_set_dynamic_ioctl);
+EXPORT_SYMBOL(dahdi_ec_chunk);
+EXPORT_SYMBOL(dahdi_ec_span);
+EXPORT_SYMBOL(dahdi_hdlc_abort);
+EXPORT_SYMBOL(dahdi_hdlc_finish);
+EXPORT_SYMBOL(dahdi_hdlc_getbuf);
+EXPORT_SYMBOL(dahdi_hdlc_putbuf);
+EXPORT_SYMBOL(dahdi_alarm_channel);
+EXPORT_SYMBOL(dahdi_register_chardev);
+EXPORT_SYMBOL(dahdi_unregister_chardev);
 
 #ifdef CONFIG_PROC_FS
-static struct proc_dir_entry *proc_entries[ZT_MAX_SPANS]; 
+static struct proc_dir_entry *proc_entries[DAHDI_MAX_SPANS]; 
 #endif
 
 /* Here are a couple important little additions for devfs */
@@ -231,36 +231,36 @@ __u16 fcstab[256] =
 static int debug;
 
 /* states for transmit signalling */
-typedef enum {ZT_TXSTATE_ONHOOK,ZT_TXSTATE_OFFHOOK,ZT_TXSTATE_START,
-	ZT_TXSTATE_PREWINK,ZT_TXSTATE_WINK,ZT_TXSTATE_PREFLASH,
-	ZT_TXSTATE_FLASH,ZT_TXSTATE_DEBOUNCE,ZT_TXSTATE_AFTERSTART,
-	ZT_TXSTATE_RINGON,ZT_TXSTATE_RINGOFF,ZT_TXSTATE_KEWL,
-	ZT_TXSTATE_AFTERKEWL,ZT_TXSTATE_PULSEBREAK,ZT_TXSTATE_PULSEMAKE,
-	ZT_TXSTATE_PULSEAFTER
-	} ZT_TXSTATE_t;
+typedef enum {DAHDI_TXSTATE_ONHOOK,DAHDI_TXSTATE_OFFHOOK,DAHDI_TXSTATE_START,
+	DAHDI_TXSTATE_PREWINK,DAHDI_TXSTATE_WINK,DAHDI_TXSTATE_PREFLASH,
+	DAHDI_TXSTATE_FLASH,DAHDI_TXSTATE_DEBOUNCE,DAHDI_TXSTATE_AFTERSTART,
+	DAHDI_TXSTATE_RINGON,DAHDI_TXSTATE_RINGOFF,DAHDI_TXSTATE_KEWL,
+	DAHDI_TXSTATE_AFTERKEWL,DAHDI_TXSTATE_PULSEBREAK,DAHDI_TXSTATE_PULSEMAKE,
+	DAHDI_TXSTATE_PULSEAFTER
+	} DAHDI_TXSTATE_t;
 
-typedef short sumtype[ZT_MAX_CHUNKSIZE];
+typedef short sumtype[DAHDI_MAX_CHUNKSIZE];
 
-static sumtype sums[(ZT_MAX_CONF + 1) * 3];
+static sumtype sums[(DAHDI_MAX_CONF + 1) * 3];
 
 /* Translate conference aliases into actual conferences 
    and vice-versa */
-static short confalias[ZT_MAX_CONF + 1];
-static short confrev[ZT_MAX_CONF + 1];
+static short confalias[DAHDI_MAX_CONF + 1];
+static short confrev[DAHDI_MAX_CONF + 1];
 
 static sumtype *conf_sums_next;
 static sumtype *conf_sums;
 static sumtype *conf_sums_prev;
 
-static struct zt_span *master;
-static struct file_operations zt_fops;
-struct file_operations *zt_transcode_fops = NULL;
+static struct dahdi_span *master;
+static struct file_operations dahdi_fops;
+struct file_operations *dahdi_transcode_fops = NULL;
 
 static struct
 {
 	int	src;	/* source conf number */
 	int	dst;	/* dst conf number */
-} conf_links[ZT_MAX_CONF + 1];
+} conf_links[DAHDI_MAX_CONF + 1];
 
 
 /* There are three sets of conference sum accumulators. One for the current
@@ -309,13 +309,13 @@ of the next sample chunk's data (next time around the world).
 
 #include "digits.h"
 
-static struct zt_dialparams global_dialparams = {
+static struct dahdi_dialparams global_dialparams = {
 	.dtmf_tonelen = DEFAULT_DTMF_LENGTH,
 	.mfv1_tonelen = DEFAULT_MFR1_LENGTH,
 	.mfr2_tonelen = DEFAULT_MFR2_LENGTH,
 };
 
-static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit);
+static int dahdi_chan_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit);
 
 #if defined(CONFIG_ZAPTEL_MMX) || defined(ECHO_CAN_FP)
 /* XXX kernel_fpu_begin() is NOT exported properly (in 2.4), so we have to make
@@ -334,7 +334,7 @@ static inline void __save_init_fpu( struct task_struct *tsk )
 	tsk->flags &= ~PF_USEDFPU;
 }
 
-static inline void zt_kernel_fpu_begin(void)
+static inline void dahdi_kernel_fpu_begin(void)
 {
 	struct task_struct *tsk = current;
 	if (tsk->flags & PF_USEDFPU) {
@@ -344,16 +344,16 @@ static inline void zt_kernel_fpu_begin(void)
 	clts();
 }
 #else
-#define zt_kernel_fpu_begin kernel_fpu_begin
+#define dahdi_kernel_fpu_begin kernel_fpu_begin
 #endif /* LINUX26 */
 #endif	
 
-static struct zt_timer {
+static struct dahdi_timer {
 	int ms;			/* Countdown */
 	int pos;		/* Position */
 	int ping;		/* Whether we've been ping'd */
 	int tripped;	/* Whether we're tripped */
-	struct zt_timer *next;	/* Linked list */
+	struct dahdi_timer *next;	/* Linked list */
 	wait_queue_head_t sel;
 } *zaptimers = NULL;
 
@@ -365,26 +365,26 @@ static spinlock_t zaptimerlock = SPIN_LOCK_UNLOCKED;
 static spinlock_t bigzaplock = SPIN_LOCK_UNLOCKED;
 #endif
 
-struct zt_zone {
+struct dahdi_zone {
 	atomic_t refcount;
 	char name[40];	/* Informational, only */
-	int ringcadence[ZT_MAX_CADENCE];
-	struct zt_tone *tones[ZT_TONE_MAX]; 
+	int ringcadence[DAHDI_MAX_CADENCE];
+	struct dahdi_tone *tones[DAHDI_TONE_MAX]; 
 	/* Each of these is a circular list
-	   of zt_tones to generate what we
+	   of dahdi_tones to generate what we
 	   want.  Use NULL if the tone is
 	   unavailable */
-	struct zt_tone dtmf[16];		/* DTMF tones for this zone, with desired length */
-	struct zt_tone dtmf_continuous[16];	/* DTMF tones for this zone, continuous play */
-	struct zt_tone mfr1[15];		/* MFR1 tones for this zone, with desired length */
-	struct zt_tone mfr2_fwd[15];		/* MFR2 FWD tones for this zone, with desired length */
-	struct zt_tone mfr2_rev[15];		/* MFR2 REV tones for this zone, with desired length */
-	struct zt_tone mfr2_fwd_continuous[16];	/* MFR2 FWD tones for this zone, continuous play */
-	struct zt_tone mfr2_rev_continuous[16];	/* MFR2 REV tones for this zone, continuous play */
+	struct dahdi_tone dtmf[16];		/* DTMF tones for this zone, with desired length */
+	struct dahdi_tone dtmf_continuous[16];	/* DTMF tones for this zone, continuous play */
+	struct dahdi_tone mfr1[15];		/* MFR1 tones for this zone, with desired length */
+	struct dahdi_tone mfr2_fwd[15];		/* MFR2 FWD tones for this zone, with desired length */
+	struct dahdi_tone mfr2_rev[15];		/* MFR2 REV tones for this zone, with desired length */
+	struct dahdi_tone mfr2_fwd_continuous[16];	/* MFR2 FWD tones for this zone, continuous play */
+	struct dahdi_tone mfr2_rev_continuous[16];	/* MFR2 REV tones for this zone, continuous play */
 };
 
-static struct zt_span *spans[ZT_MAX_SPANS];
-static struct zt_chan *chans[ZT_MAX_CHANNELS]; 
+static struct dahdi_span *spans[DAHDI_MAX_SPANS];
+static struct dahdi_chan *chans[DAHDI_MAX_CHANNELS]; 
 
 static int maxspans = 0;
 static int maxchans = 0;
@@ -393,13 +393,13 @@ static int maxlinks = 0;
 
 static int default_zone = -1;
 
-short __zt_mulaw[256];
-short __zt_alaw[256];
+short __dahdi_mulaw[256];
+short __dahdi_alaw[256];
 
 #ifndef CONFIG_CALC_XLAW
-u_char __zt_lin2mu[16384];
+u_char __dahdi_lin2mu[16384];
 
-u_char __zt_lin2a[16384];
+u_char __dahdi_lin2a[16384];
 #endif
 
 static u_char defgain[256];
@@ -412,7 +412,7 @@ static rwlock_t zone_lock = RW_LOCK_UNLOCKED;
 static rwlock_t chan_lock = RW_LOCK_UNLOCKED;
 #endif
 
-static struct zt_zone *tone_zones[ZT_TONE_ZONE_MAX];
+static struct dahdi_zone *tone_zones[DAHDI_TONE_ZONE_MAX];
 
 #define NUM_SIGS	10	
 
@@ -436,37 +436,37 @@ static inline void rotate_sums(void)
 {
 	/* Rotate where we sum and so forth */
 	static int pos = 0;
-	conf_sums_prev = sums + (ZT_MAX_CONF + 1) * pos;
-	conf_sums = sums + (ZT_MAX_CONF + 1) * ((pos + 1) % 3);
-	conf_sums_next = sums + (ZT_MAX_CONF + 1) * ((pos + 2) % 3);
+	conf_sums_prev = sums + (DAHDI_MAX_CONF + 1) * pos;
+	conf_sums = sums + (DAHDI_MAX_CONF + 1) * ((pos + 1) % 3);
+	conf_sums_next = sums + (DAHDI_MAX_CONF + 1) * ((pos + 2) % 3);
 	pos = (pos + 1) % 3;
 	memset(conf_sums_next, 0, maxconfs * sizeof(sumtype));
 }
 
   /* return quiescent (idle) signalling states, for the various signalling types */
-static int zt_q_sig(struct zt_chan *chan)
+static int dahdi_q_sig(struct dahdi_chan *chan)
 {
 int	x;
 
 static unsigned int in_sig[NUM_SIGS][2] = {
-	{ ZT_SIG_NONE, 0},
-	{ ZT_SIG_EM, 0 | (ZT_ABIT << 8)},
-	{ ZT_SIG_FXSLS,ZT_BBIT | (ZT_BBIT << 8)},
-	{ ZT_SIG_FXSGS,ZT_ABIT | ZT_BBIT | ((ZT_ABIT | ZT_BBIT) << 8)},
-	{ ZT_SIG_FXSKS,ZT_BBIT | ZT_BBIT | ((ZT_ABIT | ZT_BBIT) << 8)},
-	{ ZT_SIG_FXOLS,0 | (ZT_ABIT << 8)},
-	{ ZT_SIG_FXOGS,ZT_BBIT | ((ZT_ABIT | ZT_BBIT) << 8)},
-	{ ZT_SIG_FXOKS,0 | (ZT_ABIT << 8)},
-	{ ZT_SIG_SF, 0},
-	{ ZT_SIG_EM_E1, ZT_DBIT | ((ZT_ABIT | ZT_DBIT) << 8) },
+	{ DAHDI_SIG_NONE, 0},
+	{ DAHDI_SIG_EM, 0 | (DAHDI_ABIT << 8)},
+	{ DAHDI_SIG_FXSLS,DAHDI_BBIT | (DAHDI_BBIT << 8)},
+	{ DAHDI_SIG_FXSGS,DAHDI_ABIT | DAHDI_BBIT | ((DAHDI_ABIT | DAHDI_BBIT) << 8)},
+	{ DAHDI_SIG_FXSKS,DAHDI_BBIT | DAHDI_BBIT | ((DAHDI_ABIT | DAHDI_BBIT) << 8)},
+	{ DAHDI_SIG_FXOLS,0 | (DAHDI_ABIT << 8)},
+	{ DAHDI_SIG_FXOGS,DAHDI_BBIT | ((DAHDI_ABIT | DAHDI_BBIT) << 8)},
+	{ DAHDI_SIG_FXOKS,0 | (DAHDI_ABIT << 8)},
+	{ DAHDI_SIG_SF, 0},
+	{ DAHDI_SIG_EM_E1, DAHDI_DBIT | ((DAHDI_ABIT | DAHDI_DBIT) << 8) },
 	} ;
 
 	/* must have span to begin with */
 	if (!chan->span) return(-1);
 	  /* if RBS does not apply, return error */
-	if (!(chan->span->flags & ZT_FLAG_RBS) || 
+	if (!(chan->span->flags & DAHDI_FLAG_RBS) || 
 		!chan->span->rbsbits) return(-1);
-	if (chan->sig == ZT_SIG_CAS)
+	if (chan->sig == DAHDI_SIG_CAS)
 		return chan->idlebits;
 	for (x=0;x<NUM_SIGS;x++) {
 		if (in_sig[x][0] == chan->sig) return(in_sig[x][1]);
@@ -477,45 +477,45 @@ static unsigned int in_sig[NUM_SIGS][2] = {
 static char *sigstr(int sig)
 {
 	switch (sig) {
-		case ZT_SIG_FXSLS:
+		case DAHDI_SIG_FXSLS:
 			return "FXSLS";
-		case ZT_SIG_FXSKS:
+		case DAHDI_SIG_FXSKS:
 			return "FXSKS";
-		case ZT_SIG_FXSGS:
+		case DAHDI_SIG_FXSGS:
 			return "FXSGS";
-		case ZT_SIG_FXOLS:
+		case DAHDI_SIG_FXOLS:
 			return "FXOLS";
-		case ZT_SIG_FXOKS:
+		case DAHDI_SIG_FXOKS:
 			return "FXOKS";
-		case ZT_SIG_FXOGS:
+		case DAHDI_SIG_FXOGS:
 			return "FXOGS";
-		case ZT_SIG_EM:
+		case DAHDI_SIG_EM:
 			return "E&M";
-		case ZT_SIG_EM_E1:
+		case DAHDI_SIG_EM_E1:
 			return "E&M-E1";
-		case ZT_SIG_CLEAR:
+		case DAHDI_SIG_CLEAR:
 			return "Clear";
-		case ZT_SIG_HDLCRAW:
+		case DAHDI_SIG_HDLCRAW:
 			return "HDLCRAW";
-		case ZT_SIG_HDLCFCS:
+		case DAHDI_SIG_HDLCFCS:
 			return "HDLCFCS";
-		case ZT_SIG_HDLCNET:
+		case DAHDI_SIG_HDLCNET:
 			return "HDLCNET";
-		case ZT_SIG_HARDHDLC:
+		case DAHDI_SIG_HARDHDLC:
 			return "Hardware-assisted HDLC";
-		case ZT_SIG_MTP2:
+		case DAHDI_SIG_MTP2:
 			return "MTP2";
-		case ZT_SIG_SLAVE:
+		case DAHDI_SIG_SLAVE:
 			return "Slave";
-		case ZT_SIG_CAS:
+		case DAHDI_SIG_CAS:
 			return "CAS";
-		case ZT_SIG_DACS:
+		case DAHDI_SIG_DACS:
 			return "DACS";
-		case ZT_SIG_DACS_RBS:
+		case DAHDI_SIG_DACS_RBS:
 			return "DACS+RBS";
-		case ZT_SIG_SF:
+		case DAHDI_SIG_SF:
 			return "SF (ToneOnly)";
-		case ZT_SIG_NONE:
+		case DAHDI_SIG_NONE:
 		default:
 			return "Unconfigured";
 	}
@@ -527,17 +527,17 @@ static inline int fill_alarm_string(char *buf, int count, int alarms)
 	int	len = 0;
 
 	if (alarms > 0) {
-		if (alarms & ZT_ALARM_BLUE)
+		if (alarms & DAHDI_ALARM_BLUE)
 			len += snprintf(buf + len, count - len, "BLUE ");
-		if (alarms & ZT_ALARM_YELLOW)
+		if (alarms & DAHDI_ALARM_YELLOW)
 			len += snprintf(buf + len, count - len, "YELLOW ");
-		if (alarms & ZT_ALARM_RED)
+		if (alarms & DAHDI_ALARM_RED)
 			len += snprintf(buf + len, count - len, "RED ");
-		if (alarms & ZT_ALARM_LOOPBACK)
+		if (alarms & DAHDI_ALARM_LOOPBACK)
 			len += snprintf(buf + len, count - len, "LOOP ");
-		if (alarms & ZT_ALARM_RECOVER)
+		if (alarms & DAHDI_ALARM_RECOVER)
 			len += snprintf(buf + len, count - len, "RECOVERING ");
-		if (alarms & ZT_ALARM_NOTOPEN)
+		if (alarms & DAHDI_ALARM_NOTOPEN)
 			len += snprintf(buf + len, count - len, "NOTOPEN ");
 	}
 	if(len > 0) {
@@ -571,21 +571,21 @@ static int zaptel_proc_read(char *page, char **start, off_t off, int count, int
 
 	if (spans[span]->lineconfig) {
 		/* framing first */
-		if (spans[span]->lineconfig & ZT_CONFIG_B8ZS)
+		if (spans[span]->lineconfig & DAHDI_CONFIG_B8ZS)
 			len += sprintf(page + len, " B8ZS/");
-		else if (spans[span]->lineconfig & ZT_CONFIG_AMI)
+		else if (spans[span]->lineconfig & DAHDI_CONFIG_AMI)
 			len += sprintf(page + len, " AMI/");
-		else if (spans[span]->lineconfig & ZT_CONFIG_HDB3)
+		else if (spans[span]->lineconfig & DAHDI_CONFIG_HDB3)
 			len += sprintf(page + len, " HDB3/");
 		/* then coding */
-		if (spans[span]->lineconfig & ZT_CONFIG_ESF)
+		if (spans[span]->lineconfig & DAHDI_CONFIG_ESF)
 			len += sprintf(page + len, "ESF");
-		else if (spans[span]->lineconfig & ZT_CONFIG_D4)
+		else if (spans[span]->lineconfig & DAHDI_CONFIG_D4)
 			len += sprintf(page + len, "D4");
-		else if (spans[span]->lineconfig & ZT_CONFIG_CCS)
+		else if (spans[span]->lineconfig & DAHDI_CONFIG_CCS)
 			len += sprintf(page + len, "CCS");
 		/* E1's can enable CRC checking */
-		if (spans[span]->lineconfig & ZT_CONFIG_CRC4)
+		if (spans[span]->lineconfig & DAHDI_CONFIG_CRC4)
 			len += sprintf(page + len, "/CRC4");
 	}
 
@@ -611,13 +611,13 @@ static int zaptel_proc_read(char *page, char **start, off_t off, int count, int
 	len += sprintf(page + len, "\n");
 
 
-        for (x=1;x<ZT_MAX_CHANNELS;x++) {	
+        for (x=1;x<DAHDI_MAX_CHANNELS;x++) {	
 		if (chans[x]) {
 			if (chans[x]->span && (chans[x]->span->spanno == span)) {
 				if (chans[x]->name)
 					len += sprintf(page + len, "\t%4d %s ", x, chans[x]->name);
 				if (chans[x]->sig) {
-					if (chans[x]->sig == ZT_SIG_SLAVE)
+					if (chans[x]->sig == DAHDI_SIG_SLAVE)
 						len += sprintf(page + len, "%s ", sigstr(chans[x]->master->sig));
 					else {
 						len += sprintf(page + len, "%s ", sigstr(chans[x]->sig));
@@ -625,7 +625,7 @@ static int zaptel_proc_read(char *page, char **start, off_t off, int count, int
 							len += sprintf(page + len, "Master ");
 					}
 				}
-				if ((chans[x]->flags & ZT_FLAG_OPEN)) {
+				if ((chans[x]->flags & DAHDI_FLAG_OPEN)) {
 					len += sprintf(page + len, "(In use) ");
 				}
 #ifdef	OPTIMIZE_CHANMUTE
@@ -655,11 +655,11 @@ static int zaptel_proc_read(char *page, char **start, off_t off, int count, int
 }
 #endif
 
-static int zt_first_empty_alias(void)
+static int dahdi_first_empty_alias(void)
 {
 	/* Find the first conference which has no alias pointing to it */
 	int x;
-	for (x=1;x<ZT_MAX_CONF;x++) {
+	for (x=1;x<DAHDI_MAX_CONF;x++) {
 		if (!confrev[x])
 			return x;
 	}
@@ -669,7 +669,7 @@ static int zt_first_empty_alias(void)
 static void recalc_maxconfs(void)
 {
 	int x;
-	for (x=ZT_MAX_CONF-1;x>0;x--) {
+	for (x=DAHDI_MAX_CONF-1;x>0;x--) {
 		if (confrev[x]) {
 			maxconfs = x+1;
 			return;
@@ -681,7 +681,7 @@ static void recalc_maxconfs(void)
 static void recalc_maxlinks(void)
 {
 	int x;
-	for (x=ZT_MAX_CONF-1;x>0;x--) {
+	for (x=DAHDI_MAX_CONF-1;x>0;x--) {
 		if (conf_links[x].src || conf_links[x].dst) {
 			maxlinks = x+1;
 			return;
@@ -690,18 +690,18 @@ static void recalc_maxlinks(void)
 	maxlinks = 0;
 }
 
-static int zt_first_empty_conference(void)
+static int dahdi_first_empty_conference(void)
 {
 	/* Find the first conference which has no alias */
 	int x;
-	for (x=ZT_MAX_CONF-1;x>0;x--) {
+	for (x=DAHDI_MAX_CONF-1;x>0;x--) {
 		if (!confalias[x])
 			return x;
 	}
 	return -1;
 }
 
-static int zt_get_conf_alias(int x)
+static int dahdi_get_conf_alias(int x)
 {
 	int a;
 	if (confalias[x]) {
@@ -709,7 +709,7 @@ static int zt_get_conf_alias(int x)
 	}
 
 	/* Allocate an alias */
-	a = zt_first_empty_alias();
+	a = dahdi_first_empty_alias();
 	confalias[x] = a;
 	confrev[a] = x;
 
@@ -718,7 +718,7 @@ static int zt_get_conf_alias(int x)
 	return a;
 }
 
-static void zt_check_conf(int x)
+static void dahdi_check_conf(int x)
 {
 	int y;
 
@@ -729,11 +729,11 @@ static void zt_check_conf(int x)
 		return;
 	for (y=0;y<maxchans;y++) {
 		if (chans[y] && (chans[y]->confna == x) &&
-			((chans[y]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_CONF ||
-			(chans[y]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_CONFANN ||
-			(chans[y]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_CONFMON ||
-			(chans[y]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_CONFANNMON ||
-			(chans[y]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_REALANDPSEUDO))
+			((chans[y]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONF ||
+			(chans[y]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONFANN ||
+			(chans[y]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONFMON ||
+			(chans[y]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONFANNMON ||
+			(chans[y]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_REALANDPSEUDO))
 			return;
 	}
 	/* If we get here, nobody is in the conference anymore.  Clear it out
@@ -746,32 +746,32 @@ static void zt_check_conf(int x)
 }
 
 /* enqueue an event on a channel */
-static void __qevent(struct zt_chan *chan, int event)
+static void __qevent(struct dahdi_chan *chan, int event)
 {
 
 	  /* if full, ignore */
-	if ((chan->eventoutidx == 0) && (chan->eventinidx == (ZT_MAX_EVENTSIZE - 1))) 
+	if ((chan->eventoutidx == 0) && (chan->eventinidx == (DAHDI_MAX_EVENTSIZE - 1))) 
 		return;
 	  /* if full, ignore */
 	if (chan->eventinidx == (chan->eventoutidx - 1)) return;
 	  /* save the event */
 	chan->eventbuf[chan->eventinidx++] = event;
 	  /* wrap the index, if necessary */
-	if (chan->eventinidx >= ZT_MAX_EVENTSIZE) chan->eventinidx = 0;
+	if (chan->eventinidx >= DAHDI_MAX_EVENTSIZE) chan->eventinidx = 0;
 	  /* wake em all up */
-	if (chan->iomask & ZT_IOMUX_SIGEVENT) wake_up_interruptible(&chan->eventbufq);
+	if (chan->iomask & DAHDI_IOMUX_SIGEVENT) wake_up_interruptible(&chan->eventbufq);
 	wake_up_interruptible(&chan->readbufq);
 	wake_up_interruptible(&chan->writebufq);
 	wake_up_interruptible(&chan->sel);
 	return;
 }
 
-void zt_qevent_nolock(struct zt_chan *chan, int event)
+void dahdi_qevent_nolock(struct dahdi_chan *chan, int event)
 {
 	__qevent(chan, event);
 }
 
-void zt_qevent_lock(struct zt_chan *chan, int event)
+void dahdi_qevent_lock(struct dahdi_chan *chan, int event)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&chan->lock, flags);
@@ -794,7 +794,7 @@ static int schluffen(wait_queue_head_t *q)
 	return(0);
 }
 
-static inline void calc_fcs(struct zt_chan *ss, int inwritebuf)
+static inline void calc_fcs(struct dahdi_chan *ss, int inwritebuf)
 {
 	int x;
 	unsigned int fcs=PPP_INITFCS;
@@ -811,7 +811,7 @@ static inline void calc_fcs(struct zt_chan *ss, int inwritebuf)
 	data[len-1] = (fcs >> 8) & 0xff;
 }
 
-static int zt_reallocbufs(struct zt_chan *ss, int j, int numbufs)
+static int dahdi_reallocbufs(struct dahdi_chan *ss, int j, int numbufs)
 {
 	unsigned char *newbuf, *oldbuf;
 	unsigned long flags;
@@ -819,8 +819,8 @@ static int zt_reallocbufs(struct zt_chan *ss, int j, int numbufs)
 	/* Check numbufs */
 	if (numbufs < 2)
 		numbufs = 2;
-	if (numbufs > ZT_MAX_NUM_BUFS)
-		numbufs = ZT_MAX_NUM_BUFS;
+	if (numbufs > DAHDI_MAX_NUM_BUFS)
+		numbufs = DAHDI_MAX_NUM_BUFS;
 	/* We need to allocate our buffers now */
 	if (j) {
 		newbuf = kmalloc(j * 2 * numbufs, GFP_KERNEL);
@@ -865,12 +865,12 @@ static int zt_reallocbufs(struct zt_chan *ss, int j, int numbufs)
 	ss->outreadbuf = -1;
 	ss->outwritebuf = -1;
 	ss->numbufs = numbufs;
-	if (ss->txbufpolicy == ZT_POLICY_WHEN_FULL)
+	if (ss->txbufpolicy == DAHDI_POLICY_WHEN_FULL)
 		ss->txdisable = 1;
 	else
 		ss->txdisable = 0;
 
-	if (ss->rxbufpolicy == ZT_POLICY_WHEN_FULL)
+	if (ss->rxbufpolicy == DAHDI_POLICY_WHEN_FULL)
 		ss->rxdisable = 1;
 	else
 		ss->rxdisable = 0;
@@ -881,24 +881,24 @@ static int zt_reallocbufs(struct zt_chan *ss, int j, int numbufs)
 	return 0;
 }
 
-static int zt_hangup(struct zt_chan *chan);
-static void zt_set_law(struct zt_chan *chan, int law);
+static int dahdi_hangup(struct dahdi_chan *chan);
+static void dahdi_set_law(struct dahdi_chan *chan, int law);
 
-/* Pull a ZT_CHUNKSIZE piece off the queue.  Returns
+/* Pull a DAHDI_CHUNKSIZE piece off the queue.  Returns
    0 on success or -1 on failure.  If failed, provides
    silence */
-static int __buf_pull(struct confq *q, u_char *data, struct zt_chan *c, char *label)
+static int __buf_pull(struct confq *q, u_char *data, struct dahdi_chan *c, char *label)
 {
 	int oldoutbuf = q->outbuf;
 	/* Ain't nuffin to read */
 	if (q->outbuf < 0) {
 		if (data)
-			memset(data, ZT_LIN2X(0,c), ZT_CHUNKSIZE);
+			memset(data, DAHDI_LIN2X(0,c), DAHDI_CHUNKSIZE);
 		return -1;
 	}
 	if (data)
-		memcpy(data, q->buf[q->outbuf], ZT_CHUNKSIZE);
-	q->outbuf = (q->outbuf + 1) % ZT_CB_SIZE;
+		memcpy(data, q->buf[q->outbuf], DAHDI_CHUNKSIZE);
+	q->outbuf = (q->outbuf + 1) % DAHDI_CB_SIZE;
 
 	/* Won't be nuffin next time */
 	if (q->outbuf == q->inbuf) {
@@ -939,20 +939,20 @@ static u_char *__buf_cpush(struct confq *q)
 		return NULL;
 	pos = q->outbuf - 1;
 	if (pos < 0)
-		pos += ZT_CB_SIZE;
+		pos += DAHDI_CB_SIZE;
 	return q->buf[pos];
 }
 
-static void __buf_munge(struct zt_chan *chan, u_char *old, u_char *new)
+static void __buf_munge(struct dahdi_chan *chan, u_char *old, u_char *new)
 {
 	/* Run a weighted average of the old and new, in order to
 	   mask a missing sample */
 	int x;
 	int val;
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
-		val = x * ZT_XLAW(new[x], chan) + (ZT_CHUNKSIZE - x - 1) * ZT_XLAW(old[x], chan);
-		val = val / (ZT_CHUNKSIZE - 1);
-		old[x] = ZT_LIN2X(val, chan);
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
+		val = x * DAHDI_XLAW(new[x], chan) + (DAHDI_CHUNKSIZE - x - 1) * DAHDI_XLAW(old[x], chan);
+		val = val / (DAHDI_CHUNKSIZE - 1);
+		old[x] = DAHDI_LIN2X(val, chan);
 	}
 }
 #endif
@@ -966,10 +966,10 @@ static int __buf_push(struct confq *q, u_char *data, char *label)
 	}
 	if (data)
 		/* Copy in the data */
-		memcpy(q->buf[q->inbuf], data, ZT_CHUNKSIZE);
+		memcpy(q->buf[q->inbuf], data, DAHDI_CHUNKSIZE);
 
 	/* Advance the inbuf pointer */
-	q->inbuf = (q->inbuf + 1) % ZT_CB_SIZE;
+	q->inbuf = (q->inbuf + 1) % DAHDI_CB_SIZE;
 
 	if (q->inbuf == q->outbuf) {
 		/* No space anymore... */	
@@ -983,25 +983,25 @@ static int __buf_push(struct confq *q, u_char *data, char *label)
 	return 0;
 }
 
-static void reset_conf(struct zt_chan *chan)
+static void reset_conf(struct dahdi_chan *chan)
 {
 	int x;
 	/* Empty out buffers and reset to initialization */
-	for (x=0;x<ZT_CB_SIZE;x++)
-		chan->confin.buf[x] = chan->confin.buffer + ZT_CHUNKSIZE * x;
+	for (x=0;x<DAHDI_CB_SIZE;x++)
+		chan->confin.buf[x] = chan->confin.buffer + DAHDI_CHUNKSIZE * x;
 	chan->confin.inbuf = 0;
 	chan->confin.outbuf = -1;
 
-	for (x=0;x<ZT_CB_SIZE;x++)
-		chan->confout.buf[x] = chan->confout.buffer + ZT_CHUNKSIZE * x;
+	for (x=0;x<DAHDI_CB_SIZE;x++)
+		chan->confout.buf[x] = chan->confout.buffer + DAHDI_CHUNKSIZE * x;
 	chan->confout.inbuf = 0;
 	chan->confout.outbuf = -1;
 }
 
 
-static inline int hw_echocancel_off(struct zt_chan *chan)
+static inline int hw_echocancel_off(struct dahdi_chan *chan)
 {
-	struct zt_echocanparams ecp;
+	struct dahdi_echocanparams ecp;
 	
 	int ret = -ENODEV;
 	if (chan->span) {
@@ -1015,7 +1015,7 @@ static inline int hw_echocancel_off(struct zt_chan *chan)
 	return ret;
 }
 
-static void close_channel(struct zt_chan *chan)
+static void close_channel(struct dahdi_chan *chan)
 {
 	unsigned long flags;
 	void *rxgain = NULL;
@@ -1027,8 +1027,8 @@ static void close_channel(struct zt_chan *chan)
 #endif
 
 	/* XXX Buffers should be send out before reallocation!!! XXX */
-	if (!(chan->flags & ZT_FLAG_NOSTDTXRX))
-		zt_reallocbufs(chan, 0, 0); 
+	if (!(chan->flags & DAHDI_FLAG_NOSTDTXRX))
+		dahdi_reallocbufs(chan, 0, 0); 
 	spin_lock_irqsave(&chan->lock, flags);
 #ifdef CONFIG_ZAPATA_PPP
 	ppp = chan->ppp;
@@ -1044,7 +1044,7 @@ static void close_channel(struct zt_chan *chan)
 	chan->curzone = NULL;
 	chan->cadencepos = 0;
 	chan->pdialcount = 0;
-	zt_hangup(chan); 
+	dahdi_hangup(chan); 
 	chan->itimerset = chan->itimer = 0;
 	chan->pulsecount = 0;
 	chan->pulsetimer = 0;
@@ -1064,13 +1064,13 @@ static void close_channel(struct zt_chan *chan)
 	oldconf = chan->confna;
 	  /* initialize conference variables */
 	chan->_confn = 0;
-	if ((chan->sig & __ZT_SIG_DACS) != __ZT_SIG_DACS) {
+	if ((chan->sig & __DAHDI_SIG_DACS) != __DAHDI_SIG_DACS) {
 		chan->confna = 0;
 		chan->confmode = 0;
 	}
 	chan->confmute = 0;
 	/* release conference resource, if any to release */
-	if (oldconf) zt_check_conf(oldconf);
+	if (oldconf) dahdi_check_conf(oldconf);
 	chan->gotgs = 0;
 	reset_conf(chan);
 	
@@ -1081,9 +1081,9 @@ static void close_channel(struct zt_chan *chan)
 	chan->txgain = defgain;
 	chan->gainalloc = 0;
 	chan->eventinidx = chan->eventoutidx = 0;
-	chan->flags &= ~(ZT_FLAG_LOOPED | ZT_FLAG_LINEAR | ZT_FLAG_PPP | ZT_FLAG_SIGFREEZE);
+	chan->flags &= ~(DAHDI_FLAG_LOOPED | DAHDI_FLAG_LINEAR | DAHDI_FLAG_PPP | DAHDI_FLAG_SIGFREEZE);
 
-	zt_set_law(chan,0);
+	dahdi_set_law(chan,0);
 
 	memset(chan->conflast, 0, sizeof(chan->conflast));
 	memset(chan->conflast1, 0, sizeof(chan->conflast1));
@@ -1116,9 +1116,9 @@ static void close_channel(struct zt_chan *chan)
 
 static int free_tone_zone(int num)
 {
-	struct zt_zone *z;
+	struct dahdi_zone *z;
 
-	if ((num >= ZT_TONE_ZONE_MAX) || (num < 0))
+	if ((num >= DAHDI_TONE_ZONE_MAX) || (num < 0))
 		return -EINVAL;
 
 	write_lock(&zone_lock);
@@ -1142,11 +1142,11 @@ static int free_tone_zone(int num)
 	}
 }
 
-static int zt_register_tone_zone(int num, struct zt_zone *zone)
+static int dahdi_register_tone_zone(int num, struct dahdi_zone *zone)
 {
 	int res = 0;
 
-	if ((num >= ZT_TONE_ZONE_MAX) || (num < 0))
+	if ((num >= DAHDI_TONE_ZONE_MAX) || (num < 0))
 		return -EINVAL;
 
 	write_lock(&zone_lock);
@@ -1164,7 +1164,7 @@ static int zt_register_tone_zone(int num, struct zt_zone *zone)
 	return res;
 }
 
-static int start_tone(struct zt_chan *chan, int tone)
+static int start_tone(struct dahdi_chan *chan, int tone)
 {
 	int res = -EINVAL;
 
@@ -1187,7 +1187,7 @@ static int start_tone(struct zt_chan *chan, int tone)
 		}
 		/* Note that no tone zone exists at the moment */
 		res = -ENODATA;
-	} else if ((tone >= 0 && tone <= ZT_TONE_MAX)) {
+	} else if ((tone >= 0 && tone <= DAHDI_TONE_MAX)) {
 		/* Have a tone zone */
 		if (chan->curzone->tones[tone]) {
 			chan->curtone = chan->curzone->tones[tone];
@@ -1196,10 +1196,10 @@ static int start_tone(struct zt_chan *chan, int tone)
 			res = -ENOSYS;
 		}
 	} else if (chan->digitmode == DIGIT_MODE_DTMF) {
-		if ((tone >= ZT_TONE_DTMF_BASE) && (tone <= ZT_TONE_DTMF_MAX)) {
+		if ((tone >= DAHDI_TONE_DTMF_BASE) && (tone <= DAHDI_TONE_DTMF_MAX)) {
 			chan->dialing = 1;
 			res = 0;
-			tone -= ZT_TONE_DTMF_BASE;
+			tone -= DAHDI_TONE_DTMF_BASE;
 			if (chan->curzone) {
 				/* Have a tone zone */
 				if (chan->curzone->dtmf_continuous[tone].tonesamples) {
@@ -1217,9 +1217,9 @@ static int start_tone(struct zt_chan *chan, int tone)
 			res = -EINVAL;
 		}
 	} else if (chan->digitmode == DIGIT_MODE_MFR2_FWD) {
-		if ((tone >= ZT_TONE_MFR2_FWD_BASE) && (tone <= ZT_TONE_MFR2_FWD_MAX)) {
+		if ((tone >= DAHDI_TONE_MFR2_FWD_BASE) && (tone <= DAHDI_TONE_MFR2_FWD_MAX)) {
 			res = 0;
-			tone -= ZT_TONE_MFR2_FWD_BASE;
+			tone -= DAHDI_TONE_MFR2_FWD_BASE;
 			if (chan->curzone) {
 				/* Have a tone zone */
 				if (chan->curzone->mfr2_fwd_continuous[tone].tonesamples) {
@@ -1237,9 +1237,9 @@ static int start_tone(struct zt_chan *chan, int tone)
 			res = -EINVAL;
 		}
 	} else if (chan->digitmode == DIGIT_MODE_MFR2_REV) {
-		if ((tone >= ZT_TONE_MFR2_REV_BASE) && (tone <= ZT_TONE_MFR2_REV_MAX)) {
+		if ((tone >= DAHDI_TONE_MFR2_REV_BASE) && (tone <= DAHDI_TONE_MFR2_REV_MAX)) {
 			res = 0;
-			tone -= ZT_TONE_MFR2_REV_BASE;
+			tone -= DAHDI_TONE_MFR2_REV_BASE;
 			if (chan->curzone) {
 				/* Have a tone zone */
 				if (chan->curzone->mfr2_rev_continuous[tone].tonesamples) {
@@ -1262,15 +1262,15 @@ static int start_tone(struct zt_chan *chan, int tone)
 	}
 
 	if (chan->curtone)
-		zt_init_tone_state(&chan->ts, chan->curtone);
+		dahdi_init_tone_state(&chan->ts, chan->curtone);
 	
 	return res;
 }
 
-static int set_tone_zone(struct zt_chan *chan, int zone)
+static int set_tone_zone(struct dahdi_chan *chan, int zone)
 {
 	int res = 0;
-	struct zt_zone *z;
+	struct dahdi_zone *z;
 	unsigned long flags;
 
 	/* Do not call with the channel locked. */
@@ -1278,7 +1278,7 @@ static int set_tone_zone(struct zt_chan *chan, int zone)
 	if (zone == -1)
 		zone = default_zone;
 
-	if ((zone >= ZT_TONE_ZONE_MAX) || (zone < 0))
+	if ((zone >= DAHDI_TONE_ZONE_MAX) || (zone < 0))
 		return -EINVAL;
 
 	read_lock(&zone_lock);
@@ -1302,34 +1302,34 @@ static int set_tone_zone(struct zt_chan *chan, int zone)
 	return res;
 }
 
-static void zt_set_law(struct zt_chan *chan, int law)
+static void dahdi_set_law(struct dahdi_chan *chan, int law)
 {
 	if (!law) {
 		if (chan->deflaw)
 			law = chan->deflaw;
 		else
 			if (chan->span) law = chan->span->deflaw;
-			else law = ZT_LAW_MULAW;
+			else law = DAHDI_LAW_MULAW;
 	}
-	if (law == ZT_LAW_ALAW) {
-		chan->xlaw = __zt_alaw;
+	if (law == DAHDI_LAW_ALAW) {
+		chan->xlaw = __dahdi_alaw;
 #ifdef CONFIG_CALC_XLAW
-		chan->lineartoxlaw = __zt_lineartoalaw;
+		chan->lineartoxlaw = __dahdi_lineartoalaw;
 #else
-		chan->lin2x = __zt_lin2a;
+		chan->lin2x = __dahdi_lin2a;
 #endif
 	} else {
-		chan->xlaw = __zt_mulaw;
+		chan->xlaw = __dahdi_mulaw;
 #ifdef CONFIG_CALC_XLAW
-		chan->lineartoxlaw = __zt_lineartoulaw;
+		chan->lineartoxlaw = __dahdi_lineartoulaw;
 #else
-		chan->lin2x = __zt_lin2mu;
+		chan->lin2x = __dahdi_lin2mu;
 #endif
 	}
 }
 
 #ifdef CONFIG_DEVFS_FS
-static devfs_handle_t register_devfs_channel(struct zt_chan *chan, devfs_handle_t dir)
+static devfs_handle_t register_devfs_channel(struct dahdi_chan *chan, devfs_handle_t dir)
 {
 	char path[100];
 	char link[100];
@@ -1344,7 +1344,7 @@ static devfs_handle_t register_devfs_channel(struct zt_chan *chan, devfs_handle_
 	unsigned int flags = DEVFS_FL_AUTO_OWNER;
 
 	sprintf(path, "%d", chan->chanpos);
-	chan_dev = devfs_register(dir, path, flags, ZT_MAJOR, chan->channo, mode, &zt_fops, NULL);
+	chan_dev = devfs_register(dir, path, flags, DAHDI_MAJOR, chan->channo, mode, &dahdi_fops, NULL);
 	if (!chan_dev) {
 		printk("zaptel: Something really bad happened.  Unable to register devfs entry\n");
 		return NULL;
@@ -1373,14 +1373,14 @@ static devfs_handle_t register_devfs_channel(struct zt_chan *chan, devfs_handle_
 }
 #endif /* CONFIG_DEVFS_FS */
 
-static int zt_chan_reg(struct zt_chan *chan)
+static int dahdi_chan_reg(struct dahdi_chan *chan)
 {
 	int x;
 	int res=0;
 	unsigned long flags;
 	
 	write_lock_irqsave(&chan_lock, flags);
-	for (x=1;x<ZT_MAX_CHANNELS;x++) {
+	for (x=1;x<DAHDI_MAX_CHANNELS;x++) {
 		if (!chans[x]) {
 			spin_lock_init(&chan->lock);
 			chans[x] = chan;
@@ -1393,26 +1393,26 @@ static int zt_chan_reg(struct zt_chan *chan)
 				chan->readchunk = chan->sreadchunk;
 			if (!chan->writechunk)
 				chan->writechunk = chan->swritechunk;
-			zt_set_law(chan, 0);
+			dahdi_set_law(chan, 0);
 			close_channel(chan); 
 			/* set this AFTER running close_channel() so that
 				HDLC channels wont cause hangage */
-			chan->flags |= ZT_FLAG_REGISTERED;
+			chan->flags |= DAHDI_FLAG_REGISTERED;
 			res = 0;
 			break;
 		}
 	}
 	write_unlock_irqrestore(&chan_lock, flags);	
-	if (x >= ZT_MAX_CHANNELS)
+	if (x >= DAHDI_MAX_CHANNELS)
 		printk(KERN_ERR "No more channels available\n");
 	return res;
 }
 
-char *zt_lboname(int x)
+char *dahdi_lboname(int x)
 {
 	if ((x < 0) || ( x > 7))
 		return "Unknown";
-	return zt_txlevelnames[x];
+	return dahdi_txlevelnames[x];
 }
 
 #if defined(CONFIG_ZAPATA_NET) || defined(CONFIG_ZAPATA_PPP)
@@ -1420,14 +1420,14 @@ char *zt_lboname(int x)
 
 #ifdef CONFIG_ZAPATA_NET
 #ifdef NEW_HDLC_INTERFACE
-static int zt_net_open(struct net_device *dev)
+static int dahdi_net_open(struct net_device *dev)
 {
 #ifdef LINUX26
 	int res = hdlc_open(dev);
-	struct zt_chan *ms = dev_to_ztchan(dev);
+	struct dahdi_chan *ms = dev_to_ztchan(dev);
 #else
 	hdlc_device *hdlc = dev_to_hdlc(dev);
-	struct zt_chan *ms = hdlc_to_ztchan(hdlc);
+	struct dahdi_chan *ms = hdlc_to_ztchan(hdlc);
 	int res = hdlc_open(hdlc);
 #endif	
 	                                                                                                                             
@@ -1435,27 +1435,27 @@ static int zt_net_open(struct net_device *dev)
 	if (res) /* this is necessary to avoid kernel panic when UNSPEC link encap, proven --byg */
 		return res;
 #else
-static int zt_net_open(hdlc_device *hdlc)
+static int dahdi_net_open(hdlc_device *hdlc)
 {
-	struct zt_chan *ms = hdlc_to_ztchan(hdlc);
+	struct dahdi_chan *ms = hdlc_to_ztchan(hdlc);
 	int res;
 #endif
 	if (!ms) {
-		printk("zt_net_open: nothing??\n");
+		printk("dahdi_net_open: nothing??\n");
 		return -EINVAL;
 	}
-	if (ms->flags & ZT_FLAG_OPEN) {
+	if (ms->flags & DAHDI_FLAG_OPEN) {
 		printk("%s is already open!\n", ms->name);
 		return -EBUSY;
 	}
-	if (!(ms->flags & ZT_FLAG_NETDEV)) {
+	if (!(ms->flags & DAHDI_FLAG_NETDEV)) {
 		printk("%s is not a net device!\n", ms->name);
 		return -EINVAL;
 	}
-	ms->txbufpolicy = ZT_POLICY_IMMEDIATE;
-	ms->rxbufpolicy = ZT_POLICY_IMMEDIATE;
+	ms->txbufpolicy = DAHDI_POLICY_IMMEDIATE;
+	ms->rxbufpolicy = DAHDI_POLICY_IMMEDIATE;
 
-	res = zt_reallocbufs(ms, ZT_DEFAULT_MTU_MRU, ZT_DEFAULT_NUM_BUFS);
+	res = dahdi_reallocbufs(ms, DAHDI_DEFAULT_MTU_MRU, DAHDI_DEFAULT_NUM_BUFS);
 	if (res) 
 		return res;
 
@@ -1475,7 +1475,7 @@ static int zt_net_open(hdlc_device *hdlc)
 }
 
 #ifdef LINUX26
-static int zt_register_hdlc_device(struct net_device *dev, const char *dev_name)
+static int dahdi_register_hdlc_device(struct net_device *dev, const char *dev_name)
 {
 	int result;
 
@@ -1495,41 +1495,41 @@ static int zt_register_hdlc_device(struct net_device *dev, const char *dev_name)
 #endif
 
 #ifdef NEW_HDLC_INTERFACE
-static int zt_net_stop(struct net_device *dev)
+static int dahdi_net_stop(struct net_device *dev)
 {
 #ifdef LINUX26
     hdlc_device *h = dev_to_hdlc(dev);
-    struct zt_hdlc *hdlc = h->priv;
+    struct dahdi_hdlc *hdlc = h->priv;
 #else
     hdlc_device *hdlc = dev_to_hdlc(dev);
 #endif
 
 #else
-static void zt_net_close(hdlc_device *hdlc)
+static void dahdi_net_close(hdlc_device *hdlc)
 {
 #endif
-	struct zt_chan *ms = hdlc_to_ztchan(hdlc);
+	struct dahdi_chan *ms = hdlc_to_ztchan(hdlc);
 	if (!ms) {
 #ifdef NEW_HDLC_INTERFACE
-		printk("zt_net_stop: nothing??\n");
+		printk("dahdi_net_stop: nothing??\n");
 		return 0;
 #else
-		printk("zt_net_close: nothing??\n");
+		printk("dahdi_net_close: nothing??\n");
 		return;
 #endif
 	}
-	if (!(ms->flags & ZT_FLAG_NETDEV)) {
+	if (!(ms->flags & DAHDI_FLAG_NETDEV)) {
 #ifdef NEW_HDLC_INTERFACE
-		printk("zt_net_stop: %s is not a net device!\n", ms->name);
+		printk("dahdi_net_stop: %s is not a net device!\n", ms->name);
 		return 0;
 #else
-		printk("zt_net_close: %s is not a net device!\n", ms->name);
+		printk("dahdi_net_close: %s is not a net device!\n", ms->name);
 		return;
 #endif
 	}
 	/* Not much to do here.  Just deallocate the buffers */
         netif_stop_queue(ztchan_to_dev(ms));
-	zt_reallocbufs(ms, 0, 0);
+	dahdi_reallocbufs(ms, 0, 0);
 #ifdef LINUX26
 	hdlc_close(dev);
 #else
@@ -1552,10 +1552,10 @@ static void zt_net_close(hdlc_device *hdlc)
  just copy sources from dscc4 to be sure and ready for further mastering,
  NOOP right now (i.e. really a stub)  --byg */
 #ifdef LINUX26
-static int zt_net_attach(struct net_device *dev, unsigned short encoding,
+static int dahdi_net_attach(struct net_device *dev, unsigned short encoding,
         unsigned short parity)
 #else		
-static int zt_net_attach(hdlc_device *hdlc, unsigned short encoding,
+static int dahdi_net_attach(hdlc_device *hdlc, unsigned short encoding,
         unsigned short parity)
 #endif
 {
@@ -1582,33 +1582,33 @@ static int zt_net_attach(hdlc_device *hdlc, unsigned short encoding,
 }
 #endif
 																								 
-static struct zt_hdlc *zt_hdlc_alloc(void)
+static struct dahdi_hdlc *dahdi_hdlc_alloc(void)
 {
-	struct zt_hdlc *tmp;
-	tmp = kmalloc(sizeof(struct zt_hdlc), GFP_KERNEL);
+	struct dahdi_hdlc *tmp;
+	tmp = kmalloc(sizeof(struct dahdi_hdlc), GFP_KERNEL);
 	if (tmp) {
-		memset(tmp, 0, sizeof(struct zt_hdlc));
+		memset(tmp, 0, sizeof(struct dahdi_hdlc));
 	}
 	return tmp;
 }
 
 #ifdef NEW_HDLC_INTERFACE
-static int zt_xmit(struct sk_buff *skb, struct net_device *dev)
+static int dahdi_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	/* FIXME: this construction seems to be not very optimal for me but I could find nothing better at the moment (Friday, 10PM :( )  --byg */
-/*	struct zt_chan *ss = hdlc_to_ztchan(list_entry(dev, struct zt_hdlc, netdev.netdev));*/
+/*	struct dahdi_chan *ss = hdlc_to_ztchan(list_entry(dev, struct dahdi_hdlc, netdev.netdev));*/
 #ifdef LINUX26
-	struct zt_chan *ss = dev_to_ztchan(dev);
+	struct dahdi_chan *ss = dev_to_ztchan(dev);
 	struct net_device_stats *stats = hdlc_stats(dev);
 #else
-	struct zt_chan *ss = (list_entry(dev, struct zt_hdlc, netdev.netdev)->chan);
+	struct dahdi_chan *ss = (list_entry(dev, struct dahdi_hdlc, netdev.netdev)->chan);
 	struct net_device_stats *stats = &ss->hdlcnetdev->netdev.stats;
 #endif	
 
 #else
-static int zt_xmit(hdlc_device *hdlc, struct sk_buff *skb)
+static int dahdi_xmit(hdlc_device *hdlc, struct sk_buff *skb)
 {
-	struct zt_chan *ss = hdlc_to_ztchan(hdlc);
+	struct dahdi_chan *ss = hdlc_to_ztchan(hdlc);
 	struct net_device *dev = &ss->hdlcnetdev->netdev.netdev;
 	struct net_device_stats *stats = &ss->hdlcnetdev->netdev.stats;
 #endif
@@ -1620,7 +1620,7 @@ static int zt_xmit(hdlc_device *hdlc, struct sk_buff *skb)
 	/* See if we have any buffers */
 	spin_lock_irqsave(&ss->lock, flags);
 	if (skb->len > ss->blocksize - 2) {
-		printk(KERN_ERR "zt_xmit(%s): skb is too large (%d > %d)\n", dev->name, skb->len, ss->blocksize -2);
+		printk(KERN_ERR "dahdi_xmit(%s): skb is too large (%d > %d)\n", dev->name, skb->len, ss->blocksize -2);
 		stats->tx_dropped++;
 		retval = 0;
 	} else if (ss->inwritebuf >= 0) {
@@ -1672,12 +1672,12 @@ static int zt_xmit(hdlc_device *hdlc, struct sk_buff *skb)
 }
 
 #ifdef NEW_HDLC_INTERFACE
-static int zt_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+static int dahdi_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
 	return hdlc_ioctl(dev, ifr, cmd);
 }
 #else
-static int zt_net_ioctl(hdlc_device *hdlc, struct ifreq *ifr, int cmd)
+static int dahdi_net_ioctl(hdlc_device *hdlc, struct ifreq *ifr, int cmd)
 {
 	return -EIO;
 }
@@ -1687,7 +1687,7 @@ static int zt_net_ioctl(hdlc_device *hdlc, struct ifreq *ifr, int cmd)
 
 #ifdef CONFIG_ZAPATA_PPP
 
-static int zt_ppp_xmit(struct ppp_channel *ppp, struct sk_buff *skb)
+static int dahdi_ppp_xmit(struct ppp_channel *ppp, struct sk_buff *skb)
 {
 
 	/* 
@@ -1695,7 +1695,7 @@ static int zt_ppp_xmit(struct ppp_channel *ppp, struct sk_buff *skb)
 	 * we handle or drop it, return 1.  Always free if we return
 	 * 1 and never if we return 0
          */
-	struct zt_chan *ss = ppp->private;
+	struct dahdi_chan *ss = ppp->private;
 	int x,oldbuf;
 	unsigned int fcs;
 	unsigned char *data;
@@ -1704,11 +1704,11 @@ static int zt_ppp_xmit(struct ppp_channel *ppp, struct sk_buff *skb)
 
 	/* See if we have any buffers */
 	spin_lock_irqsave(&ss->lock, flags);
-	if (!(ss->flags & ZT_FLAG_OPEN)) {
+	if (!(ss->flags & DAHDI_FLAG_OPEN)) {
 		printk("Can't transmit on closed channel\n");
 		retval = 1;
 	} else if (skb->len > ss->blocksize - 4) {
-		printk(KERN_ERR "zt_ppp_xmit(%s): skb is too large (%d > %d)\n", ss->name, skb->len, ss->blocksize -2);
+		printk(KERN_ERR "dahdi_ppp_xmit(%s): skb is too large (%d > %d)\n", ss->name, skb->len, ss->blocksize -2);
 		retval = 1;
 	} else if (ss->inwritebuf >= 0) {
 		/* We have a place to put this packet */
@@ -1776,25 +1776,25 @@ static int zt_ppp_xmit(struct ppp_channel *ppp, struct sk_buff *skb)
 	return retval;
 }
 
-static int zt_ppp_ioctl(struct ppp_channel *ppp, unsigned int cmd, unsigned long flags)
+static int dahdi_ppp_ioctl(struct ppp_channel *ppp, unsigned int cmd, unsigned long flags)
 {
 	return -EIO;
 }
 
 static struct ppp_channel_ops ztppp_ops =
 {
-	start_xmit: zt_ppp_xmit,
-	ioctl: zt_ppp_ioctl,
+	start_xmit: dahdi_ppp_xmit,
+	ioctl: dahdi_ppp_ioctl,
 };
 
 #endif
 
-static void zt_chan_unreg(struct zt_chan *chan)
+static void dahdi_chan_unreg(struct dahdi_chan *chan)
 {
 	int x;
 	unsigned long flags;
 #ifdef CONFIG_ZAPATA_NET
-	if (chan->flags & ZT_FLAG_NETDEV) {
+	if (chan->flags & DAHDI_FLAG_NETDEV) {
 #ifdef LINUX26
 		unregister_hdlc_device(chan->hdlcnetdev->netdev);
 		free_netdev(chan->hdlcnetdev->netdev);
@@ -1806,9 +1806,9 @@ static void zt_chan_unreg(struct zt_chan *chan)
 	}
 #endif
 	write_lock_irqsave(&chan_lock, flags);
-	if (chan->flags & ZT_FLAG_REGISTERED) {
+	if (chan->flags & DAHDI_FLAG_REGISTERED) {
 		chans[chan->channo] = NULL;
-		chan->flags &= ~ZT_FLAG_REGISTERED;
+		chan->flags &= ~DAHDI_FLAG_REGISTERED;
 	}
 #ifdef CONFIG_ZAPATA_PPP
 	if (chan->ppp) {
@@ -1816,7 +1816,7 @@ static void zt_chan_unreg(struct zt_chan *chan)
 	}
 #endif
 	maxchans = 0;
-	for (x=1;x<ZT_MAX_CHANNELS;x++) 
+	for (x=1;x<DAHDI_MAX_CHANNELS;x++) 
 		if (chans[x]) {
 			maxchans = x + 1;
 			/* Remove anyone pointing to us as master
@@ -1825,17 +1825,17 @@ static void zt_chan_unreg(struct zt_chan *chan)
 				chans[x]->master = chans[x];
 			}
 			if ((chans[x]->confna == chan->channo) &&
-				((chans[x]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITOR ||
-				(chans[x]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITORTX ||
-				(chans[x]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITORBOTH ||
-				(chans[x]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITOR_RX_PREECHO ||
-				(chans[x]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITOR_TX_PREECHO ||
-				(chans[x]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITORBOTH_PREECHO ||
-				(chans[x]->confmode & ZT_CONF_MODE_MASK) == ZT_CONF_DIGITALMON)) {
+				((chans[x]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITOR ||
+				(chans[x]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITORTX ||
+				(chans[x]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITORBOTH ||
+				(chans[x]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITOR_RX_PREECHO ||
+				(chans[x]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITOR_TX_PREECHO ||
+				(chans[x]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITORBOTH_PREECHO ||
+				(chans[x]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_DIGITALMON)) {
 				/* Take them out of conference with us */
 				/* release conference resource if any */
 				if (chans[x]->confna) {
-					zt_check_conf(chans[x]->confna);
+					dahdi_check_conf(chans[x]->confna);
 					if (chans[x]->span && chans[x]->span->dacs)
 						chans[x]->span->dacs(chans[x], NULL);
 				}
@@ -1848,9 +1848,9 @@ static void zt_chan_unreg(struct zt_chan *chan)
 	write_unlock_irqrestore(&chan_lock, flags);
 }
 
-static ssize_t zt_chan_read(struct file *file, char *usrbuf, size_t count, int unit)
+static ssize_t dahdi_chan_read(struct file *file, char *usrbuf, size_t count, int unit)
 {
-	struct zt_chan *chan = chans[unit];
+	struct dahdi_chan *chan = chans[unit];
 	int amnt;
 	int res, rv;
 	int oldbuf,x;
@@ -1885,14 +1885,14 @@ static ssize_t zt_chan_read(struct file *file, char *usrbuf, size_t count, int u
 		int x;
 		if (amnt > chan->readn[res])
 			myamnt = chan->readn[res];
-		printk("zt_chan_read(unit: %d, inwritebuf: %d, outwritebuf: %d amnt: %d\n", 
+		printk("dahdi_chan_read(unit: %d, inwritebuf: %d, outwritebuf: %d amnt: %d\n", 
 			unit, chan->inwritebuf, chan->outwritebuf, myamnt);
 		printk("\t("); for (x = 0; x < myamnt; x++) printk((x ? " %02x" : "%02x"), (unsigned char)usrbuf[x]);
 		printk(")\n");
 	}
 #endif
 /* end addition */
-	if (chan->flags & ZT_FLAG_LINEAR) {
+	if (chan->flags & DAHDI_FLAG_LINEAR) {
 		if (amnt > (chan->readn[res] << 1))
 			amnt = chan->readn[res] << 1;
 		if (amnt) {
@@ -1907,7 +1907,7 @@ static ssize_t zt_chan_read(struct file *file, char *usrbuf, size_t count, int u
 				if (pass > 128)
 					pass = 128;
 				for (x=0;x<pass;x++)
-					lindata[x] = ZT_XLAW(chan->readbuf[res][x + pos], chan);
+					lindata[x] = DAHDI_XLAW(chan->readbuf[res][x + pos], chan);
 				if (copy_to_user(usrbuf + (pos << 1), lindata, pass << 1))
 					return -EFAULT;
 				left -= pass;
@@ -1930,7 +1930,7 @@ static ssize_t zt_chan_read(struct file *file, char *usrbuf, size_t count, int u
 	if (chan->outreadbuf == chan->inreadbuf) {
 		/* Out of stuff */
 		chan->outreadbuf = -1;
-		if (chan->rxbufpolicy == ZT_POLICY_WHEN_FULL)
+		if (chan->rxbufpolicy == DAHDI_POLICY_WHEN_FULL)
 			chan->rxdisable = 1;
 	}
 	if (chan->inreadbuf < 0) {
@@ -1942,10 +1942,10 @@ static ssize_t zt_chan_read(struct file *file, char *usrbuf, size_t count, int u
 	return amnt;
 }
 
-static ssize_t zt_chan_write(struct file *file, const char *usrbuf, size_t count, int unit)
+static ssize_t dahdi_chan_write(struct file *file, const char *usrbuf, size_t count, int unit)
 {
 	unsigned long flags;
-	struct zt_chan *chan = chans[unit];
+	struct dahdi_chan *chan = chans[unit];
 	int res, amnt, oldbuf, rv,x;
 	/* Make sure count never exceeds 65k, and make sure it's unsigned */
 	count &= 0xffff;
@@ -1955,7 +1955,7 @@ static ssize_t zt_chan_write(struct file *file, const char *usrbuf, size_t count
 		return -EINVAL;
 	for(;;) {
 		spin_lock_irqsave(&chan->lock, flags);
-		if ((chan->curtone || chan->pdialcount) && !(chan->flags & ZT_FLAG_PSEUDO)) {
+		if ((chan->curtone || chan->pdialcount) && !(chan->flags & DAHDI_FLAG_PSEUDO)) {
 			chan->curtone = NULL;
 			chan->tonep = 0;
 			chan->dialing = 0;
@@ -1979,7 +1979,7 @@ static ssize_t zt_chan_write(struct file *file, const char *usrbuf, size_t count
 	}
 
 	amnt = count;
-	if (chan->flags & ZT_FLAG_LINEAR) {
+	if (chan->flags & DAHDI_FLAG_LINEAR) {
 		if (amnt > (chan->blocksize << 1))
 			amnt = chan->blocksize << 1;
 	} else {
@@ -1988,13 +1988,13 @@ static ssize_t zt_chan_write(struct file *file, const char *usrbuf, size_t count
 	}
 
 #ifdef CONFIG_ZAPATA_DEBUG
-	printk("zt_chan_write(unit: %d, res: %d, outwritebuf: %d amnt: %d\n",
+	printk("dahdi_chan_write(unit: %d, res: %d, outwritebuf: %d amnt: %d\n",
 		unit, chan->res, chan->outwritebuf, amnt);
 #endif
 #if 0
  	if ((unit == 24) || (unit == 48) || (unit == 16) || (unit == 47)) { 
  		int x;
- 		printk("zt_chan_write/in(unit: %d, res: %d, outwritebuf: %d amnt: %d, txdisable: %d)\n",
+ 		printk("dahdi_chan_write/in(unit: %d, res: %d, outwritebuf: %d amnt: %d, txdisable: %d)\n",
  			unit, res, chan->outwritebuf, amnt, chan->txdisable);
  		printk("\t("); for (x = 0; x < amnt; x++) printk((x ? " %02x" : "%02x"), (unsigned char)usrbuf[x]);
  		printk(")\n");
@@ -2002,7 +2002,7 @@ static ssize_t zt_chan_write(struct file *file, const char *usrbuf, size_t count
 #endif
 
 	if (amnt) {
-		if (chan->flags & ZT_FLAG_LINEAR) {
+		if (chan->flags & DAHDI_FLAG_LINEAR) {
 			/* There seems to be a max stack size, so we have
 			   to do this in smaller pieces */
 			short lindata[128];
@@ -2017,7 +2017,7 @@ static ssize_t zt_chan_write(struct file *file, const char *usrbuf, size_t count
 					return -EFAULT;
 				left -= pass;
 				for (x=0;x<pass;x++)
-					chan->writebuf[res][x + pos] = ZT_LIN2X(lindata[x], chan);
+					chan->writebuf[res][x + pos] = DAHDI_LIN2X(lindata[x], chan);
 				pos += pass;
 			}
 			chan->writen[res] = amnt >> 1;
@@ -2027,7 +2027,7 @@ static ssize_t zt_chan_write(struct file *file, const char *usrbuf, size_t count
 			chan->writen[res] = amnt;
 		}
 		chan->writeidx[res] = 0;
-		if (chan->flags & ZT_FLAG_FCS)
+		if (chan->flags & DAHDI_FLAG_FCS)
 			calc_fcs(chan, res);
 		oldbuf = res;
 		spin_lock_irqsave(&chan->lock, flags);
@@ -2045,13 +2045,13 @@ static ssize_t zt_chan_write(struct file *file, const char *usrbuf, size_t count
 		}
 		spin_unlock_irqrestore(&chan->lock, flags);
 
-		if (chan->flags & ZT_FLAG_NOSTDTXRX && chan->span->hdlc_hard_xmit)
+		if (chan->flags & DAHDI_FLAG_NOSTDTXRX && chan->span->hdlc_hard_xmit)
 			chan->span->hdlc_hard_xmit(chan);
 	}
 	return amnt;
 }
 
-static int zt_ctl_open(struct inode *inode, struct file *file)
+static int dahdi_ctl_open(struct inode *inode, struct file *file)
 {
 	/* Nothing to do, really */
 #ifndef LINUX26
@@ -2060,7 +2060,7 @@ static int zt_ctl_open(struct inode *inode, struct file *file)
 	return 0;
 }
 
-static int zt_chan_open(struct inode *inode, struct file *file)
+static int dahdi_chan_open(struct inode *inode, struct file *file)
 {
 	/* Nothing to do here for now either */
 #ifndef LINUX26
@@ -2069,7 +2069,7 @@ static int zt_chan_open(struct inode *inode, struct file *file)
 	return 0;
 }
 
-static int zt_ctl_release(struct inode *inode, struct file *file)
+static int dahdi_ctl_release(struct inode *inode, struct file *file)
 {
 	/* Nothing to do */
 #ifndef LINUX26
@@ -2078,7 +2078,7 @@ static int zt_ctl_release(struct inode *inode, struct file *file)
 	return 0;
 }
 
-static int zt_chan_release(struct inode *inode, struct file *file)
+static int dahdi_chan_release(struct inode *inode, struct file *file)
 {
 	/* Nothing to do for now */
 #ifndef LINUX26
@@ -2087,7 +2087,7 @@ static int zt_chan_release(struct inode *inode, struct file *file)
 	return 0;
 }
 
-static void set_txtone(struct zt_chan *ss,int fac, int init_v2, int init_v3)
+static void set_txtone(struct dahdi_chan *ss,int fac, int init_v2, int init_v3)
 {
 	if (fac == 0)
 	{
@@ -2102,69 +2102,69 @@ static void set_txtone(struct zt_chan *ss,int fac, int init_v2, int init_v3)
 	return;
 }
 
-static void zt_rbs_sethook(struct zt_chan *chan, int txsig, int txstate, int timeout)
+static void dahdi_rbs_sethook(struct dahdi_chan *chan, int txsig, int txstate, int timeout)
 {
 static int outs[NUM_SIGS][5] = {
-/* We set the idle case of the ZT_SIG_NONE to this pattern to make idle E1 CAS
+/* We set the idle case of the DAHDI_SIG_NONE to this pattern to make idle E1 CAS
 channels happy. Should not matter with T1, since on an un-configured channel, 
 who cares what the sig bits are as long as they are stable */
-	{ ZT_SIG_NONE, 		ZT_ABIT | ZT_CBIT | ZT_DBIT, 0, 0, 0 },  /* no signalling */
-	{ ZT_SIG_EM, 		0, ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT,
-		ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT, 0 },  /* E and M */
-	{ ZT_SIG_FXSLS, 	ZT_BBIT | ZT_DBIT, 
-		ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT,
-			ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT, 0 }, /* FXS Loopstart */
-	{ ZT_SIG_FXSGS, 	ZT_BBIT | ZT_DBIT, 
+	{ DAHDI_SIG_NONE, 		DAHDI_ABIT | DAHDI_CBIT | DAHDI_DBIT, 0, 0, 0 },  /* no signalling */
+	{ DAHDI_SIG_EM, 		0, DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT,
+		DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT, 0 },  /* E and M */
+	{ DAHDI_SIG_FXSLS, 	DAHDI_BBIT | DAHDI_DBIT, 
+		DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT,
+			DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT, 0 }, /* FXS Loopstart */
+	{ DAHDI_SIG_FXSGS, 	DAHDI_BBIT | DAHDI_DBIT, 
 #ifdef CONFIG_CAC_GROUNDSTART
-		ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT, 0, 0 }, /* FXS Groundstart (CAC-style) */
+		DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT, 0, 0 }, /* FXS Groundstart (CAC-style) */
 #else
-		ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT, ZT_ABIT | ZT_CBIT, 0 }, /* FXS Groundstart (normal) */
+		DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT, DAHDI_ABIT | DAHDI_CBIT, 0 }, /* FXS Groundstart (normal) */
 #endif
-	{ ZT_SIG_FXSKS,		ZT_BBIT | ZT_DBIT, 
-		ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT,
-			ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT, 0 }, /* FXS Kewlstart */
-	{ ZT_SIG_FXOLS,		ZT_BBIT | ZT_DBIT, ZT_BBIT | ZT_DBIT, 0, 0 }, /* FXO Loopstart */
-	{ ZT_SIG_FXOGS,		ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT,
-		 ZT_BBIT | ZT_DBIT, 0, 0 }, /* FXO Groundstart */
-	{ ZT_SIG_FXOKS,		ZT_BBIT | ZT_DBIT, ZT_BBIT | ZT_DBIT, 0, 
-		ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT }, /* FXO Kewlstart */
-	{ ZT_SIG_SF,	ZT_BBIT | ZT_CBIT | ZT_DBIT, 
-			ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT, 
-			ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT, 
-			ZT_BBIT | ZT_CBIT | ZT_DBIT },  /* no signalling */
-	{ ZT_SIG_EM_E1, 	ZT_DBIT, ZT_ABIT | ZT_BBIT | ZT_DBIT,
-		ZT_ABIT | ZT_BBIT | ZT_DBIT, ZT_DBIT },  /* E and M  E1 */
+	{ DAHDI_SIG_FXSKS,		DAHDI_BBIT | DAHDI_DBIT, 
+		DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT,
+			DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT, 0 }, /* FXS Kewlstart */
+	{ DAHDI_SIG_FXOLS,		DAHDI_BBIT | DAHDI_DBIT, DAHDI_BBIT | DAHDI_DBIT, 0, 0 }, /* FXO Loopstart */
+	{ DAHDI_SIG_FXOGS,		DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT,
+		 DAHDI_BBIT | DAHDI_DBIT, 0, 0 }, /* FXO Groundstart */
+	{ DAHDI_SIG_FXOKS,		DAHDI_BBIT | DAHDI_DBIT, DAHDI_BBIT | DAHDI_DBIT, 0, 
+		DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT }, /* FXO Kewlstart */
+	{ DAHDI_SIG_SF,	DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT, 
+			DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT, 
+			DAHDI_ABIT | DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT, 
+			DAHDI_BBIT | DAHDI_CBIT | DAHDI_DBIT },  /* no signalling */
+	{ DAHDI_SIG_EM_E1, 	DAHDI_DBIT, DAHDI_ABIT | DAHDI_BBIT | DAHDI_DBIT,
+		DAHDI_ABIT | DAHDI_BBIT | DAHDI_DBIT, DAHDI_DBIT },  /* E and M  E1 */
 	} ;
 	int x;
 
 	/* if no span, return doing nothing */
 	if (!chan->span) return;
-	if (!chan->span->flags & ZT_FLAG_RBS) {
-		printk("zt_rbs: Tried to set RBS hook state on non-RBS channel %s\n", chan->name);
+	if (!chan->span->flags & DAHDI_FLAG_RBS) {
+		printk("dahdi_rbs: Tried to set RBS hook state on non-RBS channel %s\n", chan->name);
 		return;
 	}
 	if ((txsig > 3) || (txsig < 0)) {
-		printk("zt_rbs: Tried to set RBS hook state %d (> 3) on  channel %s\n", txsig, chan->name);
+		printk("dahdi_rbs: Tried to set RBS hook state %d (> 3) on  channel %s\n", txsig, chan->name);
 		return;
 	}
 	if (!chan->span->rbsbits && !chan->span->hooksig) {
-		printk("zt_rbs: Tried to set RBS hook state %d on channel %s while span %s lacks rbsbits or hooksig function\n",
+		printk("dahdi_rbs: Tried to set RBS hook state %d on channel %s while span %s lacks rbsbits or hooksig function\n",
 			txsig, chan->name, chan->span->name);
 		return;
 	}
 	/* Don't do anything for RBS */
-	if (chan->sig == ZT_SIG_DACS_RBS)
+	if (chan->sig == DAHDI_SIG_DACS_RBS)
 		return;
 	chan->txstate = txstate;
 	
 	/* if tone signalling */
-	if (chan->sig == ZT_SIG_SF)
+	if (chan->sig == DAHDI_SIG_SF)
 	{
 		chan->txhooksig = txsig;
 		if (chan->txtone) /* if set to make tone for tx */
 		{
-			if ((txsig && !(chan->toneflags & ZT_REVERSE_TXTONE)) ||
-			 ((!txsig) && (chan->toneflags & ZT_REVERSE_TXTONE))) 
+			if ((txsig && !(chan->toneflags & DAHDI_REVERSE_TXTONE)) ||
+			 ((!txsig) && (chan->toneflags & DAHDI_REVERSE_TXTONE))) 
 			{
 				set_txtone(chan,chan->txtone,chan->tx_v2,chan->tx_v3);
 			}
@@ -2173,7 +2173,7 @@ who cares what the sig bits are as long as they are stable */
 				set_txtone(chan,0,0,0);
 			}
 		}
-		chan->otimer = timeout * ZT_CHUNKSIZE;			/* Otimer is timer in samples */
+		chan->otimer = timeout * DAHDI_CHUNKSIZE;			/* Otimer is timer in samples */
 		return;
 	}
 	if (chan->span->hooksig) {
@@ -2181,7 +2181,7 @@ who cares what the sig bits are as long as they are stable */
 			chan->txhooksig = txsig;
 			chan->span->hooksig(chan, txsig);
 		}
-		chan->otimer = timeout * ZT_CHUNKSIZE;			/* Otimer is timer in samples */
+		chan->otimer = timeout * DAHDI_CHUNKSIZE;			/* Otimer is timer in samples */
 		return;
 	} else {
 		for (x=0;x<NUM_SIGS;x++) {
@@ -2192,15 +2192,15 @@ who cares what the sig bits are as long as they are stable */
 				chan->txhooksig = txsig;
 				chan->txsig = outs[x][txsig+1];
 				chan->span->rbsbits(chan, chan->txsig);
-				chan->otimer = timeout * ZT_CHUNKSIZE;	/* Otimer is timer in samples */
+				chan->otimer = timeout * DAHDI_CHUNKSIZE;	/* Otimer is timer in samples */
 				return;
 			}
 		}
 	}
-	printk("zt_rbs: Don't know RBS signalling type %d on channel %s\n", chan->sig, chan->name);
+	printk("dahdi_rbs: Don't know RBS signalling type %d on channel %s\n", chan->sig, chan->name);
 }
 
-static int zt_cas_setbits(struct zt_chan *chan, int bits)
+static int dahdi_cas_setbits(struct dahdi_chan *chan, int bits)
 {
 	/* if no span, return as error */
 	if (!chan->span) return -1;
@@ -2213,7 +2213,7 @@ static int zt_cas_setbits(struct zt_chan *chan, int bits)
 	return 0;
 }
 
-static int zt_hangup(struct zt_chan *chan)
+static int dahdi_hangup(struct dahdi_chan *chan)
 {
 	int x,res=0;
 
@@ -2221,37 +2221,37 @@ static int zt_hangup(struct zt_chan *chan)
 	if (!chan->span)
 		return 0;
 	/* Can't hang up a clear channel */
-	if (chan->flags & (ZT_FLAG_CLEAR | ZT_FLAG_NOSTDTXRX))
+	if (chan->flags & (DAHDI_FLAG_CLEAR | DAHDI_FLAG_NOSTDTXRX))
 		return -EINVAL;
 
 	chan->kewlonhook = 0;
 
 
-	if ((chan->sig == ZT_SIG_FXSLS) || (chan->sig == ZT_SIG_FXSKS) ||
-		(chan->sig == ZT_SIG_FXSGS)) chan->ringdebtimer = RING_DEBOUNCE_TIME;
+	if ((chan->sig == DAHDI_SIG_FXSLS) || (chan->sig == DAHDI_SIG_FXSKS) ||
+		(chan->sig == DAHDI_SIG_FXSGS)) chan->ringdebtimer = RING_DEBOUNCE_TIME;
 
-	if (chan->span->flags & ZT_FLAG_RBS) {
-		if (chan->sig == ZT_SIG_CAS) {
-			zt_cas_setbits(chan, chan->idlebits);
-		} else if ((chan->sig == ZT_SIG_FXOKS) && (chan->txstate != ZT_TXSTATE_ONHOOK)
+	if (chan->span->flags & DAHDI_FLAG_RBS) {
+		if (chan->sig == DAHDI_SIG_CAS) {
+			dahdi_cas_setbits(chan, chan->idlebits);
+		} else if ((chan->sig == DAHDI_SIG_FXOKS) && (chan->txstate != DAHDI_TXSTATE_ONHOOK)
 			/* if other party is already on-hook we shouldn't do any battery drop */
-			&& !((chan->rxhooksig == ZT_RXSIG_ONHOOK) && (chan->itimer <= 0))) {
+			&& !((chan->rxhooksig == DAHDI_RXSIG_ONHOOK) && (chan->itimer <= 0))) {
 			/* Do RBS signalling on the channel's behalf */
-			zt_rbs_sethook(chan, ZT_TXSIG_KEWL, ZT_TXSTATE_KEWL, ZT_KEWLTIME);
+			dahdi_rbs_sethook(chan, DAHDI_TXSIG_KEWL, DAHDI_TXSTATE_KEWL, DAHDI_KEWLTIME);
 		} else
-			zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_ONHOOK, 0);
+			dahdi_rbs_sethook(chan, DAHDI_TXSIG_ONHOOK, DAHDI_TXSTATE_ONHOOK, 0);
 	} else {
 		/* Let the driver hang up the line if it wants to  */
 		if (chan->span->sethook) {
-			if (chan->txhooksig != ZT_ONHOOK) {
-				chan->txhooksig = ZT_ONHOOK;
-				res = chan->span->sethook(chan, ZT_ONHOOK);
+			if (chan->txhooksig != DAHDI_ONHOOK) {
+				chan->txhooksig = DAHDI_ONHOOK;
+				res = chan->span->sethook(chan, DAHDI_ONHOOK);
 			} else
 				res = 0;
 		}
 	}
 	/* if not registered yet, just return here */
-	if (!(chan->flags & ZT_FLAG_REGISTERED)) return res;
+	if (!(chan->flags & DAHDI_FLAG_REGISTERED)) return res;
 	/* Mark all buffers as empty */
 	for (x = 0;x < chan->numbufs;x++) {
 		chan->writen[x] = 
@@ -2277,19 +2277,19 @@ static int zt_hangup(struct zt_chan *chan)
 	return res;
 }
 
-static int initialize_channel(struct zt_chan *chan)
+static int initialize_channel(struct dahdi_chan *chan)
 {
 	int res;
 	unsigned long flags;
 	void *rxgain=NULL;
 	struct echo_can_state *ec=NULL;
-	if ((res = zt_reallocbufs(chan, ZT_DEFAULT_BLOCKSIZE, ZT_DEFAULT_NUM_BUFS)))
+	if ((res = dahdi_reallocbufs(chan, DAHDI_DEFAULT_BLOCKSIZE, DAHDI_DEFAULT_NUM_BUFS)))
 		return res;
 
 	spin_lock_irqsave(&chan->lock, flags);
 
-	chan->rxbufpolicy = ZT_POLICY_IMMEDIATE;
-	chan->txbufpolicy = ZT_POLICY_IMMEDIATE;
+	chan->rxbufpolicy = DAHDI_POLICY_IMMEDIATE;
+	chan->txbufpolicy = DAHDI_POLICY_IMMEDIATE;
 
 	/* Free up the echo canceller if there is one */
 	ec = chan->ec;
@@ -2315,21 +2315,21 @@ static int initialize_channel(struct zt_chan *chan)
 	chan->infcs = PPP_INITFCS;
 	
 	/* Timings for RBS */
-	chan->prewinktime = ZT_DEFAULT_PREWINKTIME;
-	chan->preflashtime = ZT_DEFAULT_PREFLASHTIME;
-	chan->winktime = ZT_DEFAULT_WINKTIME;
-	chan->flashtime = ZT_DEFAULT_FLASHTIME;
+	chan->prewinktime = DAHDI_DEFAULT_PREWINKTIME;
+	chan->preflashtime = DAHDI_DEFAULT_PREFLASHTIME;
+	chan->winktime = DAHDI_DEFAULT_WINKTIME;
+	chan->flashtime = DAHDI_DEFAULT_FLASHTIME;
 	
-	if (chan->sig & __ZT_SIG_FXO)
-		chan->starttime = ZT_DEFAULT_RINGTIME;
+	if (chan->sig & __DAHDI_SIG_FXO)
+		chan->starttime = DAHDI_DEFAULT_RINGTIME;
 	else
-		chan->starttime = ZT_DEFAULT_STARTTIME;
-	chan->rxwinktime = ZT_DEFAULT_RXWINKTIME;
-	chan->rxflashtime = ZT_DEFAULT_RXFLASHTIME;
-	chan->debouncetime = ZT_DEFAULT_DEBOUNCETIME;
-	chan->pulsemaketime = ZT_DEFAULT_PULSEMAKETIME;
-	chan->pulsebreaktime = ZT_DEFAULT_PULSEBREAKTIME;
-	chan->pulseaftertime = ZT_DEFAULT_PULSEAFTERTIME;
+		chan->starttime = DAHDI_DEFAULT_STARTTIME;
+	chan->rxwinktime = DAHDI_DEFAULT_RXWINKTIME;
+	chan->rxflashtime = DAHDI_DEFAULT_RXFLASHTIME;
+	chan->debouncetime = DAHDI_DEFAULT_DEBOUNCETIME;
+	chan->pulsemaketime = DAHDI_DEFAULT_PULSEMAKETIME;
+	chan->pulsebreaktime = DAHDI_DEFAULT_PULSEBREAKTIME;
+	chan->pulseaftertime = DAHDI_DEFAULT_PULSEAFTERTIME;
 	
 	/* Initialize RBS timers */
 	chan->itimerset = chan->itimer = chan->otimer = 0;
@@ -2347,8 +2347,8 @@ static int initialize_channel(struct zt_chan *chan)
 	/* I/O Mask, etc */
 	chan->iomask = 0;
 	/* release conference resource if any */
-	if (chan->confna) zt_check_conf(chan->confna);
-	if ((chan->sig & __ZT_SIG_DACS) != __ZT_SIG_DACS) {
+	if (chan->confna) dahdi_check_conf(chan->confna);
+	if ((chan->sig & __DAHDI_SIG_DACS) != __DAHDI_SIG_DACS) {
 		chan->confna = 0;
 		chan->confmode = 0;
 		if (chan->span && chan->span->dacs)
@@ -2369,17 +2369,17 @@ static int initialize_channel(struct zt_chan *chan)
 	chan->txgain = defgain;
 	chan->gainalloc = 0;
 	chan->eventinidx = chan->eventoutidx = 0;
-	zt_set_law(chan,0);
-	zt_hangup(chan);
+	dahdi_set_law(chan,0);
+	dahdi_hangup(chan);
 
 	/* Make sure that the audio flag is cleared on a clear channel */
-	if ((chan->sig & ZT_SIG_CLEAR) || (chan->sig & ZT_SIG_HARDHDLC))
-		chan->flags &= ~ZT_FLAG_AUDIO;
+	if ((chan->sig & DAHDI_SIG_CLEAR) || (chan->sig & DAHDI_SIG_HARDHDLC))
+		chan->flags &= ~DAHDI_FLAG_AUDIO;
 
-	if ((chan->sig == ZT_SIG_CLEAR) || (chan->sig == ZT_SIG_HARDHDLC))
-		chan->flags &= ~(ZT_FLAG_PPP | ZT_FLAG_FCS | ZT_FLAG_HDLC);
+	if ((chan->sig == DAHDI_SIG_CLEAR) || (chan->sig == DAHDI_SIG_HARDHDLC))
+		chan->flags &= ~(DAHDI_FLAG_PPP | DAHDI_FLAG_FCS | DAHDI_FLAG_HDLC);
 
-	chan->flags &= ~ZT_FLAG_LINEAR;
+	chan->flags &= ~DAHDI_FLAG_LINEAR;
 	if (chan->curzone) {
 		/* Take cadence from tone zone */
 		memcpy(chan->ringcadence, chan->curzone->ringcadence, sizeof(chan->ringcadence));
@@ -2387,7 +2387,7 @@ static int initialize_channel(struct zt_chan *chan)
 		/* Do a default */
 		memset(chan->ringcadence, 0, sizeof(chan->ringcadence));
 		chan->ringcadence[0] = chan->starttime;
-		chan->ringcadence[1] = ZT_RINGOFFTIME;
+		chan->ringcadence[1] = DAHDI_RINGOFFTIME;
 	}
 
 	spin_unlock_irqrestore(&chan->lock, flags);
@@ -2402,15 +2402,15 @@ static int initialize_channel(struct zt_chan *chan)
 	return 0;
 }
 
-static int zt_timing_open(struct inode *inode, struct file *file)
+static int dahdi_timing_open(struct inode *inode, struct file *file)
 {
-	struct zt_timer *t;
+	struct dahdi_timer *t;
 	unsigned long flags;
-	t = kmalloc(sizeof(struct zt_timer), GFP_KERNEL);
+	t = kmalloc(sizeof(struct dahdi_timer), GFP_KERNEL);
 	if (!t)
 		return -ENOMEM;
 	/* Allocate a new timer */
-	memset(t, 0, sizeof(struct zt_timer));
+	memset(t, 0, sizeof(struct dahdi_timer));
 	init_waitqueue_head(&t->sel);
 	file->private_data = t;
 #ifndef LINUX26
@@ -2423,9 +2423,9 @@ static int zt_timing_open(struct inode *inode, struct file *file)
 	return 0;
 }
 
-static int zt_timer_release(struct inode *inode, struct file *file)
+static int dahdi_timer_release(struct inode *inode, struct file *file)
 {
-	struct zt_timer *t, *cur, *prev;
+	struct dahdi_timer *t, *cur, *prev;
 	unsigned long flags;
 	t = file->private_data;
 	if (t) {
@@ -2457,29 +2457,29 @@ static int zt_timer_release(struct inode *inode, struct file *file)
 	return 0;
 }
 
-static int zt_specchan_open(struct inode *inode, struct file *file, int unit, int inc)
+static int dahdi_specchan_open(struct inode *inode, struct file *file, int unit, int inc)
 {
 	int res = 0;
 
 	if (chans[unit] && chans[unit]->sig) {
 		/* Make sure we're not already open, a net device, or a slave device */
-		if (chans[unit]->flags & ZT_FLAG_NETDEV)
+		if (chans[unit]->flags & DAHDI_FLAG_NETDEV)
 			res = -EBUSY;
 		else if (chans[unit]->master != chans[unit])
 			res = -EBUSY;
-		else if ((chans[unit]->sig & __ZT_SIG_DACS) == __ZT_SIG_DACS)
+		else if ((chans[unit]->sig & __DAHDI_SIG_DACS) == __DAHDI_SIG_DACS)
 			res = -EBUSY;
-		else if (!test_and_set_bit(ZT_FLAGBIT_OPEN, &chans[unit]->flags)) {
+		else if (!test_and_set_bit(DAHDI_FLAGBIT_OPEN, &chans[unit]->flags)) {
 			unsigned long flags;
 			res = initialize_channel(chans[unit]);
 			if (res) {
 				/* Reallocbufs must have failed */
-				clear_bit(ZT_FLAGBIT_OPEN, &chans[unit]->flags);
+				clear_bit(DAHDI_FLAGBIT_OPEN, &chans[unit]->flags);
 				return res;
 			}
 			spin_lock_irqsave(&chans[unit]->lock, flags);
-			if (chans[unit]->flags & ZT_FLAG_PSEUDO) 
-				chans[unit]->flags |= ZT_FLAG_AUDIO;
+			if (chans[unit]->flags & DAHDI_FLAG_PSEUDO) 
+				chans[unit]->flags |= DAHDI_FLAG_AUDIO;
 			if (chans[unit]->span && chans[unit]->span->open) {
 				res = chans[unit]->span->open(chans[unit]);
 			}
@@ -2493,7 +2493,7 @@ static int zt_specchan_open(struct inode *inode, struct file *file, int unit, in
 			} else {
 				spin_unlock_irqrestore(&chans[unit]->lock, flags);
 				close_channel(chans[unit]);
-				clear_bit(ZT_FLAGBIT_OPEN, &chans[unit]->flags);
+				clear_bit(DAHDI_FLAGBIT_OPEN, &chans[unit]->flags);
 			}
 		} else
 			res = -EBUSY;
@@ -2502,7 +2502,7 @@ static int zt_specchan_open(struct inode *inode, struct file *file, int unit, in
 	return res;
 }
 
-static int zt_specchan_release(struct inode *node, struct file *file, int unit)
+static int dahdi_specchan_release(struct inode *node, struct file *file, int unit)
 {
 	int res=0;
 	unsigned long flags;
@@ -2516,7 +2516,7 @@ static int zt_specchan_release(struct inode *node, struct file *file, int unit)
 		close_channel(chans[unit]);
 		if (chans[unit]->span && chans[unit]->span->close)
 			res = chans[unit]->span->close(chans[unit]);
-		clear_bit(ZT_FLAGBIT_OPEN, &chans[unit]->flags);
+		clear_bit(DAHDI_FLAGBIT_OPEN, &chans[unit]->flags);
 	} else
 		res = -ENXIO;
 #ifndef LINUX26
@@ -2525,22 +2525,22 @@ static int zt_specchan_release(struct inode *node, struct file *file, int unit)
 	return res;
 }
 
-static struct zt_chan *zt_alloc_pseudo(void)
+static struct dahdi_chan *dahdi_alloc_pseudo(void)
 {
-	struct zt_chan *pseudo;
+	struct dahdi_chan *pseudo;
 	unsigned long flags;
 	/* Don't allow /dev/zap/pseudo to open if there are no spans */
 	if (maxspans < 1)
 		return NULL;
-	pseudo = kmalloc(sizeof(struct zt_chan), GFP_KERNEL);
+	pseudo = kmalloc(sizeof(struct dahdi_chan), GFP_KERNEL);
 	if (!pseudo)
 		return NULL;
-	memset(pseudo, 0, sizeof(struct zt_chan));
-	pseudo->sig = ZT_SIG_CLEAR;
-	pseudo->sigcap = ZT_SIG_CLEAR;
-	pseudo->flags = ZT_FLAG_PSEUDO | ZT_FLAG_AUDIO;
+	memset(pseudo, 0, sizeof(struct dahdi_chan));
+	pseudo->sig = DAHDI_SIG_CLEAR;
+	pseudo->sigcap = DAHDI_SIG_CLEAR;
+	pseudo->flags = DAHDI_FLAG_PSEUDO | DAHDI_FLAG_AUDIO;
 	spin_lock_irqsave(&bigzaplock, flags);
-	if (zt_chan_reg(pseudo)) {
+	if (dahdi_chan_reg(pseudo)) {
 		kfree(pseudo);
 		pseudo = NULL;
 	} else
@@ -2549,41 +2549,41 @@ static struct zt_chan *zt_alloc_pseudo(void)
 	return pseudo;	
 }
 
-static void zt_free_pseudo(struct zt_chan *pseudo)
+static void dahdi_free_pseudo(struct dahdi_chan *pseudo)
 {
 	unsigned long flags;
 	if (pseudo) {
 		spin_lock_irqsave(&bigzaplock, flags);
-		zt_chan_unreg(pseudo);
+		dahdi_chan_unreg(pseudo);
 		spin_unlock_irqrestore(&bigzaplock, flags);
 		kfree(pseudo);
 	}
 }
 
-static int zt_open(struct inode *inode, struct file *file)
+static int dahdi_open(struct inode *inode, struct file *file)
 {
 	int unit = UNIT(file);
 	int ret = -ENXIO;
-	struct zt_chan *chan;
+	struct dahdi_chan *chan;
 	/* Minor 0: Special "control" descriptor */
 	if (!unit) 
-		return zt_ctl_open(inode, file);
+		return dahdi_ctl_open(inode, file);
 	if (unit == 250) {
-		if (!zt_transcode_fops)
+		if (!dahdi_transcode_fops)
 			request_module("dahdi_transcode");
-		if (zt_transcode_fops && zt_transcode_fops->open) {
+		if (dahdi_transcode_fops && dahdi_transcode_fops->open) {
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-			if (zt_transcode_fops->owner) {
-				__MOD_INC_USE_COUNT (zt_transcode_fops->owner);
+			if (dahdi_transcode_fops->owner) {
+				__MOD_INC_USE_COUNT (dahdi_transcode_fops->owner);
 #else
-			if (try_module_get(zt_transcode_fops->owner)) {
+			if (try_module_get(dahdi_transcode_fops->owner)) {
 #endif
-				ret = zt_transcode_fops->open(inode, file);
+				ret = dahdi_transcode_fops->open(inode, file);
 				if (ret)
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-					__MOD_DEC_USE_COUNT (zt_transcode_fops->owner);
+					__MOD_DEC_USE_COUNT (dahdi_transcode_fops->owner);
 #else
-					module_put(zt_transcode_fops->owner);
+					module_put(dahdi_transcode_fops->owner);
 #endif
 			}
 			return ret;
@@ -2592,44 +2592,44 @@ static int zt_open(struct inode *inode, struct file *file)
 	}
 	if (unit == 253) {
 		if (maxspans) {
-			return zt_timing_open(inode, file);
+			return dahdi_timing_open(inode, file);
 		} else {
 			return -ENXIO;
 		}
 	}
 	if (unit == 254)
-		return zt_chan_open(inode, file);
+		return dahdi_chan_open(inode, file);
 	if (unit == 255) {
 		if (maxspans) {
-			chan = zt_alloc_pseudo();
+			chan = dahdi_alloc_pseudo();
 			if (chan) {
 				file->private_data = chan;
-				return zt_specchan_open(inode, file, chan->channo, 1);
+				return dahdi_specchan_open(inode, file, chan->channo, 1);
 			} else {
 				return -ENXIO;
 			}
 		} else
 			return -ENXIO;
 	}
-	return zt_specchan_open(inode, file, unit, 1);
+	return dahdi_specchan_open(inode, file, unit, 1);
 }
 
 #if 0
-static int zt_open(struct inode *inode, struct file *file)
+static int dahdi_open(struct inode *inode, struct file *file)
 {
 	int res;
 	unsigned long flags;
 	spin_lock_irqsave(&bigzaplock, flags);
-	res = __zt_open(inode, file);
+	res = __dahdi_open(inode, file);
 	spin_unlock_irqrestore(&bigzaplock, flags);
 	return res;
 }
 #endif
 
-static ssize_t zt_read(struct file *file, char *usrbuf, size_t count, loff_t *ppos)
+static ssize_t dahdi_read(struct file *file, char *usrbuf, size_t count, loff_t *ppos)
 {
 	int unit = UNIT(file);
-	struct zt_chan *chan;
+	struct dahdi_chan *chan;
 
 	/* Can't read from control */
 	if (!unit) {
@@ -2643,7 +2643,7 @@ static ssize_t zt_read(struct file *file, char *usrbuf, size_t count, loff_t *pp
 		chan = file->private_data;
 		if (!chan)
 			return -EINVAL;
-		return zt_chan_read(file, usrbuf, count, chan->channo);
+		return dahdi_chan_read(file, usrbuf, count, chan->channo);
 	}
 	
 	if (unit == 255) {
@@ -2652,18 +2652,18 @@ static ssize_t zt_read(struct file *file, char *usrbuf, size_t count, loff_t *pp
 			printk("No pseudo channel structure to read?\n");
 			return -EINVAL;
 		}
-		return zt_chan_read(file, usrbuf, count, chan->channo);
+		return dahdi_chan_read(file, usrbuf, count, chan->channo);
 	}
 	if (count < 0)
 		return -EINVAL;
 
-	return zt_chan_read(file, usrbuf, count, unit);
+	return dahdi_chan_read(file, usrbuf, count, unit);
 }
 
-static ssize_t zt_write(struct file *file, const char *usrbuf, size_t count, loff_t *ppos)
+static ssize_t dahdi_write(struct file *file, const char *usrbuf, size_t count, loff_t *ppos)
 {
 	int unit = UNIT(file);
-	struct zt_chan *chan;
+	struct dahdi_chan *chan;
 	/* Can't read from control */
 	if (!unit)
 		return -EINVAL;
@@ -2675,7 +2675,7 @@ static ssize_t zt_write(struct file *file, const char *usrbuf, size_t count, lof
 		chan = file->private_data;
 		if (!chan)
 			return -EINVAL;
-		return zt_chan_write(file, usrbuf, count, chan->channo);
+		return dahdi_chan_write(file, usrbuf, count, chan->channo);
 	}
 	if (unit == 255) {
 		chan = file->private_data;
@@ -2683,15 +2683,15 @@ static ssize_t zt_write(struct file *file, const char *usrbuf, size_t count, lof
 			printk("No pseudo channel structure to read?\n");
 			return -EINVAL;
 		}
-		return zt_chan_write(file, usrbuf, count, chan->channo);
+		return dahdi_chan_write(file, usrbuf, count, chan->channo);
 	}
-	return zt_chan_write(file, usrbuf, count, unit);
+	return dahdi_chan_write(file, usrbuf, count, unit);
 	
 }
 
-static int zt_set_default_zone(int defzone)
+static int dahdi_set_default_zone(int defzone)
 {
-	if ((defzone < 0) || (defzone >= ZT_TONE_ZONE_MAX))
+	if ((defzone < 0) || (defzone >= DAHDI_TONE_ZONE_MAX))
 		return -EINVAL;
 	write_lock(&zone_lock);
 	if (!tone_zones[defzone]) {
@@ -2719,19 +2719,19 @@ static int zt_set_default_zone(int defzone)
 */
 static int ioctl_load_zone(unsigned long data)
 {
-	struct zt_tone *samples[MAX_TONES] = { NULL, };
+	struct dahdi_tone *samples[MAX_TONES] = { NULL, };
 	short next[MAX_TONES] = { 0, };
-	struct zt_tone_def_header th;
-	struct zt_tone_def td;
-	struct zt_zone *z;
-	struct zt_tone *t;
+	struct dahdi_tone_def_header th;
+	struct dahdi_tone_def td;
+	struct dahdi_zone *z;
+	struct dahdi_tone *t;
 	void *slab, *ptr;
 	int x;
 	size_t space;
 	size_t size;
 	int res;
 	
-	if (copy_from_user(&th, (struct zt_tone_def_header *) data, sizeof(th)))
+	if (copy_from_user(&th, (struct dahdi_tone_def_header *) data, sizeof(th)))
 		return -EFAULT;
 
 	data += sizeof(th);
@@ -2756,7 +2756,7 @@ static int ioctl_load_zone(unsigned long data)
 
 	zap_copy_string(z->name, th.name, sizeof(z->name));
 
-	for (x = 0; x < ZT_MAX_CADENCE; x++)
+	for (x = 0; x < DAHDI_MAX_CADENCE; x++)
 		z->ringcadence[x] = th.ringcadence[x];
 
 	atomic_set(&z->refcount, 0);
@@ -2776,14 +2776,14 @@ static int ioctl_load_zone(unsigned long data)
 			return -EINVAL;
 		}
 
-		if (copy_from_user(&td, (struct zt_tone_def *) data, sizeof(td))) {
+		if (copy_from_user(&td, (struct dahdi_tone_def *) data, sizeof(td))) {
 			kfree(slab);
 			return -EFAULT;
 		}
 
 		data += sizeof(td);
 
-		if ((td.tone >= 0) && (td.tone < ZT_TONE_MAX)) {
+		if ((td.tone >= 0) && (td.tone < DAHDI_TONE_MAX)) {
 			tone_type = REGULAR_TONE;
 
 			t = samples[x] = ptr;
@@ -2800,25 +2800,25 @@ static int ioctl_load_zone(unsigned long data)
 				kfree(slab);
 				return -EINVAL;
 			}
-		} else if ((td.tone >= ZT_TONE_DTMF_BASE) &&
-			   (td.tone <= ZT_TONE_DTMF_MAX)) {
+		} else if ((td.tone >= DAHDI_TONE_DTMF_BASE) &&
+			   (td.tone <= DAHDI_TONE_DTMF_MAX)) {
 			tone_type = DTMF_TONE;
-			td.tone -= ZT_TONE_DTMF_BASE;
+			td.tone -= DAHDI_TONE_DTMF_BASE;
 			t = &z->dtmf[td.tone];
-		} else if ((td.tone >= ZT_TONE_MFR1_BASE) &&
-			   (td.tone <= ZT_TONE_MFR1_MAX)) {
+		} else if ((td.tone >= DAHDI_TONE_MFR1_BASE) &&
+			   (td.tone <= DAHDI_TONE_MFR1_MAX)) {
 			tone_type = MFR1_TONE;
-			td.tone -= ZT_TONE_MFR1_BASE;
+			td.tone -= DAHDI_TONE_MFR1_BASE;
 			t = &z->mfr1[td.tone];
-		} else if ((td.tone >= ZT_TONE_MFR2_FWD_BASE) &&
-			   (td.tone <= ZT_TONE_MFR2_FWD_MAX)) {
+		} else if ((td.tone >= DAHDI_TONE_MFR2_FWD_BASE) &&
+			   (td.tone <= DAHDI_TONE_MFR2_FWD_MAX)) {
 			tone_type = MFR2_FWD_TONE;
-			td.tone -= ZT_TONE_MFR2_FWD_BASE;
+			td.tone -= DAHDI_TONE_MFR2_FWD_BASE;
 			t = &z->mfr2_fwd[td.tone];
-		} else if ((td.tone >= ZT_TONE_MFR2_REV_BASE) &&
-			   (td.tone <= ZT_TONE_MFR2_REV_MAX)) {
+		} else if ((td.tone >= DAHDI_TONE_MFR2_REV_BASE) &&
+			   (td.tone <= DAHDI_TONE_MFR2_REV_MAX)) {
 			tone_type = MFR2_REV_TONE;
-			td.tone -= ZT_TONE_MFR2_REV_BASE;
+			td.tone -= DAHDI_TONE_MFR2_REV_BASE;
 			t = &z->mfr2_rev[td.tone];
 		} else {
 			printk("Invalid tone (%d) defined\n", td.tone);
@@ -2847,14 +2847,14 @@ static int ioctl_load_zone(unsigned long data)
 			z->dtmf_continuous[td.tone].next = &z->dtmf_continuous[td.tone];
 			break;
 		case MFR1_TONE:
-			switch (td.tone + ZT_TONE_MFR1_BASE) {
-			case ZT_TONE_MFR1_KP:
-			case ZT_TONE_MFR1_ST:
-			case ZT_TONE_MFR1_STP:
-			case ZT_TONE_MFR1_ST2P:
-			case ZT_TONE_MFR1_ST3P:
+			switch (td.tone + DAHDI_TONE_MFR1_BASE) {
+			case DAHDI_TONE_MFR1_KP:
+			case DAHDI_TONE_MFR1_ST:
+			case DAHDI_TONE_MFR1_STP:
+			case DAHDI_TONE_MFR1_ST2P:
+			case DAHDI_TONE_MFR1_ST3P:
 				/* signaling control tones are always 100ms */
-				t->tonesamples = 100 * ZT_CHUNKSIZE;
+				t->tonesamples = 100 * DAHDI_CHUNKSIZE;
 				break;
 			default:
 				t->tonesamples = global_dialparams.mfv1_tonelen;
@@ -2882,18 +2882,18 @@ static int ioctl_load_zone(unsigned long data)
 			samples[x]->next = samples[next[x]];
 	}
 
-	if ((res = zt_register_tone_zone(th.zone, z))) {
+	if ((res = dahdi_register_tone_zone(th.zone, z))) {
 		kfree(slab);
 	} else {
 		if ( -1 == default_zone ) {
-			zt_set_default_zone(th.zone);
+			dahdi_set_default_zone(th.zone);
 		}
 	}
 
 	return res;
 }
 
-void zt_init_tone_state(struct zt_tone_state *ts, struct zt_tone *zt)
+void dahdi_init_tone_state(struct dahdi_tone_state *ts, struct dahdi_tone *zt)
 {
 	ts->v1_1 = 0;
 	ts->v2_1 = zt->init_v2_1;
@@ -2904,7 +2904,7 @@ void zt_init_tone_state(struct zt_tone_state *ts, struct zt_tone *zt)
 	ts->modulate = zt->modulate;
 }
 
-struct zt_tone *zt_mf_tone(const struct zt_chan *chan, char digit, int digitmode)
+struct dahdi_tone *dahdi_mf_tone(const struct dahdi_chan *chan, char digit, int digitmode)
 {
 	unsigned int tone_index;
 
@@ -2931,25 +2931,25 @@ struct zt_tone *zt_mf_tone(const struct zt_chan *chan, char digit, int digitmode
 		case '7':
 		case '8':
 		case '9':
-			tone_index = ZT_TONE_DTMF_0 + (digit - '0');
+			tone_index = DAHDI_TONE_DTMF_0 + (digit - '0');
 			break;
 		case '*':
-			tone_index = ZT_TONE_DTMF_s;
+			tone_index = DAHDI_TONE_DTMF_s;
 			break;
 		case '#':
-			tone_index = ZT_TONE_DTMF_p;
+			tone_index = DAHDI_TONE_DTMF_p;
 			break;
 		case 'A':
 		case 'B':
 		case 'C':
 		case 'D':
-			tone_index = ZT_TONE_DTMF_A + (digit - 'A');
+			tone_index = DAHDI_TONE_DTMF_A + (digit - 'A');
 		case 'W':
 			return &tone_pause;
 		default:
 			return NULL;
 		}
-		return &chan->curzone->dtmf[tone_index - ZT_TONE_DTMF_BASE];
+		return &chan->curzone->dtmf[tone_index - DAHDI_TONE_DTMF_BASE];
 	case DIGIT_MODE_MFR1:
 		switch (digit) {
 		case '0':
@@ -2962,29 +2962,29 @@ struct zt_tone *zt_mf_tone(const struct zt_chan *chan, char digit, int digitmode
 		case '7':
 		case '8':
 		case '9':
-			tone_index = ZT_TONE_MFR1_0 + (digit - '0');
+			tone_index = DAHDI_TONE_MFR1_0 + (digit - '0');
 			break;
 		case '*':
-			tone_index = ZT_TONE_MFR1_KP;
+			tone_index = DAHDI_TONE_MFR1_KP;
 			break;
 		case '#':
-			tone_index = ZT_TONE_MFR1_ST;
+			tone_index = DAHDI_TONE_MFR1_ST;
 			break;
 		case 'A':
-			tone_index = ZT_TONE_MFR1_STP;
+			tone_index = DAHDI_TONE_MFR1_STP;
 			break;
 		case 'B':
-			tone_index = ZT_TONE_MFR1_ST2P;
+			tone_index = DAHDI_TONE_MFR1_ST2P;
 			break;
 		case 'C':
-			tone_index = ZT_TONE_MFR1_ST3P;
+			tone_index = DAHDI_TONE_MFR1_ST3P;
 			break;
 		case 'W':
 			return &tone_pause;
 		default:
 			return NULL;
 		}
-		return &chan->curzone->mfr1[tone_index - ZT_TONE_MFR1_BASE];
+		return &chan->curzone->mfr1[tone_index - DAHDI_TONE_MFR1_BASE];
 	case DIGIT_MODE_MFR2_FWD:
 		switch (digit) {
 		case '1':
@@ -2996,7 +2996,7 @@ struct zt_tone *zt_mf_tone(const struct zt_chan *chan, char digit, int digitmode
 		case '7':
 		case '8':
 		case '9':
-			tone_index = ZT_TONE_MFR2_FWD_1 + (digit - '1');
+			tone_index = DAHDI_TONE_MFR2_FWD_1 + (digit - '1');
 			break;
 		case 'A':
 		case 'B':
@@ -3004,14 +3004,14 @@ struct zt_tone *zt_mf_tone(const struct zt_chan *chan, char digit, int digitmode
 		case 'D':
 		case 'E':
 		case 'F':
-			tone_index = ZT_TONE_MFR2_FWD_10 + (digit - 'A');
+			tone_index = DAHDI_TONE_MFR2_FWD_10 + (digit - 'A');
 			break;
 		case 'W':
 			return &tone_pause;
 		default:
 			return NULL;
 		}
-		return &chan->curzone->mfr2_fwd[tone_index - ZT_TONE_MFR2_FWD_BASE];
+		return &chan->curzone->mfr2_fwd[tone_index - DAHDI_TONE_MFR2_FWD_BASE];
 	case DIGIT_MODE_MFR2_REV:
 		switch (digit) {
 		case '1':
@@ -3023,7 +3023,7 @@ struct zt_tone *zt_mf_tone(const struct zt_chan *chan, char digit, int digitmode
 		case '7':
 		case '8':
 		case '9':
-			tone_index = ZT_TONE_MFR2_REV_1 + (digit - '1');
+			tone_index = DAHDI_TONE_MFR2_REV_1 + (digit - '1');
 			break;
 		case 'A':
 		case 'B':
@@ -3031,20 +3031,20 @@ struct zt_tone *zt_mf_tone(const struct zt_chan *chan, char digit, int digitmode
 		case 'D':
 		case 'E':
 		case 'F':
-			tone_index = ZT_TONE_MFR2_REV_10 + (digit - 'A');
+			tone_index = DAHDI_TONE_MFR2_REV_10 + (digit - 'A');
 			break;
 		case 'W':
 			return &tone_pause;
 		default:
 			return NULL;
 		}
-		return &chan->curzone->mfr2_rev[tone_index - ZT_TONE_MFR2_REV_BASE];
+		return &chan->curzone->mfr2_rev[tone_index - DAHDI_TONE_MFR2_REV_BASE];
 	default:
 		return NULL;
 	}
 }
 
-static void __do_dtmf(struct zt_chan *chan)
+static void __do_dtmf(struct dahdi_chan *chan)
 {
 	char c;
 
@@ -3074,17 +3074,17 @@ static void __do_dtmf(struct zt_chan *chan)
 			break;
 		default:
 			if ((c != 'W') && (chan->digitmode == DIGIT_MODE_PULSE)) {
-				if ((c >= '0') && (c <= '9') && (chan->txhooksig == ZT_TXSIG_OFFHOOK)) {
+				if ((c >= '0') && (c <= '9') && (chan->txhooksig == DAHDI_TXSIG_OFFHOOK)) {
 					chan->pdialcount = (c == '0') ? 10 : c - '0';
-					zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_PULSEBREAK,
+					dahdi_rbs_sethook(chan, DAHDI_TXSIG_ONHOOK, DAHDI_TXSTATE_PULSEBREAK,
 						       chan->pulsebreaktime);
 					return;
 				}
 			} else {
-				chan->curtone = zt_mf_tone(chan, c, chan->digitmode);
+				chan->curtone = dahdi_mf_tone(chan, c, chan->digitmode);
 				chan->tonep = 0;
 				if (chan->curtone) {
-					zt_init_tone_state(&chan->ts, chan->curtone);
+					dahdi_init_tone_state(&chan->ts, chan->curtone);
 					return;
 				}
 			}
@@ -3093,85 +3093,85 @@ static void __do_dtmf(struct zt_chan *chan)
 
 	/* Notify userspace process if there is nothing left */
 	chan->dialing = 0;
-	__qevent(chan, ZT_EVENT_DIALCOMPLETE);
+	__qevent(chan, DAHDI_EVENT_DIALCOMPLETE);
 }
 
-static int zt_release(struct inode *inode, struct file *file)
+static int dahdi_release(struct inode *inode, struct file *file)
 {
 	int unit = UNIT(file);
 	int res;
-	struct zt_chan *chan;
+	struct dahdi_chan *chan;
 
 	if (!unit) 
-		return zt_ctl_release(inode, file);
+		return dahdi_ctl_release(inode, file);
 	if (unit == 253) {
-		return zt_timer_release(inode, file);
+		return dahdi_timer_release(inode, file);
 	}
 	if (unit == 250) {
-		res = zt_transcode_fops->release(inode, file);
+		res = dahdi_transcode_fops->release(inode, file);
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-		if (zt_transcode_fops->owner)
-			__MOD_DEC_USE_COUNT (zt_transcode_fops->owner);
+		if (dahdi_transcode_fops->owner)
+			__MOD_DEC_USE_COUNT (dahdi_transcode_fops->owner);
 #else
-		module_put(zt_transcode_fops->owner);
+		module_put(dahdi_transcode_fops->owner);
 #endif
 		return res;
 	}
 	if (unit == 254) {
 		chan = file->private_data;
 		if (!chan)
-			return zt_chan_release(inode, file);
+			return dahdi_chan_release(inode, file);
 		else
-			return zt_specchan_release(inode, file, chan->channo);
+			return dahdi_specchan_release(inode, file, chan->channo);
 	}
 	if (unit == 255) {
 		chan = file->private_data;
 		if (chan) {
-			res = zt_specchan_release(inode, file, chan->channo);
-			zt_free_pseudo(chan);
+			res = dahdi_specchan_release(inode, file, chan->channo);
+			dahdi_free_pseudo(chan);
 		} else {
 			printk("Pseudo release and no private data??\n");
 			res = 0;
 		}
 		return res;
 	}
-	return zt_specchan_release(inode, file, unit);
+	return dahdi_specchan_release(inode, file, unit);
 }
 
 #if 0
-static int zt_release(struct inode *inode, struct file *file)
+static int dahdi_release(struct inode *inode, struct file *file)
 {
 	/* Lock the big zap lock when handling a release */
 	unsigned long flags;
 	int res;
 	spin_lock_irqsave(&bigzaplock, flags);
-	res = __zt_release(inode, file);
+	res = __dahdi_release(inode, file);
 	spin_unlock_irqrestore(&bigzaplock, flags);
 	return res;
 }
 #endif
 
 
-void zt_alarm_channel(struct zt_chan *chan, int alarms)
+void dahdi_alarm_channel(struct dahdi_chan *chan, int alarms)
 {
 	unsigned long flags;
 
 	spin_lock_irqsave(&chan->lock, flags);
 	if (chan->chan_alarms != alarms) {
 		chan->chan_alarms = alarms;
-		zt_qevent_nolock(chan, alarms ? ZT_EVENT_ALARM : ZT_EVENT_NOALARM);
+		dahdi_qevent_nolock(chan, alarms ? DAHDI_EVENT_ALARM : DAHDI_EVENT_NOALARM);
 	}
 	spin_unlock_irqrestore(&chan->lock, flags);
 }
 
-void zt_alarm_notify(struct zt_span *span)
+void dahdi_alarm_notify(struct dahdi_span *span)
 {
 	int x;
 
-	span->alarms &= ~ZT_ALARM_LOOPBACK;
+	span->alarms &= ~DAHDI_ALARM_LOOPBACK;
 	/* Determine maint status */
 	if (span->maintstat || span->mainttimer)
-		span->alarms |= ZT_ALARM_LOOPBACK;
+		span->alarms |= DAHDI_ALARM_LOOPBACK;
 	/* DON'T CHANGE THIS AGAIN. THIS WAS DONE FOR A REASON.
  	   The expression (a != b) does *NOT* do the same thing
 	   as ((!a) != (!b)) */
@@ -3179,10 +3179,10 @@ void zt_alarm_notify(struct zt_span *span)
 	if ((!span->alarms) != (!span->lastalarms)) {
 		span->lastalarms = span->alarms;
 		for (x = 0; x < span->channels; x++)
-			zt_alarm_channel(&span->chans[x], span->alarms);
+			dahdi_alarm_channel(&span->chans[x], span->alarms);
 		/* Switch to other master if current master in alarm */
 		for (x=1; x<maxspans; x++) {
-			if (spans[x] && !spans[x]->alarms && (spans[x]->flags & ZT_FLAG_RUNNING)) {
+			if (spans[x] && !spans[x]->alarms && (spans[x]->flags & DAHDI_FLAG_RUNNING)) {
 				if(master != spans[x])
 					printk("Zaptel: Master changed to %s\n", spans[x]->name);
 				master = spans[x];
@@ -3193,7 +3193,7 @@ void zt_alarm_notify(struct zt_span *span)
 }
 
 #define VALID_SPAN(j) do { \
-	if ((j >= ZT_MAX_SPANS) || (j < 1)) \
+	if ((j >= DAHDI_MAX_SPANS) || (j < 1)) \
 		return -EINVAL; \
 	if (!spans[j]) \
 		return -ENXIO; \
@@ -3207,18 +3207,18 @@ void zt_alarm_notify(struct zt_span *span)
 } while(0)
 
 #define VALID_CHANNEL(j) do { \
-	if ((j >= ZT_MAX_CHANNELS) || (j < 1)) \
+	if ((j >= DAHDI_MAX_CHANNELS) || (j < 1)) \
 		return -EINVAL; \
 	if (!chans[j]) \
 		return -ENXIO; \
 } while(0)
 
-static int zt_timer_ioctl(struct inode *node, struct file *file, unsigned int cmd, unsigned long data, struct zt_timer *timer)
+static int dahdi_timer_ioctl(struct inode *node, struct file *file, unsigned int cmd, unsigned long data, struct dahdi_timer *timer)
 {
 	int j;
 	unsigned long flags;
 	switch(cmd) {
-	case ZT_TIMERCONFIG:
+	case DAHDI_TIMERCONFIG:
 		get_user(j, (int *)data);
 		if (j < 0)
 			j = 0;
@@ -3226,7 +3226,7 @@ static int zt_timer_ioctl(struct inode *node, struct file *file, unsigned int cm
 		timer->ms = timer->pos = j;
 		spin_unlock_irqrestore(&zaptimerlock, flags);
 		break;
-	case ZT_TIMERACK:
+	case DAHDI_TIMERACK:
 		get_user(j, (int *)data);
 		spin_lock_irqsave(&zaptimerlock, flags);
 		if ((j < 1) || (j > timer->tripped))
@@ -3234,24 +3234,24 @@ static int zt_timer_ioctl(struct inode *node, struct file *file, unsigned int cm
 		timer->tripped -= j;
 		spin_unlock_irqrestore(&zaptimerlock, flags);
 		break;
-	case ZT_GETEVENT:  /* Get event on queue */
-		j = ZT_EVENT_NONE;
+	case DAHDI_GETEVENT:  /* Get event on queue */
+		j = DAHDI_EVENT_NONE;
 		spin_lock_irqsave(&zaptimerlock, flags);
 		  /* set up for no event */
 		if (timer->tripped)
-			j = ZT_EVENT_TIMER_EXPIRED;
+			j = DAHDI_EVENT_TIMER_EXPIRED;
 		if (timer->ping)
-			j = ZT_EVENT_TIMER_PING;
+			j = DAHDI_EVENT_TIMER_PING;
 		spin_unlock_irqrestore(&zaptimerlock, flags);
 		put_user(j,(int *)data);
 		break;
-	case ZT_TIMERPING:
+	case DAHDI_TIMERPING:
 		spin_lock_irqsave(&zaptimerlock, flags);
 		timer->ping = 1;
 		wake_up_interruptible(&timer->sel);
 		spin_unlock_irqrestore(&zaptimerlock, flags);
 		break;
-	case ZT_TIMERPONG:
+	case DAHDI_TIMERPONG:
 		spin_lock_irqsave(&zaptimerlock, flags);
 		timer->ping = 0;
 		spin_unlock_irqrestore(&zaptimerlock, flags);
@@ -3262,34 +3262,34 @@ static int zt_timer_ioctl(struct inode *node, struct file *file, unsigned int cm
 	return 0;
 }
 
-static int zt_common_ioctl(struct inode *node, struct file *file, unsigned int cmd, unsigned long data, int unit)
+static int dahdi_common_ioctl(struct inode *node, struct file *file, unsigned int cmd, unsigned long data, int unit)
 {
 	union {
-		struct zt_gains gain;
-		struct zt_spaninfo spaninfo;
-		struct zt_params param;
+		struct dahdi_gains gain;
+		struct dahdi_spaninfo spaninfo;
+		struct dahdi_params param;
 	} stack;
-	struct zt_chan *chan;
+	struct dahdi_chan *chan;
 	unsigned long flags;
 	unsigned char *txgain, *rxgain;
-	struct zt_chan *mychan;
+	struct dahdi_chan *mychan;
 	int i,j;
 	int return_master = 0;
 	size_t size_to_copy;
 
 	switch(cmd) {
 		/* get channel parameters */
-	case ZT_GET_PARAMS_V1:
-	case ZT_GET_PARAMS:
-		size_to_copy = (cmd == ZT_GET_PARAMS_V1) ? sizeof(struct zt_params_v1) :
-			       sizeof(struct zt_params);
-		if (copy_from_user(&stack.param, (struct zt_params *) data, size_to_copy))
+	case DAHDI_GET_PARAMS_V1:
+	case DAHDI_GET_PARAMS:
+		size_to_copy = (cmd == DAHDI_GET_PARAMS_V1) ? sizeof(struct dahdi_params_v1) :
+			       sizeof(struct dahdi_params);
+		if (copy_from_user(&stack.param, (struct dahdi_params *) data, size_to_copy))
 			return -EFAULT;
 
 		/* check to see if the caller wants to receive our master channel number */
-		if (stack.param.channo & ZT_GET_PARAMS_RETURN_MASTER) {
+		if (stack.param.channo & DAHDI_GET_PARAMS_RETURN_MASTER) {
 			return_master = 1;
-			stack.param.channo &= ~ZT_GET_PARAMS_RETURN_MASTER;
+			stack.param.channo &= ~DAHDI_GET_PARAMS_RETURN_MASTER;
 		}
 
 		/* Pick the right channo's */
@@ -3304,18 +3304,18 @@ static int zt_common_ioctl(struct inode *node, struct file *file, unsigned int c
 		stack.param.sigtype = chan->sig;  /* get signalling type */
 		/* return non-zero if rx not in idle state */
 		if (chan->span) {
-			j = zt_q_sig(chan); 
+			j = dahdi_q_sig(chan); 
 			if (j >= 0) { /* if returned with success */
 				stack.param.rxisoffhook = ((chan->rxsig & (j >> 8)) != (j & 0xff));
 			} else {
-				stack.param.rxisoffhook = ((chan->rxhooksig != ZT_RXSIG_ONHOOK) &&
-					(chan->rxhooksig != ZT_RXSIG_INITIAL));
+				stack.param.rxisoffhook = ((chan->rxhooksig != DAHDI_RXSIG_ONHOOK) &&
+					(chan->rxhooksig != DAHDI_RXSIG_INITIAL));
 			}
-		} else if ((chan->txstate == ZT_TXSTATE_KEWL) || (chan->txstate == ZT_TXSTATE_AFTERKEWL))
+		} else if ((chan->txstate == DAHDI_TXSTATE_KEWL) || (chan->txstate == DAHDI_TXSTATE_AFTERKEWL))
 			stack.param.rxisoffhook = 1;
 		else
 			stack.param.rxisoffhook = 0;
-		if (chan->span && chan->span->rbsbits && !(chan->sig & ZT_SIG_CLEAR)) {
+		if (chan->span && chan->span->rbsbits && !(chan->sig & DAHDI_SIG_CLEAR)) {
 			stack.param.rxbits = chan->rxsig;
 			stack.param.txbits = chan->txsig;
 			stack.param.idlebits = chan->idlebits;
@@ -3325,7 +3325,7 @@ static int zt_common_ioctl(struct inode *node, struct file *file, unsigned int c
 			stack.param.idlebits = 0;
 		}
 		if (chan->span && (chan->span->rbsbits || chan->span->hooksig) && 
-			!(chan->sig & ZT_SIG_CLEAR)) {
+			!(chan->sig & DAHDI_SIG_CLEAR)) {
 			stack.param.rxhooksig = chan->rxhooksig;
 			stack.param.txhooksig = chan->txhooksig;
 		} else {
@@ -3356,23 +3356,23 @@ static int zt_common_ioctl(struct inode *node, struct file *file, unsigned int c
 		stack.param.chanpos = chan->chanpos;
 		stack.param.sigcap = chan->sigcap;
 		/* Return current law */
-		if (chan->xlaw == __zt_alaw)
-			stack.param.curlaw = ZT_LAW_ALAW;
+		if (chan->xlaw == __dahdi_alaw)
+			stack.param.curlaw = DAHDI_LAW_ALAW;
 		else
-			stack.param.curlaw = ZT_LAW_MULAW;
+			stack.param.curlaw = DAHDI_LAW_MULAW;
 
-		if (copy_to_user((struct zt_params *) data, &stack.param, size_to_copy))
+		if (copy_to_user((struct dahdi_params *) data, &stack.param, size_to_copy))
 			return -EFAULT;
 
 		break;
 		/* set channel parameters */
-	case ZT_SET_PARAMS_V1:
-	case ZT_SET_PARAMS:
-		/* The difference between zt_params and zt_params_v1 is just the 
+	case DAHDI_SET_PARAMS_V1:
+	case DAHDI_SET_PARAMS:
+		/* The difference between dahdi_params and dahdi_params_v1 is just the 
 		 * last field, which is read-only anyway. Thus we just read the
 		 * size of the older struct.
 		 */
-		if (copy_from_user(&stack.param, (struct zt_params *) data, sizeof(struct zt_params_v1)))
+		if (copy_from_user(&stack.param, (struct dahdi_params *) data, sizeof(struct dahdi_params_v1)))
 			return -EFAULT;
 
 		stack.param.chan_alarms = 0; /* be explicit about the above */
@@ -3402,33 +3402,33 @@ static int zt_common_ioctl(struct inode *node, struct file *file, unsigned int c
 		chan->pulsebreaktime = stack.param.pulsebreaktime;
 		chan->pulseaftertime = stack.param.pulseaftertime;
 		break;
-	case ZT_GETGAINS:  /* get gain stuff */
-		if (copy_from_user(&stack.gain,(struct zt_gains *) data,sizeof(stack.gain)))
+	case DAHDI_GETGAINS:  /* get gain stuff */
+		if (copy_from_user(&stack.gain,(struct dahdi_gains *) data,sizeof(stack.gain)))
 			return -EFAULT;
 		i = stack.gain.chan;  /* get channel no */
 		   /* if zero, use current channel no */
 		if (!i) i = unit;
 		  /* make sure channel number makes sense */
-		if ((i < 0) || (i > ZT_MAX_CHANNELS) || !chans[i]) return(-EINVAL);
+		if ((i < 0) || (i > DAHDI_MAX_CHANNELS) || !chans[i]) return(-EINVAL);
 		
-		if (!(chans[i]->flags & ZT_FLAG_AUDIO)) return (-EINVAL);
+		if (!(chans[i]->flags & DAHDI_FLAG_AUDIO)) return (-EINVAL);
 		stack.gain.chan = i; /* put the span # in here */
 		for (j=0;j<256;j++)  {
 			stack.gain.txgain[j] = chans[i]->txgain[j];
 			stack.gain.rxgain[j] = chans[i]->rxgain[j];
 		}
-		if (copy_to_user((struct zt_gains *) data,&stack.gain,sizeof(stack.gain)))
+		if (copy_to_user((struct dahdi_gains *) data,&stack.gain,sizeof(stack.gain)))
 			return -EFAULT;
 		break;
-	case ZT_SETGAINS:  /* set gain stuff */
-		if (copy_from_user(&stack.gain,(struct zt_gains *) data,sizeof(stack.gain)))
+	case DAHDI_SETGAINS:  /* set gain stuff */
+		if (copy_from_user(&stack.gain,(struct dahdi_gains *) data,sizeof(stack.gain)))
 			return -EFAULT;
 		i = stack.gain.chan;  /* get channel no */
 		   /* if zero, use current channel no */
 		if (!i) i = unit;
 		  /* make sure channel number makes sense */
-		if ((i < 0) || (i > ZT_MAX_CHANNELS) || !chans[i]) return(-EINVAL);
-		if (!(chans[i]->flags & ZT_FLAG_AUDIO)) return (-EINVAL);
+		if ((i < 0) || (i > DAHDI_MAX_CHANNELS) || !chans[i]) return(-EINVAL);
+		if (!(chans[i]->flags & DAHDI_FLAG_AUDIO)) return (-EINVAL);
 
 		rxgain = kmalloc(512, GFP_KERNEL);
 		if (!rxgain)
@@ -3463,16 +3463,16 @@ static int zt_common_ioctl(struct inode *node, struct file *file, unsigned int c
 			chans[i]->txgain = txgain;
 			spin_unlock_irqrestore(&chans[i]->lock, flags);
 		}
-		if (copy_to_user((struct zt_gains *) data,&stack.gain,sizeof(stack.gain)))
+		if (copy_to_user((struct dahdi_gains *) data,&stack.gain,sizeof(stack.gain)))
 			return -EFAULT;
 		break;
-	case ZT_SPANSTAT_V1:
-	case ZT_SPANSTAT_V2:
-	case ZT_SPANSTAT:
-		size_to_copy = (cmd == ZT_SPANSTAT_V1) ? sizeof(struct zt_spaninfo_v1) :
-			       (cmd == ZT_SPANSTAT_V2) ? sizeof(struct zt_spaninfo_v2) :
-			       sizeof(struct zt_spaninfo);
-		if (copy_from_user(&stack.spaninfo, (struct zt_spaninfo *) data, size_to_copy))
+	case DAHDI_SPANSTAT_V1:
+	case DAHDI_SPANSTAT_V2:
+	case DAHDI_SPANSTAT:
+		size_to_copy = (cmd == DAHDI_SPANSTAT_V1) ? sizeof(struct dahdi_spaninfo_v1) :
+			       (cmd == DAHDI_SPANSTAT_V2) ? sizeof(struct dahdi_spaninfo_v2) :
+			       sizeof(struct dahdi_spaninfo);
+		if (copy_from_user(&stack.spaninfo, (struct dahdi_spaninfo *) data, size_to_copy))
 			return -EFAULT;
 		i = stack.spaninfo.spanno; /* get specified span number */
 		if ((i < 0) || (i >= maxspans)) return(-EINVAL);  /* if bad span no */
@@ -3510,7 +3510,7 @@ static int zt_common_ioctl(struct inode *node, struct file *file, unsigned int c
 		/* version 3 fields */
 		stack.spaninfo.irq = spans[i]->irq;
 		stack.spaninfo.linecompat = spans[i]->linecompat;
-		zap_copy_string(stack.spaninfo.lboname, zt_lboname(spans[i]->lbo), sizeof(stack.spaninfo.lboname));
+		zap_copy_string(stack.spaninfo.lboname, dahdi_lboname(spans[i]->lbo), sizeof(stack.spaninfo.lboname));
 		if (spans[i]->manufacturer)
 			zap_copy_string(stack.spaninfo.manufacturer, spans[i]->manufacturer,
 				sizeof(stack.spaninfo.manufacturer));
@@ -3520,10 +3520,10 @@ static int zt_common_ioctl(struct inode *node, struct file *file, unsigned int c
 		if (spans[i]->spantype)
 			zap_copy_string(stack.spaninfo.spantype, spans[i]->spantype, sizeof(stack.spaninfo.spantype));
 		
-		if (copy_to_user((struct zt_spaninfo *) data, &stack.spaninfo, size_to_copy))
+		if (copy_to_user((struct dahdi_spaninfo *) data, &stack.spaninfo, size_to_copy))
 			return -EFAULT;
 		break;
-	case ZT_CHANDIAG:
+	case DAHDI_CHANDIAG:
 		get_user(j, (int *)data); /* get channel number from user */
 		/* make sure its a valid channel number */
 		if ((j < 1) || (j >= maxchans))
@@ -3586,17 +3586,17 @@ static int zt_common_ioctl(struct inode *node, struct file *file, unsigned int c
 	return 0;
 }
 
-static int (*zt_dynamic_ioctl)(unsigned int cmd, unsigned long data);
+static int (*dahdi_dynamic_ioctl)(unsigned int cmd, unsigned long data);
 
-void zt_set_dynamic_ioctl(int (*func)(unsigned int cmd, unsigned long data)) 
+void dahdi_set_dynamic_ioctl(int (*func)(unsigned int cmd, unsigned long data)) 
 {
-	zt_dynamic_ioctl = func;
+	dahdi_dynamic_ioctl = func;
 }
 
-static void recalc_slaves(struct zt_chan *chan)
+static void recalc_slaves(struct dahdi_chan *chan)
 {
 	int x;
-	struct zt_chan *last = chan;
+	struct dahdi_chan *last = chan;
 
 	/* Makes no sense if you don't have a span */
 	if (!chan->span)
@@ -3623,31 +3623,31 @@ static void recalc_slaves(struct zt_chan *chan)
 #endif
 }
 
-static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data)
+static int dahdi_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data)
 {
 	/* I/O CTL's for control interface */
 	int i,j;
 	int sigcap;
 	int res = 0;
 	int x,y;
-	struct zt_chan *newmaster;
+	struct dahdi_chan *newmaster;
 	unsigned long flags;
 	int rv;
 	switch(cmd) {
-	case ZT_INDIRECT:
+	case DAHDI_INDIRECT:
 	{
-		struct zt_indirect_data ind;
+		struct dahdi_indirect_data ind;
 
-		if (copy_from_user(&ind, (struct zt_indirect_data *)data, sizeof(ind)))
+		if (copy_from_user(&ind, (struct dahdi_indirect_data *)data, sizeof(ind)))
 			return -EFAULT;
 		VALID_CHANNEL(ind.chan);
-		return zt_chan_ioctl(inode, file, ind.op, (unsigned long) ind.data, ind.chan);
+		return dahdi_chan_ioctl(inode, file, ind.op, (unsigned long) ind.data, ind.chan);
 	}
-	case ZT_SPANCONFIG:
+	case DAHDI_SPANCONFIG:
 	{
-		struct zt_lineconfig lc;
+		struct dahdi_lineconfig lc;
 
-		if (copy_from_user(&lc, (struct zt_lineconfig *)data, sizeof(lc)))
+		if (copy_from_user(&lc, (struct dahdi_lineconfig *)data, sizeof(lc)))
 			return -EFAULT;
 		VALID_SPAN(lc.span);
 		if ((lc.lineconfig & 0x07f0 & spans[lc.span]->linecompat) != (lc.lineconfig & 0x07f0))
@@ -3662,49 +3662,49 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		}
 		return 0;
 	}
-	case ZT_STARTUP:
+	case DAHDI_STARTUP:
 		CHECK_VALID_SPAN(j);
-		if (spans[j]->flags & ZT_FLAG_RUNNING)
+		if (spans[j]->flags & DAHDI_FLAG_RUNNING)
 			return 0;
 		if (spans[j]->startup)
 			res = spans[j]->startup(spans[j]);
 		if (!res) {
 			/* Mark as running and hangup any channels */
-			spans[j]->flags |= ZT_FLAG_RUNNING;
+			spans[j]->flags |= DAHDI_FLAG_RUNNING;
 			for (x=0;x<spans[j]->channels;x++) {
-				y = zt_q_sig(&spans[j]->chans[x]) & 0xff;
+				y = dahdi_q_sig(&spans[j]->chans[x]) & 0xff;
 				if (y >= 0) spans[j]->chans[x].rxsig = (unsigned char)y;
 				spin_lock_irqsave(&spans[j]->chans[x].lock, flags);
-				zt_hangup(&spans[j]->chans[x]);
+				dahdi_hangup(&spans[j]->chans[x]);
 				spin_unlock_irqrestore(&spans[j]->chans[x].lock, flags);
-				spans[j]->chans[x].rxhooksig = ZT_RXSIG_INITIAL;
+				spans[j]->chans[x].rxhooksig = DAHDI_RXSIG_INITIAL;
 			}
 		}
 		return 0;
-	case ZT_SHUTDOWN:
+	case DAHDI_SHUTDOWN:
 		CHECK_VALID_SPAN(j);
 		if (spans[j]->shutdown)
 			res =  spans[j]->shutdown(spans[j]);
-		spans[j]->flags &= ~ZT_FLAG_RUNNING;
+		spans[j]->flags &= ~DAHDI_FLAG_RUNNING;
 		return 0;
-	case ZT_CHANCONFIG:
+	case DAHDI_CHANCONFIG:
 	{
-		struct zt_chanconfig ch;
+		struct dahdi_chanconfig ch;
 
-		if (copy_from_user(&ch, (struct zt_chanconfig *)data, sizeof(ch)))
+		if (copy_from_user(&ch, (struct dahdi_chanconfig *)data, sizeof(ch)))
 			return -EFAULT;
 		VALID_CHANNEL(ch.chan);
-		if (ch.sigtype == ZT_SIG_SLAVE) {
+		if (ch.sigtype == DAHDI_SIG_SLAVE) {
 			/* We have to use the master's sigtype */
-			if ((ch.master < 1) || (ch.master >= ZT_MAX_CHANNELS))
+			if ((ch.master < 1) || (ch.master >= DAHDI_MAX_CHANNELS))
 				return -EINVAL;
 			if (!chans[ch.master])
 				return -EINVAL;
 			ch.sigtype = chans[ch.master]->sig;
 			newmaster = chans[ch.master];
-		} else if ((ch.sigtype & __ZT_SIG_DACS) == __ZT_SIG_DACS) {
+		} else if ((ch.sigtype & __DAHDI_SIG_DACS) == __DAHDI_SIG_DACS) {
 			newmaster = chans[ch.chan];
-			if ((ch.idlebits < 1) || (ch.idlebits >= ZT_MAX_CHANNELS))
+			if ((ch.idlebits < 1) || (ch.idlebits >= DAHDI_MAX_CHANNELS))
 				return -EINVAL;
 			if (!chans[ch.idlebits])
 				return -EINVAL;
@@ -3713,7 +3713,7 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		}
 		spin_lock_irqsave(&chans[ch.chan]->lock, flags);
 #ifdef CONFIG_ZAPATA_NET
-		if (chans[ch.chan]->flags & ZT_FLAG_NETDEV) {
+		if (chans[ch.chan]->flags & DAHDI_FLAG_NETDEV) {
 			if (ztchan_to_dev(chans[ch.chan])->flags & IFF_UP) {
 				spin_unlock_irqrestore(&chans[ch.chan]->lock, flags);
 				printk(KERN_WARNING "Can't switch HDLC net mode on channel %s, since current interface is up\n", chans[ch.chan]->name);
@@ -3729,10 +3729,10 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 #endif				
 			kfree(chans[ch.chan]->hdlcnetdev);
 			chans[ch.chan]->hdlcnetdev = NULL;
-			chans[ch.chan]->flags &= ~ZT_FLAG_NETDEV;
+			chans[ch.chan]->flags &= ~DAHDI_FLAG_NETDEV;
 		}
 #else
-		if (ch.sigtype == ZT_SIG_HDLCNET) {
+		if (ch.sigtype == DAHDI_SIG_HDLCNET) {
 				spin_unlock_irqrestore(&chans[ch.chan]->lock, flags);
 				printk(KERN_WARNING "Zaptel networking not supported by this build.\n");
 				return -ENOSYS;
@@ -3741,8 +3741,8 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		sigcap = chans[ch.chan]->sigcap;
 		/* If they support clear channel, then they support the HDLC and such through
 		   us.  */
-		if (sigcap & ZT_SIG_CLEAR) 
-			sigcap |= (ZT_SIG_HDLCRAW | ZT_SIG_HDLCFCS | ZT_SIG_HDLCNET | ZT_SIG_DACS);
+		if (sigcap & DAHDI_SIG_CLEAR) 
+			sigcap |= (DAHDI_SIG_HDLCRAW | DAHDI_SIG_HDLCFCS | DAHDI_SIG_HDLCNET | DAHDI_SIG_DACS);
 		
 		if ((sigcap & ch.sigtype) != ch.sigtype)
 			res =  -EINVAL;	
@@ -3756,36 +3756,36 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		}
 		if (!res) {
 			chans[ch.chan]->sig = ch.sigtype;
-			if (chans[ch.chan]->sig == ZT_SIG_CAS)
+			if (chans[ch.chan]->sig == DAHDI_SIG_CAS)
 				chans[ch.chan]->idlebits = ch.idlebits;
 			else
 				chans[ch.chan]->idlebits = 0;
-			if ((ch.sigtype & ZT_SIG_CLEAR) == ZT_SIG_CLEAR) {
+			if ((ch.sigtype & DAHDI_SIG_CLEAR) == DAHDI_SIG_CLEAR) {
 				/* Set clear channel flag if appropriate */
-				chans[ch.chan]->flags &= ~ZT_FLAG_AUDIO;
-				chans[ch.chan]->flags |= ZT_FLAG_CLEAR;
+				chans[ch.chan]->flags &= ~DAHDI_FLAG_AUDIO;
+				chans[ch.chan]->flags |= DAHDI_FLAG_CLEAR;
 			} else {
 				/* Set audio flag and not clear channel otherwise */
-				chans[ch.chan]->flags |= ZT_FLAG_AUDIO;
-				chans[ch.chan]->flags &= ~ZT_FLAG_CLEAR;
+				chans[ch.chan]->flags |= DAHDI_FLAG_AUDIO;
+				chans[ch.chan]->flags &= ~DAHDI_FLAG_CLEAR;
 			}
-			if ((ch.sigtype & ZT_SIG_HDLCRAW) == ZT_SIG_HDLCRAW) {
+			if ((ch.sigtype & DAHDI_SIG_HDLCRAW) == DAHDI_SIG_HDLCRAW) {
 				/* Set the HDLC flag */
-				chans[ch.chan]->flags |= ZT_FLAG_HDLC;
+				chans[ch.chan]->flags |= DAHDI_FLAG_HDLC;
 			} else {
 				/* Clear the HDLC flag */
-				chans[ch.chan]->flags &= ~ZT_FLAG_HDLC;
+				chans[ch.chan]->flags &= ~DAHDI_FLAG_HDLC;
 			}
-			if ((ch.sigtype & ZT_SIG_HDLCFCS) == ZT_SIG_HDLCFCS) {
+			if ((ch.sigtype & DAHDI_SIG_HDLCFCS) == DAHDI_SIG_HDLCFCS) {
 				/* Set FCS to be calculated if appropriate */
-				chans[ch.chan]->flags |= ZT_FLAG_FCS;
+				chans[ch.chan]->flags |= DAHDI_FLAG_FCS;
 			} else {
 				/* Clear FCS flag */
-				chans[ch.chan]->flags &= ~ZT_FLAG_FCS;
+				chans[ch.chan]->flags &= ~DAHDI_FLAG_FCS;
 			}
-			if ((ch.sigtype & __ZT_SIG_DACS) == __ZT_SIG_DACS) {
+			if ((ch.sigtype & __DAHDI_SIG_DACS) == __DAHDI_SIG_DACS) {
 				/* Setup conference properly */
-				chans[ch.chan]->confmode = ZT_CONF_DIGITALMON;
+				chans[ch.chan]->confmode = DAHDI_CONF_DIGITALMON;
 				chans[ch.chan]->confna = ch.idlebits;
 				if (chans[ch.chan]->span && 
 				    chans[ch.chan]->span->dacs && 
@@ -3800,23 +3800,23 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 			if (newmaster != chans[ch.chan]) {
 				recalc_slaves(chans[ch.chan]->master);
 			}
-			if ((ch.sigtype & ZT_SIG_HARDHDLC) == ZT_SIG_HARDHDLC) {
-				chans[ch.chan]->flags &= ~ZT_FLAG_FCS;
-				chans[ch.chan]->flags &= ~ZT_FLAG_HDLC;
-				chans[ch.chan]->flags |= ZT_FLAG_NOSTDTXRX;
+			if ((ch.sigtype & DAHDI_SIG_HARDHDLC) == DAHDI_SIG_HARDHDLC) {
+				chans[ch.chan]->flags &= ~DAHDI_FLAG_FCS;
+				chans[ch.chan]->flags &= ~DAHDI_FLAG_HDLC;
+				chans[ch.chan]->flags |= DAHDI_FLAG_NOSTDTXRX;
 			} else
-				chans[ch.chan]->flags &= ~ZT_FLAG_NOSTDTXRX;
+				chans[ch.chan]->flags &= ~DAHDI_FLAG_NOSTDTXRX;
 
-			if ((ch.sigtype & ZT_SIG_MTP2) == ZT_SIG_MTP2)
-				chans[ch.chan]->flags |= ZT_FLAG_MTP2;
+			if ((ch.sigtype & DAHDI_SIG_MTP2) == DAHDI_SIG_MTP2)
+				chans[ch.chan]->flags |= DAHDI_FLAG_MTP2;
 			else
-				chans[ch.chan]->flags &= ~ZT_FLAG_MTP2;
+				chans[ch.chan]->flags &= ~DAHDI_FLAG_MTP2;
 		}
 #ifdef CONFIG_ZAPATA_NET
 		if (!res && 
 			(newmaster == chans[ch.chan]) && 
-		        (chans[ch.chan]->sig == ZT_SIG_HDLCNET)) {
-			chans[ch.chan]->hdlcnetdev = zt_hdlc_alloc();
+		        (chans[ch.chan]->sig == DAHDI_SIG_HDLCNET)) {
+			chans[ch.chan]->hdlcnetdev = dahdi_hdlc_alloc();
 			if (chans[ch.chan]->hdlcnetdev) {
 /*				struct hdlc_device *hdlc = chans[ch.chan]->hdlcnetdev;
 				struct net_device *d = hdlc_to_dev(hdlc); mmm...get it right later --byg */
@@ -3829,14 +3829,14 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 #endif
 					chans[ch.chan]->hdlcnetdev->netdev->irq = chans[ch.chan]->span->irq;
 					chans[ch.chan]->hdlcnetdev->netdev->tx_queue_len = 50;
-					chans[ch.chan]->hdlcnetdev->netdev->do_ioctl = zt_net_ioctl;
-					chans[ch.chan]->hdlcnetdev->netdev->open = zt_net_open;
-					chans[ch.chan]->hdlcnetdev->netdev->stop = zt_net_stop;
-					dev_to_hdlc(chans[ch.chan]->hdlcnetdev->netdev)->attach = zt_net_attach;
-					dev_to_hdlc(chans[ch.chan]->hdlcnetdev->netdev)->xmit = zt_xmit;
+					chans[ch.chan]->hdlcnetdev->netdev->do_ioctl = dahdi_net_ioctl;
+					chans[ch.chan]->hdlcnetdev->netdev->open = dahdi_net_open;
+					chans[ch.chan]->hdlcnetdev->netdev->stop = dahdi_net_stop;
+					dev_to_hdlc(chans[ch.chan]->hdlcnetdev->netdev)->attach = dahdi_net_attach;
+					dev_to_hdlc(chans[ch.chan]->hdlcnetdev->netdev)->xmit = dahdi_xmit;
 					spin_unlock_irqrestore(&chans[ch.chan]->lock, flags);
 					/* Briefly restore interrupts while we register the device */
-					res = zt_register_hdlc_device(chans[ch.chan]->hdlcnetdev->netdev, ch.netdev_name);
+					res = dahdi_register_hdlc_device(chans[ch.chan]->hdlcnetdev->netdev, ch.netdev_name);
 					spin_lock_irqsave(&chans[ch.chan]->lock, flags);
 				} else {
 					printk("Unable to allocate hdlc: *shrug*\n");
@@ -3845,49 +3845,49 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 #else /* LINUX26 */
 				chans[ch.chan]->hdlcnetdev->chan = chans[ch.chan];
 #ifndef HDLC_MAINTAINERS_ARE_MORE_STUPID_THAN_I_THOUGHT
-				chans[ch.chan]->hdlcnetdev->netdev.ioctl = zt_net_ioctl;
+				chans[ch.chan]->hdlcnetdev->netdev.ioctl = dahdi_net_ioctl;
 #endif
-				chans[ch.chan]->hdlcnetdev->netdev.netdev.do_ioctl = zt_net_ioctl;
+				chans[ch.chan]->hdlcnetdev->netdev.netdev.do_ioctl = dahdi_net_ioctl;
 #ifdef NEW_HDLC_INTERFACE
-				chans[ch.chan]->hdlcnetdev->netdev.netdev.open = zt_net_open;
-				chans[ch.chan]->hdlcnetdev->netdev.netdev.stop = zt_net_stop;
-				chans[ch.chan]->hdlcnetdev->netdev.xmit = zt_xmit;
-				chans[ch.chan]->hdlcnetdev->netdev.attach = zt_net_attach;
+				chans[ch.chan]->hdlcnetdev->netdev.netdev.open = dahdi_net_open;
+				chans[ch.chan]->hdlcnetdev->netdev.netdev.stop = dahdi_net_stop;
+				chans[ch.chan]->hdlcnetdev->netdev.xmit = dahdi_xmit;
+				chans[ch.chan]->hdlcnetdev->netdev.attach = dahdi_net_attach;
 #else
-				chans[ch.chan]->hdlcnetdev->netdev.open = zt_net_open;
-				chans[ch.chan]->hdlcnetdev->netdev.close = zt_net_close;
+				chans[ch.chan]->hdlcnetdev->netdev.open = dahdi_net_open;
+				chans[ch.chan]->hdlcnetdev->netdev.close = dahdi_net_close;
 				chans[ch.chan]->hdlcnetdev->netdev.set_mode = NULL;
-				chans[ch.chan]->hdlcnetdev->netdev.xmit = zt_xmit;
+				chans[ch.chan]->hdlcnetdev->netdev.xmit = dahdi_xmit;
 #endif /* NEW_HDLC_INTERFACE */
 				chans[ch.chan]->hdlcnetdev->netdev.netdev.irq = chans[ch.chan]->span->irq;
 				chans[ch.chan]->hdlcnetdev->netdev.netdev.tx_queue_len = 50;
 				res = register_hdlc_device(&chans[ch.chan]->hdlcnetdev->netdev);
 #endif /* LINUX26 */
 				if (!res)
-					chans[ch.chan]->flags |= ZT_FLAG_NETDEV;
+					chans[ch.chan]->flags |= DAHDI_FLAG_NETDEV;
 			} else {
 				printk("Unable to allocate netdev: out of memory\n");
 				res = -1;
 			}
 		}
 #endif			
-		if ((chans[ch.chan]->sig == ZT_SIG_HDLCNET) && 
+		if ((chans[ch.chan]->sig == DAHDI_SIG_HDLCNET) && 
 		    (chans[ch.chan] == newmaster) &&
-		    !(chans[ch.chan]->flags & ZT_FLAG_NETDEV))
+		    !(chans[ch.chan]->flags & DAHDI_FLAG_NETDEV))
 			printk("Unable to register HDLC device for channel %s\n", chans[ch.chan]->name);
 		if (!res) {
 			/* Setup default law */
 			chans[ch.chan]->deflaw = ch.deflaw;
 			/* Copy back any modified settings */
 			spin_unlock_irqrestore(&chans[ch.chan]->lock, flags);
-			if (copy_to_user((struct zt_chanconfig *)data, &ch, sizeof(ch)))
+			if (copy_to_user((struct dahdi_chanconfig *)data, &ch, sizeof(ch)))
 				return -EFAULT;
 			spin_lock_irqsave(&chans[ch.chan]->lock, flags);
 			/* And hangup */
-			zt_hangup(chans[ch.chan]);
-			y = zt_q_sig(chans[ch.chan]) & 0xff;
+			dahdi_hangup(chans[ch.chan]);
+			y = dahdi_q_sig(chans[ch.chan]) & 0xff;
 			if (y >= 0) chans[ch.chan]->rxsig = (unsigned char)y;
-			chans[ch.chan]->rxhooksig = ZT_RXSIG_INITIAL;
+			chans[ch.chan]->rxhooksig = DAHDI_RXSIG_INITIAL;
 		}
 #ifdef CONFIG_ZAPATA_DEBUG
 		printk("Configured channel %s, flags %04x, sig %04x\n", chans[ch.chan]->name, chans[ch.chan]->flags, chans[ch.chan]->sig);
@@ -3895,14 +3895,14 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		spin_unlock_irqrestore(&chans[ch.chan]->lock, flags);
 		return res;
 	}
-	case ZT_SFCONFIG:
+	case DAHDI_SFCONFIG:
 	{
-		struct zt_sfconfig sf;
+		struct dahdi_sfconfig sf;
 
-		if (copy_from_user(&sf, (struct zt_chanconfig *)data, sizeof(sf)))
+		if (copy_from_user(&sf, (struct dahdi_chanconfig *)data, sizeof(sf)))
 			return -EFAULT;
 		VALID_CHANNEL(sf.chan);
-		if (chans[sf.chan]->sig != ZT_SIG_SF) return -EINVAL;
+		if (chans[sf.chan]->sig != DAHDI_SIG_SF) return -EINVAL;
 		spin_lock_irqsave(&chans[sf.chan]->lock, flags);
 		chans[sf.chan]->rxp1 = sf.rxp1;
 		chans[sf.chan]->rxp2 = sf.rxp2;
@@ -3913,8 +3913,8 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		chans[sf.chan]->toneflags = sf.toneflag;
 		if (sf.txtone) /* if set to make tone for tx */
 		{
-			if ((chans[sf.chan]->txhooksig && !(sf.toneflag & ZT_REVERSE_TXTONE)) ||
-			 ((!chans[sf.chan]->txhooksig) && (sf.toneflag & ZT_REVERSE_TXTONE))) 
+			if ((chans[sf.chan]->txhooksig && !(sf.toneflag & DAHDI_REVERSE_TXTONE)) ||
+			 ((!chans[sf.chan]->txhooksig) && (sf.toneflag & DAHDI_REVERSE_TXTONE))) 
 			{
 				set_txtone(chans[sf.chan],sf.txtone,sf.tx_v2,sf.tx_v3);
 			}
@@ -3926,20 +3926,20 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		spin_unlock_irqrestore(&chans[sf.chan]->lock, flags);
 		return res;
 	}
-	case ZT_DEFAULTZONE:
+	case DAHDI_DEFAULTZONE:
 		if (get_user(j,(int *)data))
 			return -EFAULT;
-		return zt_set_default_zone(j);
-	case ZT_LOADZONE:
+		return dahdi_set_default_zone(j);
+	case DAHDI_LOADZONE:
 		return ioctl_load_zone(data);
-	case ZT_FREEZONE:
+	case DAHDI_FREEZONE:
 		get_user(j, (int *) data);
 		return free_tone_zone(j);
-	case ZT_SET_DIALPARAMS:
+	case DAHDI_SET_DIALPARAMS:
 	{
-		struct zt_dialparams tdp;
+		struct dahdi_dialparams tdp;
 
-		if (copy_from_user(&tdp, (struct zt_dialparams *) data, sizeof(tdp)))
+		if (copy_from_user(&tdp, (struct dahdi_dialparams *) data, sizeof(tdp)))
 			return -EFAULT;
 
 		if ((tdp.dtmf_tonelen <= 4000) || (tdp.dtmf_tonelen >= 10)) {
@@ -3955,64 +3955,64 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		/* update the lengths in all currently loaded zones */
 		write_lock(&zone_lock);
 		for (j = 0; j < sizeof(tone_zones) / sizeof(tone_zones[0]); j++) {
-			struct zt_zone *z = tone_zones[j];
+			struct dahdi_zone *z = tone_zones[j];
 
 			if (!z)
 				continue;
 
 			for (i = 0; i < sizeof(z->dtmf) / sizeof(z->dtmf[0]); i++) {
-				z->dtmf[i].tonesamples = global_dialparams.dtmf_tonelen * ZT_CHUNKSIZE;
+				z->dtmf[i].tonesamples = global_dialparams.dtmf_tonelen * DAHDI_CHUNKSIZE;
 			}
 
 			/* for MFR1, we only adjust the length of the digits */
-			for (i = ZT_TONE_MFR1_0; i <= ZT_TONE_MFR1_9; i++) {
-				z->mfr1[i - ZT_TONE_MFR1_BASE].tonesamples = global_dialparams.mfv1_tonelen * ZT_CHUNKSIZE;
+			for (i = DAHDI_TONE_MFR1_0; i <= DAHDI_TONE_MFR1_9; i++) {
+				z->mfr1[i - DAHDI_TONE_MFR1_BASE].tonesamples = global_dialparams.mfv1_tonelen * DAHDI_CHUNKSIZE;
 			}
 
 			for (i = 0; i < sizeof(z->mfr2_fwd) / sizeof(z->mfr2_fwd[0]); i++) {
-				z->mfr2_fwd[i].tonesamples = global_dialparams.mfr2_tonelen * ZT_CHUNKSIZE;
+				z->mfr2_fwd[i].tonesamples = global_dialparams.mfr2_tonelen * DAHDI_CHUNKSIZE;
 			}
 
 			for (i = 0; i < sizeof(z->mfr2_rev) / sizeof(z->mfr2_rev[0]); i++) {
-				z->mfr2_rev[i].tonesamples = global_dialparams.mfr2_tonelen * ZT_CHUNKSIZE;
+				z->mfr2_rev[i].tonesamples = global_dialparams.mfr2_tonelen * DAHDI_CHUNKSIZE;
 			}
 		}
 		write_unlock(&zone_lock);
 
-		dtmf_silence.tonesamples = global_dialparams.dtmf_tonelen * ZT_CHUNKSIZE;
-		mfr1_silence.tonesamples = global_dialparams.mfv1_tonelen * ZT_CHUNKSIZE;
-		mfr2_silence.tonesamples = global_dialparams.mfr2_tonelen * ZT_CHUNKSIZE;
+		dtmf_silence.tonesamples = global_dialparams.dtmf_tonelen * DAHDI_CHUNKSIZE;
+		mfr1_silence.tonesamples = global_dialparams.mfv1_tonelen * DAHDI_CHUNKSIZE;
+		mfr2_silence.tonesamples = global_dialparams.mfr2_tonelen * DAHDI_CHUNKSIZE;
 
 		break;
 	}
-	case ZT_GET_DIALPARAMS:
+	case DAHDI_GET_DIALPARAMS:
 	{
-		struct zt_dialparams tdp;
+		struct dahdi_dialparams tdp;
 
 		tdp = global_dialparams;
-		if (copy_to_user((struct zt_dialparams *) data, &tdp, sizeof(tdp)))
+		if (copy_to_user((struct dahdi_dialparams *) data, &tdp, sizeof(tdp)))
 			return -EFAULT;
 		break;
 	}
-	case ZT_GETVERSION:
+	case DAHDI_GETVERSION:
 	{
-		struct zt_versioninfo vi;
+		struct dahdi_versioninfo vi;
 
 		memset(&vi, 0, sizeof(vi));
 		zap_copy_string(vi.version, ZAPTEL_VERSION, sizeof(vi.version));
 		echo_can_identify(vi.echo_canceller, sizeof(vi.echo_canceller) - 1);
-		if (copy_to_user((struct zt_versioninfo *) data, &vi, sizeof(vi)))
+		if (copy_to_user((struct dahdi_versioninfo *) data, &vi, sizeof(vi)))
 			return -EFAULT;
 		break;
 	}
-	case ZT_MAINT:  /* do maintenance stuff */
+	case DAHDI_MAINT:  /* do maintenance stuff */
 	{
-		struct zt_maintinfo maint;
+		struct dahdi_maintinfo maint;
 		  /* get struct from user */
-		if (copy_from_user(&maint,(struct zt_maintinfo *) data, sizeof(maint)))
+		if (copy_from_user(&maint,(struct dahdi_maintinfo *) data, sizeof(maint)))
 			return -EFAULT;
 		/* must be valid span number */
-		if ((maint.spanno < 1) || (maint.spanno > ZT_MAX_SPANS) || (!spans[maint.spanno]))
+		if ((maint.spanno < 1) || (maint.spanno > DAHDI_MAX_SPANS) || (!spans[maint.spanno]))
 			return -EINVAL;
 		if (!spans[maint.spanno]->maint)
 			return -ENOSYS;
@@ -4022,9 +4022,9 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		  /* set maint mode */
 		spans[maint.spanno]->maintstat = maint.command;
 		switch(maint.command) {
-		case ZT_MAINT_NONE:
-		case ZT_MAINT_LOCALLOOP:
-		case ZT_MAINT_REMOTELOOP:
+		case DAHDI_MAINT_NONE:
+		case DAHDI_MAINT_LOCALLOOP:
+		case DAHDI_MAINT_REMOTELOOP:
 			/* if same, ignore it */
 			if (i == maint.command) break;
 			rv = spans[maint.spanno]->maint(spans[maint.spanno], maint.command);
@@ -4032,9 +4032,9 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 			if (rv) return rv;
 			spin_lock_irqsave(&spans[maint.spanno]->lock, flags);
 			break;
-		case ZT_MAINT_LOOPUP:
-		case ZT_MAINT_LOOPDOWN:
-			spans[maint.spanno]->mainttimer = ZT_LOOPCODE_TIME * ZT_CHUNKSIZE;
+		case DAHDI_MAINT_LOOPUP:
+		case DAHDI_MAINT_LOOPDOWN:
+			spans[maint.spanno]->mainttimer = DAHDI_LOOPCODE_TIME * DAHDI_CHUNKSIZE;
 			rv = spans[maint.spanno]->maint(spans[maint.spanno], maint.command);
 			spin_unlock_irqrestore(&spans[maint.spanno]->lock, flags);
 			if (rv) return rv;
@@ -4045,34 +4045,34 @@ static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		default:
 			printk("zaptel: Unknown maintenance event: %d\n", maint.command);
 		}
-		zt_alarm_notify(spans[maint.spanno]);  /* process alarm-related events */
+		dahdi_alarm_notify(spans[maint.spanno]);  /* process alarm-related events */
 		spin_unlock_irqrestore(&spans[maint.spanno]->lock, flags);
 		break;
 	}
-	case ZT_DYNAMIC_CREATE:
-	case ZT_DYNAMIC_DESTROY:
-		if (zt_dynamic_ioctl)
-			return zt_dynamic_ioctl(cmd, data);
+	case DAHDI_DYNAMIC_CREATE:
+	case DAHDI_DYNAMIC_DESTROY:
+		if (dahdi_dynamic_ioctl)
+			return dahdi_dynamic_ioctl(cmd, data);
 		else {
 			request_module("dahdi_dynamic");
-			if (zt_dynamic_ioctl)
-				return zt_dynamic_ioctl(cmd, data);
+			if (dahdi_dynamic_ioctl)
+				return dahdi_dynamic_ioctl(cmd, data);
 		}
 		return -ENOSYS;
 #if defined(ECHO_CAN_HPEC)
-	case ZT_EC_LICENSE_CHALLENGE:
-	case ZT_EC_LICENSE_RESPONSE:
+	case DAHDI_EC_LICENSE_CHALLENGE:
+	case DAHDI_EC_LICENSE_RESPONSE:
 		return hpec_license_ioctl(cmd, data);
 #endif /* defined(ECHO_CAN_HPEC) */
 	default:
-		return zt_common_ioctl(inode, file, cmd, data, 0);
+		return dahdi_common_ioctl(inode, file, cmd, data, 0);
 	}
 	return 0;
 }
 
-static int ioctl_zt_dial(struct zt_chan *chan, unsigned long data)
+static int ioctl_dahdi_dial(struct dahdi_chan *chan, unsigned long data)
 {
-	struct zt_dialoperation *tdo;
+	struct dahdi_dialoperation *tdo;
 	unsigned long flags;
 	char *s;
 	int rv;
@@ -4082,11 +4082,11 @@ static int ioctl_zt_dial(struct zt_chan *chan, unsigned long data)
 	if (!tdo)
 		return -ENOMEM;
 
-	if (copy_from_user(tdo, (struct zt_dialoperation *)data, sizeof(*tdo)))
+	if (copy_from_user(tdo, (struct dahdi_dialoperation *)data, sizeof(*tdo)))
 		return -EFAULT;
 	rv = 0;
 	/* Force proper NULL termination and uppercase entry */
-	tdo->dialstr[ZT_MAX_DTMF_BUF - 1] = '\0';
+	tdo->dialstr[DAHDI_MAX_DTMF_BUF - 1] = '\0';
 	for (s = tdo->dialstr; *s; s++)
 		*s = toupper(*s);
 	spin_lock_irqsave(&chan->lock, flags);
@@ -4097,24 +4097,24 @@ static int ioctl_zt_dial(struct zt_chan *chan, unsigned long data)
 		return -ENODATA;
 	}
 	switch (tdo->op) {
-	case ZT_DIAL_OP_CANCEL:
+	case DAHDI_DIAL_OP_CANCEL:
 		chan->curtone = NULL;
 		chan->dialing = 0;
 		chan->txdialbuf[0] = '\0';
 		chan->tonep = 0;
 		chan->pdialcount = 0;
 		break;
-	case ZT_DIAL_OP_REPLACE:
+	case DAHDI_DIAL_OP_REPLACE:
 		strcpy(chan->txdialbuf, tdo->dialstr);
 		chan->dialing = 1;
 		__do_dtmf(chan);
 		break;
-	case ZT_DIAL_OP_APPEND:
-		if (strlen(tdo->dialstr) + strlen(chan->txdialbuf) >= (ZT_MAX_DTMF_BUF - 1)) {
+	case DAHDI_DIAL_OP_APPEND:
+		if (strlen(tdo->dialstr) + strlen(chan->txdialbuf) >= (DAHDI_MAX_DTMF_BUF - 1)) {
 			rv = -EBUSY;
 			break;
 		}
-		zap_copy_string(chan->txdialbuf + strlen(chan->txdialbuf), tdo->dialstr, ZT_MAX_DTMF_BUF - strlen(chan->txdialbuf));
+		zap_copy_string(chan->txdialbuf + strlen(chan->txdialbuf), tdo->dialstr, DAHDI_MAX_DTMF_BUF - strlen(chan->txdialbuf));
 		if (!chan->dialing) {
 			chan->dialing = 1;
 			__do_dtmf(chan);
@@ -4127,13 +4127,13 @@ static int ioctl_zt_dial(struct zt_chan *chan, unsigned long data)
 	return rv;
 }
 
-static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit)
+static int dahdi_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit)
 {
-	struct zt_chan *chan = chans[unit];
+	struct dahdi_chan *chan = chans[unit];
 	union {
-		struct zt_bufferinfo bi;
-		struct zt_confinfo conf;
-		struct zt_ring_cadence cad;
+		struct dahdi_bufferinfo bi;
+		struct dahdi_confinfo conf;
+		struct dahdi_ring_cadence cad;
 	} stack;
 	unsigned long flags, flagso;
 	int i, j, k, rv;
@@ -4142,16 +4142,16 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 	if (!chan)
 		return -EINVAL;
 	switch(cmd) {
-	case ZT_DIALING:
+	case DAHDI_DIALING:
 		spin_lock_irqsave(&chan->lock, flags);
 		j = chan->dialing;
 		spin_unlock_irqrestore(&chan->lock, flags);
 		if (copy_to_user((int *)data,&j,sizeof(int)))
 			return -EFAULT;
 		return 0;
-	case ZT_DIAL:
-		return ioctl_zt_dial(chan, data);
-	case ZT_GET_BUFINFO:
+	case DAHDI_DIAL:
+		return ioctl_dahdi_dial(chan, data);
+	case DAHDI_GET_BUFINFO:
 		stack.bi.rxbufpolicy = chan->rxbufpolicy;
 		stack.bi.txbufpolicy = chan->txbufpolicy;
 		stack.bi.numbufs = chan->numbufs;
@@ -4159,41 +4159,41 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 		/* XXX FIXME! XXX */
 		stack.bi.readbufs = -1;
 		stack.bi.writebufs = -1;
-		if (copy_to_user((struct zt_bufferinfo *)data, &stack.bi, sizeof(stack.bi)))
+		if (copy_to_user((struct dahdi_bufferinfo *)data, &stack.bi, sizeof(stack.bi)))
 			return -EFAULT;
 		break;
-	case ZT_SET_BUFINFO:
-		if (copy_from_user(&stack.bi, (struct zt_bufferinfo *)data, sizeof(stack.bi)))
+	case DAHDI_SET_BUFINFO:
+		if (copy_from_user(&stack.bi, (struct dahdi_bufferinfo *)data, sizeof(stack.bi)))
 			return -EFAULT;
-		if (stack.bi.bufsize > ZT_MAX_BLOCKSIZE)
+		if (stack.bi.bufsize > DAHDI_MAX_BLOCKSIZE)
 			return -EINVAL;
 		if (stack.bi.bufsize < 16)
 			return -EINVAL;
-		if (stack.bi.bufsize * stack.bi.numbufs > ZT_MAX_BUF_SPACE)
+		if (stack.bi.bufsize * stack.bi.numbufs > DAHDI_MAX_BUF_SPACE)
 			return -EINVAL;
 		chan->rxbufpolicy = stack.bi.rxbufpolicy & 0x1;
 		chan->txbufpolicy = stack.bi.txbufpolicy & 0x1;
-		if ((rv = zt_reallocbufs(chan,  stack.bi.bufsize, stack.bi.numbufs)))
+		if ((rv = dahdi_reallocbufs(chan,  stack.bi.bufsize, stack.bi.numbufs)))
 			return (rv);
 		break;
-	case ZT_GET_BLOCKSIZE:  /* get blocksize */
+	case DAHDI_GET_BLOCKSIZE:  /* get blocksize */
 		put_user(chan->blocksize,(int *)data); /* return block size */
 		break;
-	case ZT_SET_BLOCKSIZE:  /* set blocksize */
+	case DAHDI_SET_BLOCKSIZE:  /* set blocksize */
 		get_user(j,(int *)data);
 		  /* cannot be larger than max amount */
-		if (j > ZT_MAX_BLOCKSIZE) return(-EINVAL);
+		if (j > DAHDI_MAX_BLOCKSIZE) return(-EINVAL);
 		  /* cannot be less then 16 */
 		if (j < 16) return(-EINVAL);
 		  /* allocate a single kernel buffer which we then
 		     sub divide into four pieces */
-		if ((rv = zt_reallocbufs(chan, j, chan->numbufs)))
+		if ((rv = dahdi_reallocbufs(chan, j, chan->numbufs)))
 			return (rv);
 		break;
-	case ZT_FLUSH:  /* flush input buffer, output buffer, and/or event queue */
+	case DAHDI_FLUSH:  /* flush input buffer, output buffer, and/or event queue */
 		get_user(i,(int *)data);  /* get param */
 		spin_lock_irqsave(&chan->lock, flags);
-		if (i & ZT_FLUSH_READ)  /* if for read (input) */
+		if (i & DAHDI_FLUSH_READ)  /* if for read (input) */
 		   {
 			  /* initialize read buffers and pointers */
 			chan->inreadbuf = 0;
@@ -4206,7 +4206,7 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 			wake_up_interruptible(&chan->readbufq);  /* wake_up_interruptible waiting on read */
 			wake_up_interruptible(&chan->sel); /* wake_up_interruptible waiting on select */
 		   }
-		if (i & ZT_FLUSH_WRITE) /* if for write (output) */
+		if (i & DAHDI_FLUSH_WRITE) /* if for write (output) */
 		   {
 			  /* initialize write buffers and pointers */
 			chan->outwritebuf = -1;
@@ -4220,17 +4220,17 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 			wake_up_interruptible(&chan->sel);  /* wake_up_interruptible waiting on select */
 			   /* if IO MUX wait on write empty, well, this
 				certainly *did* empty the write */
-			if (chan->iomask & ZT_IOMUX_WRITEEMPTY)
+			if (chan->iomask & DAHDI_IOMUX_WRITEEMPTY)
 				wake_up_interruptible(&chan->eventbufq); /* wake_up_interruptible waiting on IOMUX */
 		   }
-		if (i & ZT_FLUSH_EVENT) /* if for events */
+		if (i & DAHDI_FLUSH_EVENT) /* if for events */
 		   {
 			   /* initialize the event pointers */
 			chan->eventinidx = chan->eventoutidx = 0;
 		   }
 		spin_unlock_irqrestore(&chan->lock, flags);
 		break;
-	case ZT_SYNC:  /* wait for no tx */
+	case DAHDI_SYNC:  /* wait for no tx */
 		for(;;)  /* loop forever */
 		   {
 			spin_lock_irqsave(&chan->lock, flags);
@@ -4242,7 +4242,7 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 			if (rv) return(rv);
 		   }
 		break;
-	case ZT_IOMUX: /* wait for something to happen */
+	case DAHDI_IOMUX: /* wait for something to happen */
 		get_user(chan->iomask,(int*)data);  /* save mask */
 		if (!chan->iomask) return(-EINVAL);  /* cant wait for nothing */
 		for(;;)  /* loop forever */
@@ -4251,36 +4251,36 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 			ret = 0;  /* start with empty return value */
 			spin_lock_irqsave(&chan->lock, flags);
 			  /* if looking for read */
-			if (chan->iomask & ZT_IOMUX_READ)
+			if (chan->iomask & DAHDI_IOMUX_READ)
 			   {
 				/* if read available */
 				if ((chan->outreadbuf > -1)  && !chan->rxdisable)
-					ret |= ZT_IOMUX_READ;
+					ret |= DAHDI_IOMUX_READ;
 			   }
 			  /* if looking for write avail */
-			if (chan->iomask & ZT_IOMUX_WRITE)
+			if (chan->iomask & DAHDI_IOMUX_WRITE)
 			   {
 				if (chan->inwritebuf > -1)
-					ret |= ZT_IOMUX_WRITE;
+					ret |= DAHDI_IOMUX_WRITE;
 			   }
 			  /* if looking for write empty */
-			if (chan->iomask & ZT_IOMUX_WRITEEMPTY)
+			if (chan->iomask & DAHDI_IOMUX_WRITEEMPTY)
 			   {
 				  /* if everything empty -- be sure the transmitter is enabled */
 				chan->txdisable = 0;
 				if (chan->outwritebuf < 0)
-					ret |= ZT_IOMUX_WRITEEMPTY;
+					ret |= DAHDI_IOMUX_WRITEEMPTY;
 			   }
 			  /* if looking for signalling event */
-			if (chan->iomask & ZT_IOMUX_SIGEVENT)
+			if (chan->iomask & DAHDI_IOMUX_SIGEVENT)
 			   {
 				  /* if event */
 				if (chan->eventinidx != chan->eventoutidx)
-					ret |= ZT_IOMUX_SIGEVENT;
+					ret |= DAHDI_IOMUX_SIGEVENT;
 			   }
 			spin_unlock_irqrestore(&chan->lock, flags);
 			  /* if something to return, or not to wait */
-			if (ret || (chan->iomask & ZT_IOMUX_NOWAIT))
+			if (ret || (chan->iomask & DAHDI_IOMUX_NOWAIT))
 			   {
 				  /* set return value */
 				put_user(ret,(int *)data);
@@ -4292,9 +4292,9 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 		  /* clear IO MUX mask */
 		chan->iomask = 0;
 		break;
-	case ZT_GETEVENT:  /* Get event on queue */
+	case DAHDI_GETEVENT:  /* Get event on queue */
 		  /* set up for no event */
-		j = ZT_EVENT_NONE;
+		j = DAHDI_EVENT_NONE;
 		spin_lock_irqsave(&chan->lock, flags);
 		  /* if some event in queue */
 		if (chan->eventinidx != chan->eventoutidx)
@@ -4302,77 +4302,77 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 			j = chan->eventbuf[chan->eventoutidx++];
 			  /* get the data, bump index */
 			  /* if index overflow, set to beginning */
-			if (chan->eventoutidx >= ZT_MAX_EVENTSIZE)
+			if (chan->eventoutidx >= DAHDI_MAX_EVENTSIZE)
 				chan->eventoutidx = 0;
 		   }		
 		spin_unlock_irqrestore(&chan->lock, flags);
 		put_user(j,(int *)data);
 		break;
-	case ZT_CONFMUTE:  /* set confmute flag */
+	case DAHDI_CONFMUTE:  /* set confmute flag */
 		get_user(j,(int *)data);  /* get conf # */
-		if (!(chan->flags & ZT_FLAG_AUDIO)) return (-EINVAL);
+		if (!(chan->flags & DAHDI_FLAG_AUDIO)) return (-EINVAL);
 		spin_lock_irqsave(&bigzaplock, flags);
 		chan->confmute = j;
 		spin_unlock_irqrestore(&bigzaplock, flags);
 		break;
-	case ZT_GETCONFMUTE:  /* get confmute flag */
-		if (!(chan->flags & ZT_FLAG_AUDIO)) return (-EINVAL);
+	case DAHDI_GETCONFMUTE:  /* get confmute flag */
+		if (!(chan->flags & DAHDI_FLAG_AUDIO)) return (-EINVAL);
 		j = chan->confmute;
 		put_user(j,(int *)data);  /* get conf # */
 		rv = 0;
 		break;
-	case ZT_SETTONEZONE:
+	case DAHDI_SETTONEZONE:
 		get_user(j, (int *) data);
 		rv = set_tone_zone(chan, j);
 		return rv;
-	case ZT_GETTONEZONE:
+	case DAHDI_GETTONEZONE:
 		spin_lock_irqsave(&chan->lock, flags);
 		if (chan->curzone)
 			j = chan->tonezone;
 		spin_unlock_irqrestore(&chan->lock, flags);
 		put_user(j, (int *) data);
 		break;
-	case ZT_SENDTONE:
+	case DAHDI_SENDTONE:
 		get_user(j,(int *)data);
 		spin_lock_irqsave(&chan->lock, flags);
 		rv = start_tone(chan, j);	
 		spin_unlock_irqrestore(&chan->lock, flags);
 		return rv;
-	case ZT_GETCONF:  /* get conf stuff */
-		if (copy_from_user(&stack.conf,(struct zt_confinfo *) data,sizeof(stack.conf)))
+	case DAHDI_GETCONF:  /* get conf stuff */
+		if (copy_from_user(&stack.conf,(struct dahdi_confinfo *) data,sizeof(stack.conf)))
 			return -EFAULT;
 		i = stack.conf.chan;  /* get channel no */
 		   /* if zero, use current channel no */
 		if (!i) i = chan->channo;
 		  /* make sure channel number makes sense */
-		if ((i < 0) || (i > ZT_MAX_CONF) || (!chans[i])) return(-EINVAL);
-		if (!(chans[i]->flags & ZT_FLAG_AUDIO)) return (-EINVAL);
+		if ((i < 0) || (i > DAHDI_MAX_CONF) || (!chans[i])) return(-EINVAL);
+		if (!(chans[i]->flags & DAHDI_FLAG_AUDIO)) return (-EINVAL);
 		stack.conf.chan = i;  /* get channel number */
 		stack.conf.confno = chans[i]->confna;  /* get conference number */
 		stack.conf.confmode = chans[i]->confmode; /* get conference mode */
-		if (copy_to_user((struct zt_confinfo *) data,&stack.conf,sizeof(stack.conf)))
+		if (copy_to_user((struct dahdi_confinfo *) data,&stack.conf,sizeof(stack.conf)))
 			return -EFAULT;
 		break;
-	case ZT_SETCONF:  /* set conf stuff */
-		if (copy_from_user(&stack.conf,(struct zt_confinfo *) data,sizeof(stack.conf)))
+	case DAHDI_SETCONF:  /* set conf stuff */
+		if (copy_from_user(&stack.conf,(struct dahdi_confinfo *) data,sizeof(stack.conf)))
 			return -EFAULT;
 		i = stack.conf.chan;  /* get channel no */
 		   /* if zero, use current channel no */
 		if (!i) i = chan->channo;
 		  /* make sure channel number makes sense */
-		if ((i < 1) || (i > ZT_MAX_CHANNELS) || (!chans[i])) return(-EINVAL);
-		if (!(chans[i]->flags & ZT_FLAG_AUDIO)) return (-EINVAL); 
-		if ((stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITOR ||
-			(stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITORTX ||
-			(stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITORBOTH ||
-			(stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITOR_RX_PREECHO ||
-			(stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITOR_TX_PREECHO ||
-			(stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITORBOTH_PREECHO) {
+		if ((i < 1) || (i > DAHDI_MAX_CHANNELS) || (!chans[i])) return(-EINVAL);
+		if (!(chans[i]->flags & DAHDI_FLAG_AUDIO)) return (-EINVAL); 
+		if ((stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITOR ||
+			(stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITORTX ||
+			(stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITORBOTH ||
+			(stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITOR_RX_PREECHO ||
+			(stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITOR_TX_PREECHO ||
+			(stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITORBOTH_PREECHO) {
 			/* Monitor mode -- it's a channel */
-			if ((stack.conf.confno < 0) || (stack.conf.confno >= ZT_MAX_CHANNELS) || !chans[stack.conf.confno]) return(-EINVAL);
+			if ((stack.conf.confno < 0) || (stack.conf.confno >= DAHDI_MAX_CHANNELS) || !chans[stack.conf.confno]) return(-EINVAL);
 		} else {
 			  /* make sure conf number makes sense, too */
-			if ((stack.conf.confno < -1) || (stack.conf.confno > ZT_MAX_CONF)) return(-EINVAL);
+			if ((stack.conf.confno < -1) || (stack.conf.confno > DAHDI_MAX_CONF)) return(-EINVAL);
 		}
 			
 		  /* if taking off of any conf, must have 0 mode */
@@ -4383,7 +4383,7 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 		spin_lock_irqsave(&bigzaplock, flagso);
 		spin_lock_irqsave(&chan->lock, flags);
 		if (stack.conf.confno == -1) 
-			stack.conf.confno = zt_first_empty_conference();
+			stack.conf.confno = dahdi_first_empty_conference();
 		if ((stack.conf.confno < 1) && (stack.conf.confmode)) {
 			/* No more empty conferences */
 			spin_unlock_irqrestore(&chan->lock, flags);
@@ -4392,18 +4392,18 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 		}
 		  /* if changing confs, clear last added info */
 		if (stack.conf.confno != chans[i]->confna) {
-			memset(chans[i]->conflast, 0, ZT_MAX_CHUNKSIZE);
-			memset(chans[i]->conflast1, 0, ZT_MAX_CHUNKSIZE);
-			memset(chans[i]->conflast2, 0, ZT_MAX_CHUNKSIZE);
+			memset(chans[i]->conflast, 0, DAHDI_MAX_CHUNKSIZE);
+			memset(chans[i]->conflast1, 0, DAHDI_MAX_CHUNKSIZE);
+			memset(chans[i]->conflast2, 0, DAHDI_MAX_CHUNKSIZE);
 		}
 		j = chans[i]->confna;  /* save old conference number */
 		chans[i]->confna = stack.conf.confno;   /* set conference number */
 		chans[i]->confmode = stack.conf.confmode;  /* set conference mode */
 		chans[i]->_confn = 0;		     /* Clear confn */
-		zt_check_conf(j);
-		zt_check_conf(stack.conf.confno);
+		dahdi_check_conf(j);
+		dahdi_check_conf(stack.conf.confno);
 		if (chans[i]->span && chans[i]->span->dacs) {
-			if (((stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_DIGITALMON) &&
+			if (((stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_DIGITALMON) &&
 			    chans[stack.conf.confno]->span &&
 			    chans[stack.conf.confno]->span->dacs == chans[i]->span->dacs &&
 			    chans[i]->txgain == defgain &&
@@ -4417,20 +4417,20 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 		}
 		/* if we are going onto a conf */
 		if (stack.conf.confno &&
-			((stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_CONF ||
-			(stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_CONFANN ||
-			(stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_CONFMON ||
-			(stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_CONFANNMON ||
-			(stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_REALANDPSEUDO)) {
+			((stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONF ||
+			(stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONFANN ||
+			(stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONFMON ||
+			(stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONFANNMON ||
+			(stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_REALANDPSEUDO)) {
 			/* Get alias */
-			chans[i]->_confn = zt_get_conf_alias(stack.conf.confno);
+			chans[i]->_confn = dahdi_get_conf_alias(stack.conf.confno);
 		}
 
 		if (chans[stack.conf.confno]) {
-			if ((stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITOR_RX_PREECHO ||
-			    (stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITOR_TX_PREECHO ||
-			    (stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_MONITORBOTH_PREECHO)
-				chans[stack.conf.confno]->readchunkpreec = kmalloc(sizeof(*chans[stack.conf.confno]->readchunkpreec) * ZT_CHUNKSIZE, GFP_ATOMIC);
+			if ((stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITOR_RX_PREECHO ||
+			    (stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITOR_TX_PREECHO ||
+			    (stack.conf.confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_MONITORBOTH_PREECHO)
+				chans[stack.conf.confno]->readchunkpreec = kmalloc(sizeof(*chans[stack.conf.confno]->readchunkpreec) * DAHDI_CHUNKSIZE, GFP_ATOMIC);
 			else {
 				if (chans[stack.conf.confno]->readchunkpreec) {
 					kfree(chans[stack.conf.confno]->readchunkpreec);
@@ -4441,16 +4441,16 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 
 		spin_unlock_irqrestore(&chan->lock, flags);
 		spin_unlock_irqrestore(&bigzaplock, flagso);
-		if (copy_to_user((struct zt_confinfo *) data,&stack.conf,sizeof(stack.conf)))
+		if (copy_to_user((struct dahdi_confinfo *) data,&stack.conf,sizeof(stack.conf)))
 			return -EFAULT;
 		break;
-	case ZT_CONFLINK:  /* do conf link stuff */
-		if (!(chan->flags & ZT_FLAG_AUDIO)) return (-EINVAL);
-		if (copy_from_user(&stack.conf,(struct zt_confinfo *) data,sizeof(stack.conf)))
+	case DAHDI_CONFLINK:  /* do conf link stuff */
+		if (!(chan->flags & DAHDI_FLAG_AUDIO)) return (-EINVAL);
+		if (copy_from_user(&stack.conf,(struct dahdi_confinfo *) data,sizeof(stack.conf)))
 			return -EFAULT;
 		  /* check sanity of arguments */
-		if ((stack.conf.chan < 0) || (stack.conf.chan > ZT_MAX_CONF)) return(-EINVAL);
-		if ((stack.conf.confno < 0) || (stack.conf.confno > ZT_MAX_CONF)) return(-EINVAL);
+		if ((stack.conf.chan < 0) || (stack.conf.chan > DAHDI_MAX_CONF)) return(-EINVAL);
+		if ((stack.conf.confno < 0) || (stack.conf.confno > DAHDI_MAX_CONF)) return(-EINVAL);
 		  /* cant listen to self!! */
 		if (stack.conf.chan && (stack.conf.chan == stack.conf.confno)) return(-EINVAL);
 		spin_lock_irqsave(&bigzaplock, flagso);
@@ -4467,13 +4467,13 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 		   }
 		rv = 0;  /* clear return value */
 		/* look for already existant specified combination */
-		for(i = 1; i <= ZT_MAX_CONF; i++)
+		for(i = 1; i <= DAHDI_MAX_CONF; i++)
 		   {
 			  /* if found, exit */
 			if ((conf_links[i].src == stack.conf.chan) &&
 				(conf_links[i].dst == stack.conf.confno)) break;
 		   }
-		if (i <= ZT_MAX_CONF) /* if found */
+		if (i <= DAHDI_MAX_CONF) /* if found */
 		   {
 			if (!stack.conf.confmode) /* if to remove link */
 			   {
@@ -4489,14 +4489,14 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 			if (stack.conf.confmode) /* if to add link */
 			   {
 				/* look for empty location */
-				for(i = 1; i <= ZT_MAX_CONF; i++)
+				for(i = 1; i <= DAHDI_MAX_CONF; i++)
 				   {
 					  /* if empty, exit loop */
 					if ((!conf_links[i].src) &&
 						 (!conf_links[i].dst)) break;
 				   }
 				   /* if empty spot found */
-				if (i <= ZT_MAX_CONF)
+				if (i <= DAHDI_MAX_CONF)
 				   {
 					conf_links[i].src = stack.conf.chan;
 					conf_links[i].dst = stack.conf.confno;
@@ -4515,14 +4515,14 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 		spin_unlock_irqrestore(&chan->lock, flags);
 		spin_unlock_irqrestore(&bigzaplock, flagso);
 		return(rv);
-	case ZT_CONFDIAG:  /* output diagnostic info to console */
-		if (!(chan->flags & ZT_FLAG_AUDIO)) return (-EINVAL);
+	case DAHDI_CONFDIAG:  /* output diagnostic info to console */
+		if (!(chan->flags & DAHDI_FLAG_AUDIO)) return (-EINVAL);
 		get_user(j,(int *)data);  /* get conf # */
  		  /* loop thru the interesting ones */
-		for(i = ((j) ? j : 1); i <= ((j) ? j : ZT_MAX_CONF); i++)
+		for(i = ((j) ? j : 1); i <= ((j) ? j : DAHDI_MAX_CONF); i++)
 		   {
 			c = 0;
-			for(k = 1; k < ZT_MAX_CHANNELS; k++)
+			for(k = 1; k < DAHDI_MAX_CHANNELS; k++)
 			   {
 				  /* skip if no pointer */
 				if (!chans[k]) continue;
@@ -4534,7 +4534,7 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 					k,chans[k]->confmode);
 			   }
 			rv = 0;
-			for(k = 1; k <= ZT_MAX_CONF; k++)
+			for(k = 1; k <= DAHDI_MAX_CONF; k++)
 			   {
 				if (conf_links[k].dst == i)
 				   {
@@ -4548,35 +4548,35 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 			if (c) printk("\n");
 		   }
 		break;
-	case ZT_CHANNO:  /* get channel number of stream */
+	case DAHDI_CHANNO:  /* get channel number of stream */
 		put_user(unit,(int *)data); /* return unit/channel number */
 		break;
-	case ZT_SETLAW:
+	case DAHDI_SETLAW:
 		get_user(j, (int *)data);
-		if ((j < 0) || (j > ZT_LAW_ALAW))
+		if ((j < 0) || (j > DAHDI_LAW_ALAW))
 			return -EINVAL;
-		zt_set_law(chan, j);
+		dahdi_set_law(chan, j);
 		break;
-	case ZT_SETLINEAR:
+	case DAHDI_SETLINEAR:
 		get_user(j, (int *)data);
 		/* Makes no sense on non-audio channels */
-		if (!(chan->flags & ZT_FLAG_AUDIO))
+		if (!(chan->flags & DAHDI_FLAG_AUDIO))
 			return -EINVAL;
 
 		if (j)
-			chan->flags |= ZT_FLAG_LINEAR;
+			chan->flags |= DAHDI_FLAG_LINEAR;
 		else
-			chan->flags &= ~ZT_FLAG_LINEAR;
+			chan->flags &= ~DAHDI_FLAG_LINEAR;
 		break;
-	case ZT_SETCADENCE:
+	case DAHDI_SETCADENCE:
 		if (data) {
 			/* Use specific ring cadence */
-			if (copy_from_user(&stack.cad, (struct zt_ring_cadence *)data, sizeof(stack.cad)))
+			if (copy_from_user(&stack.cad, (struct dahdi_ring_cadence *)data, sizeof(stack.cad)))
 				return -EFAULT;
 			memcpy(chan->ringcadence, &stack.cad, sizeof(chan->ringcadence));
 			chan->firstcadencepos = 0;
 			/* Looking for negative ringing time indicating where to loop back into ringcadence */
-			for (i=0; i<ZT_MAX_CADENCE; i+=2 ) {
+			for (i=0; i<DAHDI_MAX_CADENCE; i+=2 ) {
 				if (chan->ringcadence[i]<0) {
 					chan->ringcadence[i] *= -1;
 					chan->firstcadencepos = i;
@@ -4589,7 +4589,7 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 			if (chan->curzone) {
 				memcpy(chan->ringcadence, chan->curzone->ringcadence, sizeof(chan->ringcadence));
 				/* Looking for negative ringing time indicating where to loop back into ringcadence */
-				for (i=0; i<ZT_MAX_CADENCE; i+=2 ) {
+				for (i=0; i<DAHDI_MAX_CADENCE; i+=2 ) {
 					if (chan->ringcadence[i]<0) {
 						chan->ringcadence[i] *= -1;
 						chan->firstcadencepos = i;
@@ -4599,13 +4599,13 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
 			} else {
 				memset(chan->ringcadence, 0, sizeof(chan->ringcadence));
 				chan->ringcadence[0] = chan->starttime;
-				chan->ringcadence[1] = ZT_RINGOFFTIME;
+				chan->ringcadence[1] = DAHDI_RINGOFFTIME;
 			}
 		}
 		break;
 	default:
 		/* Check for common ioctl's and private ones */
-		rv = zt_common_ioctl(inode, file, cmd, data, unit);
+		rv = dahdi_common_ioctl(inode, file, cmd, data, unit);
 		/* if no span, just return with value */
 		if (!chan->span) return rv;
 		if ((rv == -ENOTTY) && chan->span->ioctl) 
@@ -4625,7 +4625,7 @@ static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsign
  */
 static void do_ppp_calls(unsigned long data)
 {
-	struct zt_chan *chan = (struct zt_chan *) data;
+	struct dahdi_chan *chan = (struct dahdi_chan *) data;
 	struct sk_buff *skb;
 
 	if (!chan->ppp)
@@ -4643,14 +4643,14 @@ static void do_ppp_calls(unsigned long data)
 }
 #endif
 
-static int ioctl_echocancel(struct zt_chan *chan, struct zt_echocanparams *ecp, void *data)
+static int ioctl_echocancel(struct dahdi_chan *chan, struct dahdi_echocanparams *ecp, void *data)
 {
 	struct echo_can_state *ec = NULL, *tec;
-	struct zt_echocanparam *params;
+	struct dahdi_echocanparam *params;
 	int ret;
 	unsigned long flags;
 
-	if (ecp->param_count > ZT_MAX_ECHOCANPARAMS)
+	if (ecp->param_count > DAHDI_MAX_ECHOCANPARAMS)
 		return -E2BIG;
 
 	if (ecp->tap_length == 0) {
@@ -4676,14 +4676,14 @@ static int ioctl_echocancel(struct zt_chan *chan, struct zt_echocanparams *ecp,
 	    !chan->span->echocan_with_params)
 		return -EINVAL;
 	
-	params = kmalloc(sizeof(params[0]) * ZT_MAX_ECHOCANPARAMS, GFP_KERNEL);
+	params = kmalloc(sizeof(params[0]) * DAHDI_MAX_ECHOCANPARAMS, GFP_KERNEL);
 	
 	if (!params)
 		return -ENOMEM;
 
 	/* enable mode, need the params */
 	
-	if (copy_from_user(params, (struct zt_echocanparam *) data, sizeof(params[0]) * ecp->param_count)) {
+	if (copy_from_user(params, (struct dahdi_echocanparam *) data, sizeof(params[0]) * ecp->param_count)) {
 		ret = -EFAULT;
 		goto exit_with_free;
 	}
@@ -4739,9 +4739,9 @@ exit_with_free:
 	return ret;
 }
 
-static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit)
+static int dahdi_chan_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit)
 {
-	struct zt_chan *chan = chans[unit];
+	struct dahdi_chan *chan = chans[unit];
 	unsigned long flags;
 	int j, rv;
 	int ret;
@@ -4753,40 +4753,40 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 		return -ENOSYS;
 
 	switch(cmd) {
-	case ZT_SIGFREEZE:
+	case DAHDI_SIGFREEZE:
 		get_user(j, (int *)data);
 		spin_lock_irqsave(&chan->lock, flags);
 		if (j) {
-			chan->flags |= ZT_FLAG_SIGFREEZE;
+			chan->flags |= DAHDI_FLAG_SIGFREEZE;
 		} else {
-			chan->flags &= ~ZT_FLAG_SIGFREEZE;
+			chan->flags &= ~DAHDI_FLAG_SIGFREEZE;
 		}
 		spin_unlock_irqrestore(&chan->lock, flags);
 		break;
-	case ZT_GETSIGFREEZE:
+	case DAHDI_GETSIGFREEZE:
 		spin_lock_irqsave(&chan->lock, flags);
-		if (chan->flags & ZT_FLAG_SIGFREEZE)
+		if (chan->flags & DAHDI_FLAG_SIGFREEZE)
 			j = 1;
 		else
 			j = 0;
 		spin_unlock_irqrestore(&chan->lock, flags);
 		put_user(j, (int *)data);
 		break;
-	case ZT_AUDIOMODE:
+	case DAHDI_AUDIOMODE:
 		/* Only literal clear channels can be put in  */
-		if (chan->sig != ZT_SIG_CLEAR) return (-EINVAL);
+		if (chan->sig != DAHDI_SIG_CLEAR) return (-EINVAL);
 		get_user(j, (int *)data);
 		if (j) {
 			spin_lock_irqsave(&chan->lock, flags);
-			chan->flags |= ZT_FLAG_AUDIO;
-			chan->flags &= ~(ZT_FLAG_HDLC | ZT_FLAG_FCS);
+			chan->flags |= DAHDI_FLAG_AUDIO;
+			chan->flags &= ~(DAHDI_FLAG_HDLC | DAHDI_FLAG_FCS);
 			spin_unlock_irqrestore(&chan->lock, flags);
 		} else {
 			/* Coming out of audio mode, also clear all 
 			   conferencing and gain related info as well
 			   as echo canceller */
 			spin_lock_irqsave(&chan->lock, flags);
-			chan->flags &= ~ZT_FLAG_AUDIO;
+			chan->flags &= ~DAHDI_FLAG_AUDIO;
 			/* save old conf number, if any */
 			oldconf = chan->confna;
 			  /* initialize conference variables */
@@ -4820,12 +4820,12 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 				kfree(rxgain);
 			if (ec)
 				echo_can_free(ec);
-			if (oldconf) zt_check_conf(oldconf);
+			if (oldconf) dahdi_check_conf(oldconf);
 		}
 		break;
-	case ZT_HDLCPPP:
+	case DAHDI_HDLCPPP:
 #ifdef CONFIG_ZAPATA_PPP
-		if (chan->sig != ZT_SIG_CLEAR) return (-EINVAL);
+		if (chan->sig != DAHDI_SIG_CLEAR) return (-EINVAL);
 		get_user(j, (int *)data);
 		if (j) {
 			if (!chan->ppp) {
@@ -4835,13 +4835,13 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 					memset(chan->ppp, 0, sizeof(struct ppp_channel));
 					chan->ppp->private = chan;
 					chan->ppp->ops = &ztppp_ops;
-					chan->ppp->mtu = ZT_DEFAULT_MTU_MRU;
+					chan->ppp->mtu = DAHDI_DEFAULT_MTU_MRU;
 					chan->ppp->hdrlen = 0;
 					skb_queue_head_init(&chan->ppp_rq);
 					chan->do_ppp_wakeup = 0;
 					tasklet_init(&chan->ppp_calls, do_ppp_calls,
 						     (unsigned long)chan);
-					if ((ret = zt_reallocbufs(chan, ZT_DEFAULT_MTU_MRU, ZT_DEFAULT_NUM_BUFS))) {
+					if ((ret = dahdi_reallocbufs(chan, DAHDI_DEFAULT_MTU_MRU, DAHDI_DEFAULT_NUM_BUFS))) {
 						kfree(chan->ppp);
 						chan->ppp = NULL;
 						return ret;
@@ -4864,8 +4864,8 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 					chan->rxgain = defgain;
 					chan->txgain = defgain;
 					chan->gainalloc = 0;
-					chan->flags &= ~ZT_FLAG_AUDIO;
-					chan->flags |= (ZT_FLAG_PPP | ZT_FLAG_HDLC | ZT_FLAG_FCS);
+					chan->flags &= ~DAHDI_FLAG_AUDIO;
+					chan->flags |= (DAHDI_FLAG_PPP | DAHDI_FLAG_HDLC | DAHDI_FLAG_FCS);
 					hw_echocancel_off(chan);
 					
 					if (tec)
@@ -4874,7 +4874,7 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 					return -ENOMEM;
 			}
 		} else {
-			chan->flags &= ~(ZT_FLAG_PPP | ZT_FLAG_HDLC | ZT_FLAG_FCS);
+			chan->flags &= ~(DAHDI_FLAG_PPP | DAHDI_FLAG_HDLC | DAHDI_FLAG_FCS);
 			if (chan->ppp) {
 				struct ppp_channel *ppp = chan->ppp;
 				chan->ppp = NULL;
@@ -4889,44 +4889,44 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 		return -ENOSYS;
 #endif
 		break;
-	case ZT_HDLCRAWMODE:
-		if (chan->sig != ZT_SIG_CLEAR)	return (-EINVAL);
+	case DAHDI_HDLCRAWMODE:
+		if (chan->sig != DAHDI_SIG_CLEAR)	return (-EINVAL);
 		get_user(j, (int *)data);
-		chan->flags &= ~(ZT_FLAG_AUDIO | ZT_FLAG_HDLC | ZT_FLAG_FCS);
+		chan->flags &= ~(DAHDI_FLAG_AUDIO | DAHDI_FLAG_HDLC | DAHDI_FLAG_FCS);
 		if (j) {
-			chan->flags |= ZT_FLAG_HDLC;
+			chan->flags |= DAHDI_FLAG_HDLC;
 			fasthdlc_init(&chan->rxhdlc);
 			fasthdlc_init(&chan->txhdlc);
 		}
 		break;
-	case ZT_HDLCFCSMODE:
-		if (chan->sig != ZT_SIG_CLEAR)	return (-EINVAL);
+	case DAHDI_HDLCFCSMODE:
+		if (chan->sig != DAHDI_SIG_CLEAR)	return (-EINVAL);
 		get_user(j, (int *)data);
-		chan->flags &= ~(ZT_FLAG_AUDIO | ZT_FLAG_HDLC | ZT_FLAG_FCS);
+		chan->flags &= ~(DAHDI_FLAG_AUDIO | DAHDI_FLAG_HDLC | DAHDI_FLAG_FCS);
 		if (j) {
-			chan->flags |= ZT_FLAG_HDLC | ZT_FLAG_FCS;
+			chan->flags |= DAHDI_FLAG_HDLC | DAHDI_FLAG_FCS;
 			fasthdlc_init(&chan->rxhdlc);
 			fasthdlc_init(&chan->txhdlc);
 		}
 		break;
-	case ZT_ECHOCANCEL_PARAMS:
+	case DAHDI_ECHOCANCEL_PARAMS:
 	{
-		struct zt_echocanparams ecp;
+		struct dahdi_echocanparams ecp;
 
-		if (!(chan->flags & ZT_FLAG_AUDIO))
+		if (!(chan->flags & DAHDI_FLAG_AUDIO))
 			return -EINVAL;
-		if (copy_from_user(&ecp, (struct zt_echocanparams *) data, sizeof(ecp)))
+		if (copy_from_user(&ecp, (struct dahdi_echocanparams *) data, sizeof(ecp)))
 			return -EFAULT;
 		data += sizeof(ecp);
 		if ((ret = ioctl_echocancel(chan, &ecp, (void *) data)))
 			return ret;
 		break;
 	}
-	case ZT_ECHOCANCEL:
+	case DAHDI_ECHOCANCEL:
 	{
-		struct zt_echocanparams ecp;
+		struct dahdi_echocanparams ecp;
 
-		if (!(chan->flags & ZT_FLAG_AUDIO))
+		if (!(chan->flags & DAHDI_FLAG_AUDIO))
 			return -EINVAL;
 		get_user(j, (int *) data);
 		ecp.tap_length = j;
@@ -4935,9 +4935,9 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 			return ret;
 		break;
 	}
-	case ZT_ECHOTRAIN:
+	case DAHDI_ECHOTRAIN:
 		get_user(j, (int *)data); /* get pre-training time from user */
-		if ((j < 0) || (j >= ZT_MAX_PRETRAINING))
+		if ((j < 0) || (j >= DAHDI_MAX_PRETRAINING))
 			return -EINVAL;
 		j <<= 3;
 		if (chan->ec) {
@@ -4947,32 +4947,32 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 		} else
 			return -EINVAL;
 		break;
-	case ZT_SETTXBITS:
-		if (chan->sig != ZT_SIG_CAS)
+	case DAHDI_SETTXBITS:
+		if (chan->sig != DAHDI_SIG_CAS)
 			return -EINVAL;
 		get_user(j,(int *)data);
-		zt_cas_setbits(chan, j);
+		dahdi_cas_setbits(chan, j);
 		rv = 0;
 		break;
-	case ZT_GETRXBITS:
+	case DAHDI_GETRXBITS:
 		put_user(chan->rxsig, (int *)data);
 		rv = 0;
 		break;
-	case ZT_LOOPBACK:
+	case DAHDI_LOOPBACK:
 		get_user(j, (int *)data);
 		spin_lock_irqsave(&chan->lock, flags);
 		if (j)
-			chan->flags |= ZT_FLAG_LOOPED;
+			chan->flags |= DAHDI_FLAG_LOOPED;
 		else
-			chan->flags &= ~ZT_FLAG_LOOPED;
+			chan->flags &= ~DAHDI_FLAG_LOOPED;
 		spin_unlock_irqrestore(&chan->lock, flags);
 		rv = 0;
 		break;
-	case ZT_HOOK:
+	case DAHDI_HOOK:
 		get_user(j,(int *)data);
-		if (chan->flags & ZT_FLAG_CLEAR)
+		if (chan->flags & DAHDI_FLAG_CLEAR)
 			return -EINVAL;
-		if (chan->sig == ZT_SIG_CAS) 
+		if (chan->sig == DAHDI_SIG_CAS) 
 			return -EINVAL;
 		/* if no span, just do nothing */
 		if (!chan->span) return(0);
@@ -4984,42 +4984,42 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 		chan->tonep = 0;
 		chan->pdialcount = 0;
 		spin_unlock_irqrestore(&chan->lock, flags);
-		if (chan->span->flags & ZT_FLAG_RBS) {
+		if (chan->span->flags & DAHDI_FLAG_RBS) {
 			switch (j) {
-			case ZT_ONHOOK:
+			case DAHDI_ONHOOK:
 				spin_lock_irqsave(&chan->lock, flags);
-				zt_hangup(chan);
+				dahdi_hangup(chan);
 				spin_unlock_irqrestore(&chan->lock, flags);
 				break;
-			case ZT_OFFHOOK:
+			case DAHDI_OFFHOOK:
 				spin_lock_irqsave(&chan->lock, flags);
-				if ((chan->txstate == ZT_TXSTATE_KEWL) ||
-				  (chan->txstate == ZT_TXSTATE_AFTERKEWL)) {
+				if ((chan->txstate == DAHDI_TXSTATE_KEWL) ||
+				  (chan->txstate == DAHDI_TXSTATE_AFTERKEWL)) {
 					spin_unlock_irqrestore(&chan->lock, flags);
 					return -EBUSY;
 				}
-				zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_DEBOUNCE, chan->debouncetime);
+				dahdi_rbs_sethook(chan, DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_DEBOUNCE, chan->debouncetime);
 				spin_unlock_irqrestore(&chan->lock, flags);
 				break;
-			case ZT_RING:
-			case ZT_START:
+			case DAHDI_RING:
+			case DAHDI_START:
 				spin_lock_irqsave(&chan->lock, flags);
 				if (!chan->curzone) {
 					spin_unlock_irqrestore(&chan->lock, flags);
 					printk(KERN_WARNING "zaptel: Cannot start tone until a tone zone is loaded.\n");
 					return -ENODATA;
 				}
-				if (chan->txstate != ZT_TXSTATE_ONHOOK) {
+				if (chan->txstate != DAHDI_TXSTATE_ONHOOK) {
 					spin_unlock_irqrestore(&chan->lock, flags);
 					return -EBUSY;
 				}
-				if (chan->sig & __ZT_SIG_FXO) {
+				if (chan->sig & __DAHDI_SIG_FXO) {
 					ret = 0;
 					chan->cadencepos = 0;
 					ret = chan->ringcadence[0];
-					zt_rbs_sethook(chan, ZT_TXSIG_START, ZT_TXSTATE_RINGON, ret);
+					dahdi_rbs_sethook(chan, DAHDI_TXSIG_START, DAHDI_TXSTATE_RINGON, ret);
 				} else
-					zt_rbs_sethook(chan, ZT_TXSIG_START, ZT_TXSTATE_START, chan->starttime);
+					dahdi_rbs_sethook(chan, DAHDI_TXSIG_START, DAHDI_TXSTATE_START, chan->starttime);
 				spin_unlock_irqrestore(&chan->lock, flags);
 				if (file->f_flags & O_NONBLOCK)
 					return -EINPROGRESS;
@@ -5029,35 +5029,35 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 #endif				
 				rv = 0;
 				break;
-			case ZT_WINK:
+			case DAHDI_WINK:
 				spin_lock_irqsave(&chan->lock, flags);
-				if (chan->txstate != ZT_TXSTATE_ONHOOK) {
+				if (chan->txstate != DAHDI_TXSTATE_ONHOOK) {
 					spin_unlock_irqrestore(&chan->lock, flags);
 					return -EBUSY;
 				}
-				zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_PREWINK, chan->prewinktime);
+				dahdi_rbs_sethook(chan, DAHDI_TXSIG_ONHOOK, DAHDI_TXSTATE_PREWINK, chan->prewinktime);
 				spin_unlock_irqrestore(&chan->lock, flags);
 				if (file->f_flags & O_NONBLOCK)
 					return -EINPROGRESS;
 				rv = schluffen(&chan->txstateq);
 				if (rv) return rv;
 				break;
-			case ZT_FLASH:
+			case DAHDI_FLASH:
 				spin_lock_irqsave(&chan->lock, flags);
-				if (chan->txstate != ZT_TXSTATE_OFFHOOK) {
+				if (chan->txstate != DAHDI_TXSTATE_OFFHOOK) {
 					spin_unlock_irqrestore(&chan->lock, flags);
 					return -EBUSY;
 				}
-				zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_PREFLASH, chan->preflashtime);
+				dahdi_rbs_sethook(chan, DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_PREFLASH, chan->preflashtime);
 				spin_unlock_irqrestore(&chan->lock, flags);
 				if (file->f_flags & O_NONBLOCK)
 					return -EINPROGRESS;
 				rv = schluffen(&chan->txstateq);
 				if (rv) return rv;
 				break;
-			case ZT_RINGOFF:
+			case DAHDI_RINGOFF:
 				spin_lock_irqsave(&chan->lock, flags);
-				zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_ONHOOK, 0);
+				dahdi_rbs_sethook(chan, DAHDI_TXSIG_ONHOOK, DAHDI_TXSTATE_ONHOOK, 0);
 				spin_unlock_irqrestore(&chan->lock, flags);
 				break;
 			default:
@@ -5073,27 +5073,27 @@ static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cm
 		break;
 #ifdef CONFIG_ZAPATA_PPP
 	case PPPIOCGCHAN:
-		if (chan->flags & ZT_FLAG_PPP)
+		if (chan->flags & DAHDI_FLAG_PPP)
 			return put_user(ppp_channel_index(chan->ppp), (int *)data) ? -EFAULT : 0;
 		else
 			return -EINVAL;
 		break;
 	case PPPIOCGUNIT:
-		if (chan->flags & ZT_FLAG_PPP)
+		if (chan->flags & DAHDI_FLAG_PPP)
 			return put_user(ppp_unit_number(chan->ppp), (int *)data) ? -EFAULT : 0;
 		else
 			return -EINVAL;
 		break;
 #endif
 	default:
-		return zt_chanandpseudo_ioctl(inode, file, cmd, data, unit);
+		return dahdi_chanandpseudo_ioctl(inode, file, cmd, data, unit);
 	}
 	return 0;
 }
 
-static int zt_prechan_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit)
+static int dahdi_prechan_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit)
 {
-	struct zt_chan *chan = file->private_data;
+	struct dahdi_chan *chan = file->private_data;
 	int channo;
 	int res;
 
@@ -5101,13 +5101,13 @@ static int zt_prechan_ioctl(struct inode *inode, struct file *file, unsigned int
 		printk("Huh?  Prechan already has private data??\n");
 	}
 	switch(cmd) {
-	case ZT_SPECIFY:
+	case DAHDI_SPECIFY:
 		get_user(channo,(int *)data);
 		if (channo < 1)
 			return -EINVAL;
-		if (channo > ZT_MAX_CHANNELS)
+		if (channo > DAHDI_MAX_CHANNELS)
 			return -EINVAL;
-		res = zt_specchan_open(inode, file, channo, 0);
+		res = dahdi_specchan_open(inode, file, channo, 0);
 		if (!res) {
 			/* Setup the pointer for future stuff */
 			chan = chans[channo];
@@ -5122,31 +5122,31 @@ static int zt_prechan_ioctl(struct inode *inode, struct file *file, unsigned int
 	return 0;
 }
 
-static int zt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data)
+static int dahdi_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data)
 {
 	int unit = UNIT(file);
-	struct zt_chan *chan;
-	struct zt_timer *timer;
+	struct dahdi_chan *chan;
+	struct dahdi_timer *timer;
 
 	if (!unit)
-		return zt_ctl_ioctl(inode, file, cmd, data);
+		return dahdi_ctl_ioctl(inode, file, cmd, data);
 
 	if (unit == 250)
-		return zt_transcode_fops->ioctl(inode, file, cmd, data);
+		return dahdi_transcode_fops->ioctl(inode, file, cmd, data);
 
 	if (unit == 253) {
 		timer = file->private_data;
 		if (timer)
-			return zt_timer_ioctl(inode, file, cmd, data, timer);
+			return dahdi_timer_ioctl(inode, file, cmd, data, timer);
 		else
 			return -EINVAL;
 	}
 	if (unit == 254) {
 		chan = file->private_data;
 		if (chan)
-			return zt_chan_ioctl(inode, file, cmd, data, chan->channo);
+			return dahdi_chan_ioctl(inode, file, cmd, data, chan->channo);
 		else
-			return zt_prechan_ioctl(inode, file, cmd, data, unit);
+			return dahdi_prechan_ioctl(inode, file, cmd, data, unit);
 	}
 	if (unit == 255) {
 		chan = file->private_data;
@@ -5154,12 +5154,12 @@ static int zt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
 			printk("No pseudo channel structure to read?\n");
 			return -EINVAL;
 		}
-		return zt_chanandpseudo_ioctl(inode, file, cmd, data, chan->channo);
+		return dahdi_chanandpseudo_ioctl(inode, file, cmd, data, chan->channo);
 	}
-	return zt_chan_ioctl(inode, file, cmd, data, unit);
+	return dahdi_chan_ioctl(inode, file, cmd, data, unit);
 }
 
-int zt_register(struct zt_span *span, int prefmaster)
+int dahdi_register(struct dahdi_span *span, int prefmaster)
 {
 	int x;
 
@@ -5168,7 +5168,7 @@ int zt_register(struct zt_span *span, int prefmaster)
 #endif
 	if (!span)
 		return -EINVAL;
-	if (span->flags & ZT_FLAG_REGISTERED) {
+	if (span->flags & DAHDI_FLAG_REGISTERED) {
 		printk(KERN_ERR "Span %s already appears to be registered\n", span->name);
 		return -EBUSY;
 	}
@@ -5177,10 +5177,10 @@ int zt_register(struct zt_span *span, int prefmaster)
 			printk(KERN_ERR "Span %s already in list\n", span->name);
 			return -EBUSY;
 		}
-	for (x=1;x<ZT_MAX_SPANS;x++)
+	for (x=1;x<DAHDI_MAX_SPANS;x++)
 		if (!spans[x])
 			break;
-	if (x < ZT_MAX_SPANS) {
+	if (x < DAHDI_MAX_SPANS) {
 		spans[x] = span;
 		if (maxspans < x + 1)
 			maxspans = x + 1;
@@ -5188,12 +5188,12 @@ int zt_register(struct zt_span *span, int prefmaster)
 		printk(KERN_ERR "Too many zapata spans registered\n");
 		return -EBUSY;
 	}
-	span->flags |= ZT_FLAG_REGISTERED;
+	span->flags |= DAHDI_FLAG_REGISTERED;
 	span->spanno = x;
 	spin_lock_init(&span->lock);
 	if (!span->deflaw) {
 		printk("zaptel: Span %s didn't specify default law.  Assuming mulaw, please fix driver!\n", span->name);
-		span->deflaw = ZT_LAW_MULAW;
+		span->deflaw = DAHDI_LAW_MULAW;
 	}
 
 	if (span->echocan && span->echocan_with_params) {
@@ -5203,7 +5203,7 @@ int zt_register(struct zt_span *span, int prefmaster)
 
 	for (x=0;x<span->channels;x++) {
 		span->chans[x].span = span;
-		zt_chan_reg(&span->chans[x]); 
+		dahdi_chan_reg(&span->chans[x]); 
 	}
 
 #ifdef CONFIG_PROC_FS
@@ -5217,7 +5217,7 @@ int zt_register(struct zt_span *span, int prefmaster)
 		sprintf(span_name, "span%d", span->spanno);
 		span->dhandle = devfs_mk_dir(zaptel_devfs_dir, span_name, NULL);
 		for (x = 0; x < span->channels; x++) {
-			struct zt_chan *chan = &span->chans[x];
+			struct dahdi_chan *chan = &span->chans[x];
 			chan->fhandle = register_devfs_channel(chan, chan->span->dhandle); /* Register our stuff with devfs */
 		}
 	}
@@ -5228,7 +5228,7 @@ int zt_register(struct zt_span *span, int prefmaster)
 		char chan_name[50];
 		if (span->chans[x].channo < 250) {
 			sprintf(chan_name, "zap%d", span->chans[x].channo);
-			CLASS_DEV_CREATE(zap_class, MKDEV(ZT_MAJOR, span->chans[x].channo), NULL, chan_name);
+			CLASS_DEV_CREATE(zap_class, MKDEV(DAHDI_MAJOR, span->chans[x].channo), NULL, chan_name);
 		}
 	}
 #endif /* CONFIG_ZAP_UDEV */
@@ -5243,22 +5243,22 @@ int zt_register(struct zt_span *span, int prefmaster)
 	return 0;
 }
 
-int zt_unregister(struct zt_span *span)
+int dahdi_unregister(struct dahdi_span *span)
 {
 	int x;
 	int new_maxspans;
-	static struct zt_span *new_master;
+	static struct dahdi_span *new_master;
 
 #ifdef CONFIG_PROC_FS
 	char tempfile[17];
 #endif /* CONFIG_PROC_FS */
 
-	if (!(span->flags & ZT_FLAG_REGISTERED)) {
+	if (!(span->flags & DAHDI_FLAG_REGISTERED)) {
 		printk(KERN_ERR "Span %s does not appear to be registered\n", span->name);
 		return -1;
 	}
 	/* Shutdown the span if it's running */
-	if (span->flags & ZT_FLAG_RUNNING)
+	if (span->flags & DAHDI_FLAG_RUNNING)
 		if (span->shutdown)
 			span->shutdown(span);
 			
@@ -5283,20 +5283,20 @@ int zt_unregister(struct zt_span *span)
 #ifdef CONFIG_ZAP_UDEV
 	for (x = 0; x < span->channels; x++) {
 		if (span->chans[x].channo < 250)
-			class_device_destroy(zap_class, MKDEV(ZT_MAJOR, span->chans[x].channo));
+			class_device_destroy(zap_class, MKDEV(DAHDI_MAJOR, span->chans[x].channo));
 	}
 #endif /* CONFIG_ZAP_UDEV */
 
 	spans[span->spanno] = NULL;
 	span->spanno = 0;
-	span->flags &= ~ZT_FLAG_REGISTERED;
+	span->flags &= ~DAHDI_FLAG_REGISTERED;
 	for (x=0;x<span->channels;x++)
-		zt_chan_unreg(&span->chans[x]);
+		dahdi_chan_unreg(&span->chans[x]);
 	new_maxspans = 0;
 	new_master = master; /* FIXME: locking */
 	if (master == span)
 		new_master = NULL;
-	for (x=1;x<ZT_MAX_SPANS;x++) {
+	for (x=1;x<DAHDI_MAX_SPANS;x++) {
 		if (spans[x]) {
 			new_maxspans = x+1;
 			if (!new_master)
@@ -5343,7 +5343,7 @@ unsigned char
 #else
 static unsigned char  __init
 #endif
-__zt_lineartoulaw(short sample)
+__dahdi_lineartoulaw(short sample)
 {
   static int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
                              4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
@@ -5388,7 +5388,7 @@ unsigned char
 #else
 static inline unsigned char __init
 #endif
-__zt_lineartoalaw (short linear)
+__dahdi_lineartoalaw (short linear)
 {
     int mask;
     int seg;
@@ -5435,7 +5435,7 @@ static inline short int __init alaw2linear (uint8_t alaw)
     return (short int) ((alaw & 0x80)  ?  i  :  -i);
 }
 /*- End of function --------------------------------------------------------*/
-static void  __init zt_conv_init(void)
+static void  __init dahdi_conv_init(void)
 {
 	int i;
 
@@ -5453,8 +5453,8 @@ static void  __init zt_conv_init(void)
 		y = f * (1 << (e + 3));
 		y += etab[e];
 		if (mu & 0x80) y = -y;
-	        __zt_mulaw[i] = y;
-		__zt_alaw[i] = alaw2linear(i);
+	        __dahdi_mulaw[i] = y;
+		__dahdi_alaw[i] = alaw2linear(i);
 		/* Default (0.0 db) gain table */
 		defgain[i] = i;
 	   }
@@ -5462,27 +5462,27 @@ static void  __init zt_conv_init(void)
 	  /* set up the reverse (mu-law) conversion table */
 	for(i = -32768; i < 32768; i += 4)
 	   {
-		__zt_lin2mu[((unsigned short)(short)i) >> 2] = __zt_lineartoulaw(i);
-		__zt_lin2a[((unsigned short)(short)i) >> 2] = __zt_lineartoalaw(i);
+		__dahdi_lin2mu[((unsigned short)(short)i) >> 2] = __dahdi_lineartoulaw(i);
+		__dahdi_lin2a[((unsigned short)(short)i) >> 2] = __dahdi_lineartoalaw(i);
 	   }
 #endif
 }
 
-static inline void __zt_process_getaudio_chunk(struct zt_chan *ss, unsigned char *txb)
+static inline void __dahdi_process_getaudio_chunk(struct dahdi_chan *ss, unsigned char *txb)
 {
 	/* We transmit data from our master channel */
 	/* Called with ss->lock held */
-	struct zt_chan *ms = ss->master;
+	struct dahdi_chan *ms = ss->master;
 	/* Linear representation */
-	short getlin[ZT_CHUNKSIZE], k[ZT_CHUNKSIZE];
+	short getlin[DAHDI_CHUNKSIZE], k[DAHDI_CHUNKSIZE];
 	int x;
 
 	/* Okay, now we've got something to transmit */
-	for (x=0;x<ZT_CHUNKSIZE;x++)
-		getlin[x] = ZT_XLAW(txb[x], ms);
+	for (x=0;x<DAHDI_CHUNKSIZE;x++)
+		getlin[x] = DAHDI_XLAW(txb[x], ms);
 #ifndef NO_ECHOCAN_DISABLE
 	if (ms->ec) {
-		for (x=0;x<ZT_CHUNKSIZE;x++) {
+		for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 			/* Check for echo cancel disabling tone */
 			if (echo_can_disable_detector_update(&ms->txecdis, getlin[x])) {
 				printk("zaptel Disabled echo canceller because of tone (tx) on channel %d\n", ss->channo);
@@ -5492,84 +5492,84 @@ static inline void __zt_process_getaudio_chunk(struct zt_chan *ss, unsigned char
 				ms->echotimer = 0;
 				echo_can_free(ms->ec);
 				ms->ec = NULL;
-				__qevent(ss, ZT_EVENT_EC_DISABLED);
+				__qevent(ss, DAHDI_EVENT_EC_DISABLED);
 				break;
 			}
 		}
 	}
 #endif
-	if ((!ms->confmute && !ms->dialing) || (ms->flags & ZT_FLAG_PSEUDO)) {
+	if ((!ms->confmute && !ms->dialing) || (ms->flags & DAHDI_FLAG_PSEUDO)) {
 		/* Handle conferencing on non-clear channel and non-HDLC channels */
-		switch(ms->confmode & ZT_CONF_MODE_MASK) {
-		case ZT_CONF_NORMAL:
+		switch(ms->confmode & DAHDI_CONF_MODE_MASK) {
+		case DAHDI_CONF_NORMAL:
 			/* Do nuffin */
 			break;
-		case ZT_CONF_MONITOR:	/* Monitor a channel's rx mode */
+		case DAHDI_CONF_MONITOR:	/* Monitor a channel's rx mode */
 			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO) break;
+			if (ms->flags & DAHDI_FLAG_PSEUDO) break;
 			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_FLAG_PSEUDO) {
+			if (chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO) {
 				ACSS(getlin, chans[ms->confna]->getlin);
 			} else {
 				ACSS(getlin, chans[ms->confna]->putlin);
 			}
-			for (x=0;x<ZT_CHUNKSIZE;x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
+			for (x=0;x<DAHDI_CHUNKSIZE;x++)
+				txb[x] = DAHDI_LIN2X(getlin[x], ms);
 			break;
-		case ZT_CONF_MONITORTX: /* Monitor a channel's tx mode */
+		case DAHDI_CONF_MONITORTX: /* Monitor a channel's tx mode */
 			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO) break;
+			if (ms->flags & DAHDI_FLAG_PSEUDO) break;
 			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_FLAG_PSEUDO) {
+			if (chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO) {
 				ACSS(getlin, chans[ms->confna]->putlin);
 			} else {
 				ACSS(getlin, chans[ms->confna]->getlin);
 			}
 
-			for (x=0;x<ZT_CHUNKSIZE;x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
+			for (x=0;x<DAHDI_CHUNKSIZE;x++)
+				txb[x] = DAHDI_LIN2X(getlin[x], ms);
 			break;
-		case ZT_CONF_MONITORBOTH: /* monitor a channel's rx and tx mode */
+		case DAHDI_CONF_MONITORBOTH: /* monitor a channel's rx and tx mode */
 			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO) break;
+			if (ms->flags & DAHDI_FLAG_PSEUDO) break;
 			ACSS(getlin, chans[ms->confna]->putlin);
 			ACSS(getlin, chans[ms->confna]->getlin);
-			for (x=0;x<ZT_CHUNKSIZE;x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
+			for (x=0;x<DAHDI_CHUNKSIZE;x++)
+				txb[x] = DAHDI_LIN2X(getlin[x], ms);
 			break;
-		case ZT_CONF_MONITOR_RX_PREECHO:	/* Monitor a channel's rx mode */
+		case DAHDI_CONF_MONITOR_RX_PREECHO:	/* Monitor a channel's rx mode */
 			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO)
+			if (ms->flags & DAHDI_FLAG_PSEUDO)
 				break;
 
 			if (!chans[ms->confna]->readchunkpreec)
 				break;
 
 			/* Add monitored channel */
-			ACSS(getlin, chans[ms->confna]->flags & ZT_FLAG_PSEUDO ?
+			ACSS(getlin, chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO ?
 			     chans[ms->confna]->readchunkpreec : chans[ms->confna]->putlin);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
+			for (x = 0; x < DAHDI_CHUNKSIZE; x++)
+				txb[x] = DAHDI_LIN2X(getlin[x], ms);
 
 			break;
-		case ZT_CONF_MONITOR_TX_PREECHO: /* Monitor a channel's tx mode */
+		case DAHDI_CONF_MONITOR_TX_PREECHO: /* Monitor a channel's tx mode */
 			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO)
+			if (ms->flags & DAHDI_FLAG_PSEUDO)
 				break;
 
 			if (!chans[ms->confna]->readchunkpreec)
 				break;
 
 			/* Add monitored channel */
-			ACSS(getlin, chans[ms->confna]->flags & ZT_FLAG_PSEUDO ?
+			ACSS(getlin, chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO ?
 			     chans[ms->confna]->putlin : chans[ms->confna]->readchunkpreec);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
+			for (x = 0; x < DAHDI_CHUNKSIZE; x++)
+				txb[x] = DAHDI_LIN2X(getlin[x], ms);
 
 			break;
-		case ZT_CONF_MONITORBOTH_PREECHO: /* monitor a channel's rx and tx mode */
+		case DAHDI_CONF_MONITORBOTH_PREECHO: /* monitor a channel's rx and tx mode */
 			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO)
+			if (ms->flags & DAHDI_FLAG_PSEUDO)
 				break;
 
 			if (!chans[ms->confna]->readchunkpreec)
@@ -5578,144 +5578,144 @@ static inline void __zt_process_getaudio_chunk(struct zt_chan *ss, unsigned char
 			ACSS(getlin, chans[ms->confna]->putlin);
 			ACSS(getlin, chans[ms->confna]->readchunkpreec);
 
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
+			for (x = 0; x < DAHDI_CHUNKSIZE; x++)
+				txb[x] = DAHDI_LIN2X(getlin[x], ms);
 
 			break;
-		case ZT_CONF_REALANDPSEUDO:
+		case DAHDI_CONF_REALANDPSEUDO:
 			/* This strange mode takes the transmit buffer and
 				puts it on the conference, minus its last sample,
 				then outputs from the conference minus the 
 				real channel's last sample. */
 			  /* if to talk on conf */
-			if (ms->confmode & ZT_CONF_PSEUDO_TALKER) {
+			if (ms->confmode & DAHDI_CONF_PSEUDO_TALKER) {
 				/* Store temp value */
-				memcpy(k, getlin, ZT_CHUNKSIZE * sizeof(short));
+				memcpy(k, getlin, DAHDI_CHUNKSIZE * sizeof(short));
 				/* Add conf value */
 				ACSS(k, conf_sums_next[ms->_confn]);
 				/* save last one */
-				memcpy(ms->conflast2, ms->conflast1, ZT_CHUNKSIZE * sizeof(short));
-				memcpy(ms->conflast1, k, ZT_CHUNKSIZE * sizeof(short));
+				memcpy(ms->conflast2, ms->conflast1, DAHDI_CHUNKSIZE * sizeof(short));
+				memcpy(ms->conflast1, k, DAHDI_CHUNKSIZE * sizeof(short));
 				/*  get amount actually added */
 				SCSS(ms->conflast1, conf_sums_next[ms->_confn]);
 				/* Really add in new value */
 				ACSS(conf_sums_next[ms->_confn], ms->conflast1);
 			} else {
-				memset(ms->conflast1, 0, ZT_CHUNKSIZE * sizeof(short));
-				memset(ms->conflast2, 0, ZT_CHUNKSIZE * sizeof(short));
+				memset(ms->conflast1, 0, DAHDI_CHUNKSIZE * sizeof(short));
+				memset(ms->conflast2, 0, DAHDI_CHUNKSIZE * sizeof(short));
 			}
-			memset(getlin, 0, ZT_CHUNKSIZE * sizeof(short));
-			txb[0] = ZT_LIN2X(0, ms);
-			memset(txb + 1, txb[0], ZT_CHUNKSIZE - 1);
+			memset(getlin, 0, DAHDI_CHUNKSIZE * sizeof(short));
+			txb[0] = DAHDI_LIN2X(0, ms);
+			memset(txb + 1, txb[0], DAHDI_CHUNKSIZE - 1);
 			/* fall through to normal conf mode */
-		case ZT_CONF_CONF:	/* Normal conference mode */
-			if (ms->flags & ZT_FLAG_PSEUDO) /* if pseudo-channel */
+		case DAHDI_CONF_CONF:	/* Normal conference mode */
+			if (ms->flags & DAHDI_FLAG_PSEUDO) /* if pseudo-channel */
 			   {
 				  /* if to talk on conf */
-				if (ms->confmode & ZT_CONF_TALKER) {
+				if (ms->confmode & DAHDI_CONF_TALKER) {
 					/* Store temp value */
-					memcpy(k, getlin, ZT_CHUNKSIZE * sizeof(short));
+					memcpy(k, getlin, DAHDI_CHUNKSIZE * sizeof(short));
 					/* Add conf value */
 					ACSS(k, conf_sums[ms->_confn]);
 					/*  get amount actually added */
-					memcpy(ms->conflast, k, ZT_CHUNKSIZE * sizeof(short));
+					memcpy(ms->conflast, k, DAHDI_CHUNKSIZE * sizeof(short));
 					SCSS(ms->conflast, conf_sums[ms->_confn]);
 					/* Really add in new value */
 					ACSS(conf_sums[ms->_confn], ms->conflast);
-					memcpy(ms->getlin, getlin, ZT_CHUNKSIZE * sizeof(short));
+					memcpy(ms->getlin, getlin, DAHDI_CHUNKSIZE * sizeof(short));
 				} else {
-					memset(ms->conflast, 0, ZT_CHUNKSIZE * sizeof(short));
-					memcpy(getlin, ms->getlin, ZT_CHUNKSIZE * sizeof(short));
+					memset(ms->conflast, 0, DAHDI_CHUNKSIZE * sizeof(short));
+					memcpy(getlin, ms->getlin, DAHDI_CHUNKSIZE * sizeof(short));
 				}
-				txb[0] = ZT_LIN2X(0, ms);
-				memset(txb + 1, txb[0], ZT_CHUNKSIZE - 1);
+				txb[0] = DAHDI_LIN2X(0, ms);
+				memset(txb + 1, txb[0], DAHDI_CHUNKSIZE - 1);
 				break;
 		 	   }
 			/* fall through */
-		case ZT_CONF_CONFMON:	/* Conference monitor mode */
-			if (ms->confmode & ZT_CONF_LISTENER) {
+		case DAHDI_CONF_CONFMON:	/* Conference monitor mode */
+			if (ms->confmode & DAHDI_CONF_LISTENER) {
 				/* Subtract out last sample written to conf */
 				SCSS(getlin, ms->conflast);
 				/* Add in conference */
 				ACSS(getlin, conf_sums[ms->_confn]);
 			}
-			for (x=0;x<ZT_CHUNKSIZE;x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
+			for (x=0;x<DAHDI_CHUNKSIZE;x++)
+				txb[x] = DAHDI_LIN2X(getlin[x], ms);
 			break;
-		case ZT_CONF_CONFANN:
-		case ZT_CONF_CONFANNMON:
+		case DAHDI_CONF_CONFANN:
+		case DAHDI_CONF_CONFANNMON:
 			/* First, add tx buffer to conf */
 			ACSS(conf_sums_next[ms->_confn], getlin);
 			/* Start with silence */
-			memset(getlin, 0, ZT_CHUNKSIZE * sizeof(short));
+			memset(getlin, 0, DAHDI_CHUNKSIZE * sizeof(short));
 			/* If a listener on the conf... */
-			if (ms->confmode & ZT_CONF_LISTENER) {
+			if (ms->confmode & DAHDI_CONF_LISTENER) {
 				/* Subtract last value written */
 				SCSS(getlin, ms->conflast);
 				/* Add in conf */
 				ACSS(getlin, conf_sums[ms->_confn]);
 			}
-			for (x=0;x<ZT_CHUNKSIZE;x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
+			for (x=0;x<DAHDI_CHUNKSIZE;x++)
+				txb[x] = DAHDI_LIN2X(getlin[x], ms);
 			break;
-		case ZT_CONF_DIGITALMON:
+		case DAHDI_CONF_DIGITALMON:
 			/* Real digital monitoring, but still echo cancel if desired */
 			if (!chans[ms->confna])
 				break;
-			if (chans[ms->confna]->flags & ZT_FLAG_PSEUDO) {
+			if (chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO) {
 				if (ms->ec) {
-					for (x=0;x<ZT_CHUNKSIZE;x++)
-						txb[x] = ZT_LIN2X(chans[ms->confna]->getlin[x], ms);
+					for (x=0;x<DAHDI_CHUNKSIZE;x++)
+						txb[x] = DAHDI_LIN2X(chans[ms->confna]->getlin[x], ms);
 				} else {
-					memcpy(txb, chans[ms->confna]->getraw, ZT_CHUNKSIZE);
+					memcpy(txb, chans[ms->confna]->getraw, DAHDI_CHUNKSIZE);
 				}
 			} else {
 				if (ms->ec) {
-					for (x=0;x<ZT_CHUNKSIZE;x++)
-						txb[x] = ZT_LIN2X(chans[ms->confna]->putlin[x], ms);
+					for (x=0;x<DAHDI_CHUNKSIZE;x++)
+						txb[x] = DAHDI_LIN2X(chans[ms->confna]->putlin[x], ms);
 				} else {
-					memcpy(txb, chans[ms->confna]->putraw, ZT_CHUNKSIZE);
+					memcpy(txb, chans[ms->confna]->putraw, DAHDI_CHUNKSIZE);
 				}
 			}
-			for (x=0;x<ZT_CHUNKSIZE;x++)
-				getlin[x] = ZT_XLAW(txb[x], ms);
+			for (x=0;x<DAHDI_CHUNKSIZE;x++)
+				getlin[x] = DAHDI_XLAW(txb[x], ms);
 			break;
 		}
 	}
 	if (ms->confmute || (ms->echostate & __ECHO_STATE_MUTE)) {
-		txb[0] = ZT_LIN2X(0, ms);
-		memset(txb + 1, txb[0], ZT_CHUNKSIZE - 1);
+		txb[0] = DAHDI_LIN2X(0, ms);
+		memset(txb + 1, txb[0], DAHDI_CHUNKSIZE - 1);
 		if (ms->echostate == ECHO_STATE_STARTTRAINING) {
 			/* Transmit impulse now */
-			txb[0] = ZT_LIN2X(16384, ms);
+			txb[0] = DAHDI_LIN2X(16384, ms);
 			ms->echostate = ECHO_STATE_AWAITINGECHO;
 		}
 	}
 	/* save value from last chunk */
-	memcpy(ms->getlin_lastchunk, ms->getlin, ZT_CHUNKSIZE * sizeof(short));
+	memcpy(ms->getlin_lastchunk, ms->getlin, DAHDI_CHUNKSIZE * sizeof(short));
 	/* save value from current */
-	memcpy(ms->getlin, getlin, ZT_CHUNKSIZE * sizeof(short));
+	memcpy(ms->getlin, getlin, DAHDI_CHUNKSIZE * sizeof(short));
 	/* save value from current */
-	memcpy(ms->getraw, txb, ZT_CHUNKSIZE);
+	memcpy(ms->getraw, txb, DAHDI_CHUNKSIZE);
 	/* if to make tx tone */
 	if (ms->v1_1 || ms->v2_1 || ms->v3_1)
 	{
-		for (x=0;x<ZT_CHUNKSIZE;x++)
+		for (x=0;x<DAHDI_CHUNKSIZE;x++)
 		{
-			getlin[x] += zt_txtone_nextsample(ms);
-			txb[x] = ZT_LIN2X(getlin[x], ms);
+			getlin[x] += dahdi_txtone_nextsample(ms);
+			txb[x] = DAHDI_LIN2X(getlin[x], ms);
 		}
 	}
 	/* This is what to send (after having applied gain) */
-	for (x=0;x<ZT_CHUNKSIZE;x++)
+	for (x=0;x<DAHDI_CHUNKSIZE;x++)
 		txb[x] = ms->txgain[txb[x]];
 }
 
-static inline void __zt_getbuf_chunk(struct zt_chan *ss, unsigned char *txb)
+static inline void __dahdi_getbuf_chunk(struct dahdi_chan *ss, unsigned char *txb)
 {
 	/* Called with ss->lock held */
 	/* We transmit data from our master channel */
-	struct zt_chan *ms = ss->master;
+	struct dahdi_chan *ms = ss->master;
 	/* Buffer we're using */
 	unsigned char *buf;
 	/* Old buffer number */
@@ -5723,7 +5723,7 @@ static inline void __zt_getbuf_chunk(struct zt_chan *ss, unsigned char *txb)
 	/* Linear representation */
 	int getlin;
 	/* How many bytes we need to process */
-	int bytes = ZT_CHUNKSIZE, left;
+	int bytes = DAHDI_CHUNKSIZE, left;
 	int x;
 
 	/* Let's pick something to transmit.  First source to
@@ -5735,7 +5735,7 @@ static inline void __zt_getbuf_chunk(struct zt_chan *ss, unsigned char *txb)
 			left = ms->writen[ms->outwritebuf] - ms->writeidx[ms->outwritebuf];
 			if (left > bytes)
 				left = bytes;
-			if (ms->flags & ZT_FLAG_HDLC) {
+			if (ms->flags & DAHDI_FLAG_HDLC) {
 				/* If this is an HDLC channel we only send a byte of
 				   HDLC. */
 				for(x=0;x<left;x++) {
@@ -5759,26 +5759,26 @@ static inline void __zt_getbuf_chunk(struct zt_chan *ss, unsigned char *txb)
 				ms->writeidx[oldbuf] = 0;
 				ms->outwritebuf = (ms->outwritebuf + 1) % ms->numbufs;
 
-				if (!(ms->flags & ZT_FLAG_MTP2)) {
+				if (!(ms->flags & DAHDI_FLAG_MTP2)) {
 					ms->writen[oldbuf] = 0;
 					if (ms->outwritebuf == ms->inwritebuf) {
 						/* Whoopsies, we're run out of buffers.  Mark ours
 						as -1 and wait for the filler to notify us that
 						there is something to write */
 						ms->outwritebuf = -1;
-						if (ms->iomask & (ZT_IOMUX_WRITE | ZT_IOMUX_WRITEEMPTY))
+						if (ms->iomask & (DAHDI_IOMUX_WRITE | DAHDI_IOMUX_WRITEEMPTY))
 							wake_up_interruptible(&ms->eventbufq);
 						/* If we're only supposed to start when full, disable the transmitter */
-						if (ms->txbufpolicy == ZT_POLICY_WHEN_FULL)
+						if (ms->txbufpolicy == DAHDI_POLICY_WHEN_FULL)
 							ms->txdisable = 1;
 					}
 				} else {
 					if (ms->outwritebuf == ms->inwritebuf) {
 						ms->outwritebuf = oldbuf;
-						if (ms->iomask & (ZT_IOMUX_WRITE | ZT_IOMUX_WRITEEMPTY))
+						if (ms->iomask & (DAHDI_IOMUX_WRITE | DAHDI_IOMUX_WRITEEMPTY))
 							wake_up_interruptible(&ms->eventbufq);
 						/* If we're only supposed to start when full, disable the transmitter */
-						if (ms->txbufpolicy == ZT_POLICY_WHEN_FULL)
+						if (ms->txbufpolicy == DAHDI_POLICY_WHEN_FULL)
 							ms->txdisable = 1;
 					}
 				}
@@ -5797,39 +5797,39 @@ in the read or iomux call, etc). That is why the write and iomux calls start
 with an infinite loop that gets broken out of upon an active condition,
 otherwise keeps sleeping and looking. The part in this code got "optimized"
 out in the later versions, and is put back now. */
-				if (!(ms->flags & (ZT_FLAG_NETDEV | ZT_FLAG_PPP))) {
+				if (!(ms->flags & (DAHDI_FLAG_NETDEV | DAHDI_FLAG_PPP))) {
 					wake_up_interruptible(&ms->writebufq);
 					wake_up_interruptible(&ms->sel);
-					if (ms->iomask & ZT_IOMUX_WRITE)
+					if (ms->iomask & DAHDI_IOMUX_WRITE)
 						wake_up_interruptible(&ms->eventbufq);
 				}
 				/* Transmit a flag if this is an HDLC channel */
-				if (ms->flags & ZT_FLAG_HDLC)
+				if (ms->flags & DAHDI_FLAG_HDLC)
 					fasthdlc_tx_frame_nocheck(&ms->txhdlc);
 #ifdef CONFIG_ZAPATA_NET
-				if (ms->flags & ZT_FLAG_NETDEV)
+				if (ms->flags & DAHDI_FLAG_NETDEV)
 					netif_wake_queue(ztchan_to_dev(ms));
 #endif				
 #ifdef CONFIG_ZAPATA_PPP
-				if (ms->flags & ZT_FLAG_PPP) {
+				if (ms->flags & DAHDI_FLAG_PPP) {
 					ms->do_ppp_wakeup = 1;
 					tasklet_schedule(&ms->ppp_calls);
 				}
 #endif
 			}
-		} else if (ms->curtone && !(ms->flags & ZT_FLAG_PSEUDO)) {
+		} else if (ms->curtone && !(ms->flags & DAHDI_FLAG_PSEUDO)) {
 			left = ms->curtone->tonesamples - ms->tonep;
 			if (left > bytes)
 				left = bytes;
 			for (x=0;x<left;x++) {
 				/* Pick our default value from the next sample of the current tone */
-				getlin = zt_tone_nextsample(&ms->ts, ms->curtone);
-				*(txb++) = ZT_LIN2X(getlin, ms);
+				getlin = dahdi_tone_nextsample(&ms->ts, ms->curtone);
+				*(txb++) = DAHDI_LIN2X(getlin, ms);
 			}
 			ms->tonep+=left;
 			bytes -= left;
 			if (ms->tonep >= ms->curtone->tonesamples) {
-				struct zt_tone *last;
+				struct dahdi_tone *last;
 				/* Go to the next sample of the tone */
 				ms->tonep = 0;
 				last = ms->curtone;
@@ -5840,14 +5840,14 @@ out in the later versions, and is put back now. */
 						__do_dtmf(ms);
 				} else {
 					if (last != ms->curtone)
-						zt_init_tone_state(&ms->ts, ms->curtone);
+						dahdi_init_tone_state(&ms->ts, ms->curtone);
 				}
 			}
-		} else if (ms->flags & ZT_FLAG_LOOPED) {
+		} else if (ms->flags & DAHDI_FLAG_LOOPED) {
 			for (x = 0; x < bytes; x++)
 				txb[x] = ms->readchunk[x];
 			bytes = 0;
-		} else if (ms->flags & ZT_FLAG_HDLC) {
+		} else if (ms->flags & DAHDI_FLAG_HDLC) {
 			for (x=0;x<bytes;x++) {
 				/* Okay, if we're HDLC, then transmit a flag by default */
 				if (ms->txhdlc.bits < 8) 
@@ -5855,62 +5855,62 @@ out in the later versions, and is put back now. */
 				*(txb++) = fasthdlc_tx_run_nocheck(&ms->txhdlc);
 			}
 			bytes = 0;
-		} else if (ms->flags & ZT_FLAG_CLEAR) {
+		} else if (ms->flags & DAHDI_FLAG_CLEAR) {
 			/* Clear channels that are idle in audio mode need
 			   to send silence; in non-audio mode, always send 0xff
 			   so stupid switches won't consider the channel active
 			*/
-			if (ms->flags & ZT_FLAG_AUDIO) {
-				memset(txb, ZT_LIN2X(0, ms), bytes);
+			if (ms->flags & DAHDI_FLAG_AUDIO) {
+				memset(txb, DAHDI_LIN2X(0, ms), bytes);
 			} else {
 				memset(txb, 0xFF, bytes);
 			}
 			bytes = 0;
 		} else {
-			memset(txb, ZT_LIN2X(0, ms), bytes);	/* Lastly we use silence on telephony channels */
+			memset(txb, DAHDI_LIN2X(0, ms), bytes);	/* Lastly we use silence on telephony channels */
 			bytes = 0;
 		}
 	}	
 }
 
-static inline void rbs_itimer_expire(struct zt_chan *chan)
+static inline void rbs_itimer_expire(struct dahdi_chan *chan)
 {
 	/* the only way this could have gotten here, is if a channel
 	    went onf hook longer then the wink or flash detect timeout */
 	/* Called with chan->lock held */
 	switch(chan->sig)
 	{
-	    case ZT_SIG_FXOLS:  /* if FXO, its definitely on hook */
-	    case ZT_SIG_FXOGS:
-	    case ZT_SIG_FXOKS:
-		__qevent(chan,ZT_EVENT_ONHOOK);
+	    case DAHDI_SIG_FXOLS:  /* if FXO, its definitely on hook */
+	    case DAHDI_SIG_FXOGS:
+	    case DAHDI_SIG_FXOKS:
+		__qevent(chan,DAHDI_EVENT_ONHOOK);
 		chan->gotgs = 0; 
 		break;
 #if defined(EMFLASH) || defined(EMPULSE)
-	    case ZT_SIG_EM:
-	    case ZT_SIG_EM_E1:
-		if (chan->rxhooksig == ZT_RXSIG_ONHOOK) {
-			__qevent(chan,ZT_EVENT_ONHOOK); 
+	    case DAHDI_SIG_EM:
+	    case DAHDI_SIG_EM_E1:
+		if (chan->rxhooksig == DAHDI_RXSIG_ONHOOK) {
+			__qevent(chan,DAHDI_EVENT_ONHOOK); 
 			break;
 		}
-		__qevent(chan,ZT_EVENT_RINGOFFHOOK); 
+		__qevent(chan,DAHDI_EVENT_RINGOFFHOOK); 
 		break;
 #endif
 #ifdef	FXSFLASH
-	    case ZT_SIG_FXSKS:
-		if (chan->rxhooksig == ZT_RXSIG_ONHOOK) {
-			__qevent(chan, ZT_EVENT_ONHOOK); 
+	    case DAHDI_SIG_FXSKS:
+		if (chan->rxhooksig == DAHDI_RXSIG_ONHOOK) {
+			__qevent(chan, DAHDI_EVENT_ONHOOK); 
 			break;
 		}
 #endif
 		/* fall thru intentionally */
 	    default:  /* otherwise, its definitely off hook */
-		__qevent(chan,ZT_EVENT_RINGOFFHOOK); 
+		__qevent(chan,DAHDI_EVENT_RINGOFFHOOK); 
 		break;
 	}
 }
 
-static inline void __rbs_otimer_expire(struct zt_chan *chan)
+static inline void __rbs_otimer_expire(struct dahdi_chan *chan)
 {
 	int len = 0;
 	/* Called with chan->lock held */
@@ -5918,10 +5918,10 @@ static inline void __rbs_otimer_expire(struct zt_chan *chan)
 	chan->otimer = 0;
 	/* Move to the next timer state */	
 	switch(chan->txstate) {
-	case ZT_TXSTATE_RINGOFF:
+	case DAHDI_TXSTATE_RINGOFF:
 		/* Turn on the ringer now that the silent time has passed */
 		++chan->cadencepos;
-		if (chan->cadencepos >= ZT_MAX_CADENCE)
+		if (chan->cadencepos >= DAHDI_MAX_CADENCE)
 			chan->cadencepos = chan->firstcadencepos;
 		len = chan->ringcadence[chan->cadencepos];
 
@@ -5930,14 +5930,14 @@ static inline void __rbs_otimer_expire(struct zt_chan *chan)
 			len = chan->ringcadence[chan->cadencepos];
 		}
 
-		zt_rbs_sethook(chan, ZT_TXSIG_START, ZT_TXSTATE_RINGON, len);
-		__qevent(chan, ZT_EVENT_RINGERON);
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_START, DAHDI_TXSTATE_RINGON, len);
+		__qevent(chan, DAHDI_EVENT_RINGERON);
 		break;
 		
-	case ZT_TXSTATE_RINGON:
+	case DAHDI_TXSTATE_RINGON:
 		/* Turn off the ringer now that the loud time has passed */
 		++chan->cadencepos;
-		if (chan->cadencepos >= ZT_MAX_CADENCE)
+		if (chan->cadencepos >= DAHDI_MAX_CADENCE)
 			chan->cadencepos = 0;
 		len = chan->ringcadence[chan->cadencepos];
 
@@ -5946,93 +5946,93 @@ static inline void __rbs_otimer_expire(struct zt_chan *chan)
 			len = chan->curzone->ringcadence[chan->cadencepos];
 		}
 
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_RINGOFF, len);
-		__qevent(chan, ZT_EVENT_RINGEROFF);
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_RINGOFF, len);
+		__qevent(chan, DAHDI_EVENT_RINGEROFF);
 		break;
 		
-	case ZT_TXSTATE_START:
+	case DAHDI_TXSTATE_START:
 		/* If we were starting, go off hook now ready to debounce */
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_AFTERSTART, ZT_AFTERSTART_TIME);
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_AFTERSTART, DAHDI_AFTERSTART_TIME);
 		wake_up_interruptible(&chan->txstateq);
 		break;
 		
-	case ZT_TXSTATE_PREWINK:
+	case DAHDI_TXSTATE_PREWINK:
 		/* Actually wink */
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_WINK, chan->winktime);
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_WINK, chan->winktime);
 		break;
 		
-	case ZT_TXSTATE_WINK:
+	case DAHDI_TXSTATE_WINK:
 		/* Wink complete, go on hook and stabalize */
-		zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_ONHOOK, 0);
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_ONHOOK, DAHDI_TXSTATE_ONHOOK, 0);
 		if (chan->file && (chan->file->f_flags & O_NONBLOCK))
-			__qevent(chan, ZT_EVENT_HOOKCOMPLETE);
+			__qevent(chan, DAHDI_EVENT_HOOKCOMPLETE);
 		wake_up_interruptible(&chan->txstateq);
 		break;
 		
-	case ZT_TXSTATE_PREFLASH:
+	case DAHDI_TXSTATE_PREFLASH:
 		/* Actually flash */
-		zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_FLASH, chan->flashtime);
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_ONHOOK, DAHDI_TXSTATE_FLASH, chan->flashtime);
 		break;
 
-	case ZT_TXSTATE_FLASH:
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_OFFHOOK, 0);
+	case DAHDI_TXSTATE_FLASH:
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_OFFHOOK, 0);
 		if (chan->file && (chan->file->f_flags & O_NONBLOCK))
-			__qevent(chan, ZT_EVENT_HOOKCOMPLETE);
+			__qevent(chan, DAHDI_EVENT_HOOKCOMPLETE);
 		wake_up_interruptible(&chan->txstateq);
 		break;
 	
-	case ZT_TXSTATE_DEBOUNCE:
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_OFFHOOK, 0);
+	case DAHDI_TXSTATE_DEBOUNCE:
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_OFFHOOK, 0);
 		/* See if we've gone back on hook */
-		if ((chan->rxhooksig == ZT_RXSIG_ONHOOK) && (chan->rxflashtime > 2))
-			chan->itimerset = chan->itimer = chan->rxflashtime * ZT_CHUNKSIZE;
+		if ((chan->rxhooksig == DAHDI_RXSIG_ONHOOK) && (chan->rxflashtime > 2))
+			chan->itimerset = chan->itimer = chan->rxflashtime * DAHDI_CHUNKSIZE;
 		wake_up_interruptible(&chan->txstateq);
 		break;
 		
-	case ZT_TXSTATE_AFTERSTART:
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_OFFHOOK, 0);
+	case DAHDI_TXSTATE_AFTERSTART:
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_OFFHOOK, 0);
 		if (chan->file && (chan->file->f_flags & O_NONBLOCK))
-			__qevent(chan, ZT_EVENT_HOOKCOMPLETE);
+			__qevent(chan, DAHDI_EVENT_HOOKCOMPLETE);
 		wake_up_interruptible(&chan->txstateq);
 		break;
 
-	case ZT_TXSTATE_KEWL:
-		zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_AFTERKEWL, ZT_AFTERKEWLTIME);
+	case DAHDI_TXSTATE_KEWL:
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_ONHOOK, DAHDI_TXSTATE_AFTERKEWL, DAHDI_AFTERKEWLTIME);
 		if (chan->file && (chan->file->f_flags & O_NONBLOCK))
-			__qevent(chan, ZT_EVENT_HOOKCOMPLETE);
+			__qevent(chan, DAHDI_EVENT_HOOKCOMPLETE);
 		wake_up_interruptible(&chan->txstateq);
 		break;
 
-	case ZT_TXSTATE_AFTERKEWL:
+	case DAHDI_TXSTATE_AFTERKEWL:
 		if (chan->kewlonhook)  {
-			__qevent(chan,ZT_EVENT_ONHOOK);
+			__qevent(chan,DAHDI_EVENT_ONHOOK);
 		}
-		chan->txstate = ZT_TXSTATE_ONHOOK;
+		chan->txstate = DAHDI_TXSTATE_ONHOOK;
 		chan->gotgs = 0;
 		break;
 
-	case ZT_TXSTATE_PULSEBREAK:
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_PULSEMAKE, 
+	case DAHDI_TXSTATE_PULSEBREAK:
+		dahdi_rbs_sethook(chan, DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_PULSEMAKE, 
 			chan->pulsemaketime);
 		wake_up_interruptible(&chan->txstateq);
 		break;
 
-	case ZT_TXSTATE_PULSEMAKE:
+	case DAHDI_TXSTATE_PULSEMAKE:
 		if (chan->pdialcount)
 			chan->pdialcount--;
 		if (chan->pdialcount)
 		{
-			zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, 
-				ZT_TXSTATE_PULSEBREAK, chan->pulsebreaktime);
+			dahdi_rbs_sethook(chan, DAHDI_TXSIG_ONHOOK, 
+				DAHDI_TXSTATE_PULSEBREAK, chan->pulsebreaktime);
 			break;
 		}
-		chan->txstate = ZT_TXSTATE_PULSEAFTER;
-		chan->otimer = chan->pulseaftertime * ZT_CHUNKSIZE;
+		chan->txstate = DAHDI_TXSTATE_PULSEAFTER;
+		chan->otimer = chan->pulseaftertime * DAHDI_CHUNKSIZE;
 		wake_up_interruptible(&chan->txstateq);
 		break;
 
-	case ZT_TXSTATE_PULSEAFTER:
-		chan->txstate = ZT_TXSTATE_OFFHOOK;
+	case DAHDI_TXSTATE_PULSEAFTER:
+		chan->txstate = DAHDI_TXSTATE_OFFHOOK;
 		__do_dtmf(chan);
 		wake_up_interruptible(&chan->txstateq);
 		break;
@@ -6042,7 +6042,7 @@ static inline void __rbs_otimer_expire(struct zt_chan *chan)
 	}
 }
 
-static void __zt_hooksig_pvt(struct zt_chan *chan, zt_rxsig_t rxsig)
+static void __dahdi_hooksig_pvt(struct dahdi_chan *chan, dahdi_rxsig_t rxsig)
 {
 
 	/* State machines for receive hookstate transitions 
@@ -6050,24 +6050,24 @@ static void __zt_hooksig_pvt(struct zt_chan *chan, zt_rxsig_t rxsig)
 
 	if ((chan->rxhooksig) == rxsig) return;
 	
-	if ((chan->flags & ZT_FLAG_SIGFREEZE)) return;
+	if ((chan->flags & DAHDI_FLAG_SIGFREEZE)) return;
 
 	chan->rxhooksig = rxsig;
 #ifdef	RINGBEGIN
-	if ((chan->sig & __ZT_SIG_FXS) && (rxsig == ZT_RXSIG_RING) &&
+	if ((chan->sig & __DAHDI_SIG_FXS) && (rxsig == DAHDI_RXSIG_RING) &&
 	    (!chan->ringdebtimer))
-		__qevent(chan,ZT_EVENT_RINGBEGIN);  
+		__qevent(chan,DAHDI_EVENT_RINGBEGIN);  
 #endif
 	switch(chan->sig) {
-	    case ZT_SIG_EM:  /* E and M */
-	    case ZT_SIG_EM_E1:
+	    case DAHDI_SIG_EM:  /* E and M */
+	    case DAHDI_SIG_EM_E1:
 		switch(rxsig) {
-		    case ZT_RXSIG_OFFHOOK: /* went off hook */
+		    case DAHDI_RXSIG_OFFHOOK: /* went off hook */
 			/* The interface is going off hook */
 #ifdef	EMFLASH
 			if (chan->itimer)
 			{
-				__qevent(chan,ZT_EVENT_WINKFLASH); 
+				__qevent(chan,DAHDI_EVENT_WINKFLASH); 
 				chan->itimerset = chan->itimer = 0;
 				break;				
 			}
@@ -6076,36 +6076,36 @@ static void __zt_hooksig_pvt(struct zt_chan *chan, zt_rxsig_t rxsig)
 			if (chan->itimer) /* if timer still running */
 			{
 			    int plen = chan->itimerset - chan->itimer;
-			    if (plen <= ZT_MAXPULSETIME)
+			    if (plen <= DAHDI_MAXPULSETIME)
 			    {
-					if (plen >= ZT_MINPULSETIME)
+					if (plen >= DAHDI_MINPULSETIME)
 					{
 						chan->pulsecount++;
 
-						chan->pulsetimer = ZT_PULSETIMEOUT;
+						chan->pulsetimer = DAHDI_PULSETIMEOUT;
                                                 chan->itimerset = chan->itimer = 0;
 						if (chan->pulsecount == 1)
-							__qevent(chan,ZT_EVENT_PULSE_START); 
+							__qevent(chan,DAHDI_EVENT_PULSE_START); 
 					} 
 			    } 
 			    break;
 			}
 #endif
 			/* set wink timer */
-			chan->itimerset = chan->itimer = chan->rxwinktime * ZT_CHUNKSIZE;
+			chan->itimerset = chan->itimer = chan->rxwinktime * DAHDI_CHUNKSIZE;
 			break;
-		    case ZT_RXSIG_ONHOOK: /* went on hook */
+		    case DAHDI_RXSIG_ONHOOK: /* went on hook */
 			/* This interface is now going on hook.
 			   Check for WINK, etc */
 			if (chan->itimer)
-				__qevent(chan,ZT_EVENT_WINKFLASH); 
+				__qevent(chan,DAHDI_EVENT_WINKFLASH); 
 #if defined(EMFLASH) || defined(EMPULSE)
 			else {
 #ifdef EMFLASH
-				chan->itimerset = chan->itimer = chan->rxflashtime * ZT_CHUNKSIZE;
+				chan->itimerset = chan->itimer = chan->rxflashtime * DAHDI_CHUNKSIZE;
 
 #else /* EMFLASH */
-				chan->itimerset = chan->itimer = chan->rxwinktime * ZT_CHUNKSIZE;
+				chan->itimerset = chan->itimer = chan->rxwinktime * DAHDI_CHUNKSIZE;
 
 #endif /* EMFLASH */
 				chan->gotgs = 0;
@@ -6113,7 +6113,7 @@ static void __zt_hooksig_pvt(struct zt_chan *chan, zt_rxsig_t rxsig)
 			}
 #else /* EMFLASH || EMPULSE */
 			else {
-				__qevent(chan,ZT_EVENT_ONHOOK); 
+				__qevent(chan,DAHDI_EVENT_ONHOOK); 
 				chan->gotgs = 0;
 			}
 #endif
@@ -6123,50 +6123,50 @@ static void __zt_hooksig_pvt(struct zt_chan *chan, zt_rxsig_t rxsig)
 			break;
 		}
 		break;
-	   case ZT_SIG_FXSKS:  /* FXS Kewlstart */
+	   case DAHDI_SIG_FXSKS:  /* FXS Kewlstart */
 		  /* ignore a bit poopy if loop not closed and stable */
-		if (chan->txstate != ZT_TXSTATE_OFFHOOK) break;
+		if (chan->txstate != DAHDI_TXSTATE_OFFHOOK) break;
 #ifdef	FXSFLASH
-		if (rxsig == ZT_RXSIG_ONHOOK) {
-			chan->itimer = ZT_FXSFLASHMAXTIME * ZT_CHUNKSIZE;
+		if (rxsig == DAHDI_RXSIG_ONHOOK) {
+			chan->itimer = DAHDI_FXSFLASHMAXTIME * DAHDI_CHUNKSIZE;
 			break;
-		} else 	if (rxsig == ZT_RXSIG_OFFHOOK) {
+		} else 	if (rxsig == DAHDI_RXSIG_OFFHOOK) {
 			if (chan->itimer) {
 				/* did the offhook occur in the window? if not, ignore both events */
-				if (chan->itimer <= ((ZT_FXSFLASHMAXTIME - ZT_FXSFLASHMINTIME) * ZT_CHUNKSIZE))
-					__qevent(chan, ZT_EVENT_WINKFLASH);
+				if (chan->itimer <= ((DAHDI_FXSFLASHMAXTIME - DAHDI_FXSFLASHMINTIME) * DAHDI_CHUNKSIZE))
+					__qevent(chan, DAHDI_EVENT_WINKFLASH);
 			}
 			chan->itimer = 0;
 			break;
 		}
 #endif
 		/* fall through intentionally */
-	   case ZT_SIG_FXSGS:  /* FXS Groundstart */
-		if (rxsig == ZT_RXSIG_ONHOOK) {
+	   case DAHDI_SIG_FXSGS:  /* FXS Groundstart */
+		if (rxsig == DAHDI_RXSIG_ONHOOK) {
 			chan->ringdebtimer = RING_DEBOUNCE_TIME;
 			chan->ringtrailer = 0;
-			if (chan->txstate != ZT_TXSTATE_DEBOUNCE) {
+			if (chan->txstate != DAHDI_TXSTATE_DEBOUNCE) {
 				chan->gotgs = 0;
-				__qevent(chan,ZT_EVENT_ONHOOK);
+				__qevent(chan,DAHDI_EVENT_ONHOOK);
 			}
 		}
 		break;
-	   case ZT_SIG_FXOGS: /* FXO Groundstart */
-		if (rxsig == ZT_RXSIG_START) {
+	   case DAHDI_SIG_FXOGS: /* FXO Groundstart */
+		if (rxsig == DAHDI_RXSIG_START) {
 			  /* if havent got gs, report it */
 			if (!chan->gotgs) {
-				__qevent(chan,ZT_EVENT_RINGOFFHOOK);
+				__qevent(chan,DAHDI_EVENT_RINGOFFHOOK);
 				chan->gotgs = 1;
 			}
 		}
 		/* fall through intentionally */
-	   case ZT_SIG_FXOLS: /* FXO Loopstart */
-	   case ZT_SIG_FXOKS: /* FXO Kewlstart */
+	   case DAHDI_SIG_FXOLS: /* FXO Loopstart */
+	   case DAHDI_SIG_FXOKS: /* FXO Kewlstart */
 		switch(rxsig) {
-		    case ZT_RXSIG_OFFHOOK: /* went off hook */
+		    case DAHDI_RXSIG_OFFHOOK: /* went off hook */
 			  /* if asserti ng ring, stop it */
-			if (chan->txstate == ZT_TXSTATE_START) {
-				zt_rbs_sethook(chan,ZT_TXSIG_OFFHOOK, ZT_TXSTATE_AFTERSTART, ZT_AFTERSTART_TIME);
+			if (chan->txstate == DAHDI_TXSTATE_START) {
+				dahdi_rbs_sethook(chan,DAHDI_TXSIG_OFFHOOK, DAHDI_TXSTATE_AFTERSTART, DAHDI_AFTERSTART_TIME);
 			}
 			chan->kewlonhook = 0;
 #ifdef CONFIG_ZAPATA_DEBUG
@@ -6175,36 +6175,36 @@ static void __zt_hooksig_pvt(struct zt_chan *chan, zt_rxsig_t rxsig)
 			if (chan->itimer) /* if timer still running */
 			{
 			    int plen = chan->itimerset - chan->itimer;
-			    if (plen <= ZT_MAXPULSETIME)
+			    if (plen <= DAHDI_MAXPULSETIME)
 			    {
-					if (plen >= ZT_MINPULSETIME)
+					if (plen >= DAHDI_MINPULSETIME)
 					{
 						chan->pulsecount++;
-						chan->pulsetimer = ZT_PULSETIMEOUT;
+						chan->pulsetimer = DAHDI_PULSETIMEOUT;
 						chan->itimer = chan->itimerset;
 						if (chan->pulsecount == 1)
-							__qevent(chan,ZT_EVENT_PULSE_START); 
+							__qevent(chan,DAHDI_EVENT_PULSE_START); 
 					} 
 			    } else 
-					__qevent(chan,ZT_EVENT_WINKFLASH); 
+					__qevent(chan,DAHDI_EVENT_WINKFLASH); 
 			} else {
 				  /* if havent got GS detect */
 				if (!chan->gotgs) {
-					__qevent(chan,ZT_EVENT_RINGOFFHOOK); 
+					__qevent(chan,DAHDI_EVENT_RINGOFFHOOK); 
 					chan->gotgs = 1;
 					chan->itimerset = chan->itimer = 0;
 				}
 			}
 			chan->itimerset = chan->itimer = 0;
 			break;
-		    case ZT_RXSIG_ONHOOK: /* went on hook */
+		    case DAHDI_RXSIG_ONHOOK: /* went on hook */
 			  /* if not during offhook debounce time */
-			if ((chan->txstate != ZT_TXSTATE_DEBOUNCE) &&
-			    (chan->txstate != ZT_TXSTATE_KEWL) && 
-			    (chan->txstate != ZT_TXSTATE_AFTERKEWL)) {
-				chan->itimerset = chan->itimer = chan->rxflashtime * ZT_CHUNKSIZE;
+			if ((chan->txstate != DAHDI_TXSTATE_DEBOUNCE) &&
+			    (chan->txstate != DAHDI_TXSTATE_KEWL) && 
+			    (chan->txstate != DAHDI_TXSTATE_AFTERKEWL)) {
+				chan->itimerset = chan->itimer = chan->rxflashtime * DAHDI_CHUNKSIZE;
 			}
-			if (chan->txstate == ZT_TXSTATE_KEWL)
+			if (chan->txstate == DAHDI_TXSTATE_KEWL)
 				chan->kewlonhook = 1;
 			break;
 		    default:
@@ -6215,61 +6215,61 @@ static void __zt_hooksig_pvt(struct zt_chan *chan, zt_rxsig_t rxsig)
 	}
 }
 
-void zt_hooksig(struct zt_chan *chan, zt_rxsig_t rxsig)
+void dahdi_hooksig(struct dahdi_chan *chan, dahdi_rxsig_t rxsig)
 {
 	  /* skip if no change */
 	unsigned long flags;
 	spin_lock_irqsave(&chan->lock, flags);
-	__zt_hooksig_pvt(chan,rxsig);
+	__dahdi_hooksig_pvt(chan,rxsig);
 	spin_unlock_irqrestore(&chan->lock, flags);
 }
 
-void zt_rbsbits(struct zt_chan *chan, int cursig)
+void dahdi_rbsbits(struct dahdi_chan *chan, int cursig)
 {
 	unsigned long flags;
 	if (cursig == chan->rxsig)
 		return;
 
-	if ((chan->flags & ZT_FLAG_SIGFREEZE)) return;
+	if ((chan->flags & DAHDI_FLAG_SIGFREEZE)) return;
 
 	spin_lock_irqsave(&chan->lock, flags);
 	switch(chan->sig) {
-	    case ZT_SIG_FXOGS: /* FXO Groundstart */
+	    case DAHDI_SIG_FXOGS: /* FXO Groundstart */
 		/* B-bit only matters for FXO GS */
-		if (!(cursig & ZT_BBIT)) {
-			__zt_hooksig_pvt(chan, ZT_RXSIG_START);
+		if (!(cursig & DAHDI_BBIT)) {
+			__dahdi_hooksig_pvt(chan, DAHDI_RXSIG_START);
 			break;
 		}
 		/* Fall through */
-	    case ZT_SIG_EM:  /* E and M */
-	    case ZT_SIG_EM_E1:
-	    case ZT_SIG_FXOLS: /* FXO Loopstart */
-	    case ZT_SIG_FXOKS: /* FXO Kewlstart */
-		if (cursig & ZT_ABIT)  /* off hook */
-			__zt_hooksig_pvt(chan,ZT_RXSIG_OFFHOOK);
+	    case DAHDI_SIG_EM:  /* E and M */
+	    case DAHDI_SIG_EM_E1:
+	    case DAHDI_SIG_FXOLS: /* FXO Loopstart */
+	    case DAHDI_SIG_FXOKS: /* FXO Kewlstart */
+		if (cursig & DAHDI_ABIT)  /* off hook */
+			__dahdi_hooksig_pvt(chan,DAHDI_RXSIG_OFFHOOK);
 		else /* on hook */
-			__zt_hooksig_pvt(chan,ZT_RXSIG_ONHOOK);
+			__dahdi_hooksig_pvt(chan,DAHDI_RXSIG_ONHOOK);
 		break;
 
-	   case ZT_SIG_FXSKS:  /* FXS Kewlstart */
-	   case ZT_SIG_FXSGS:  /* FXS Groundstart */
+	   case DAHDI_SIG_FXSKS:  /* FXS Kewlstart */
+	   case DAHDI_SIG_FXSGS:  /* FXS Groundstart */
 		/* Fall through */
-	   case ZT_SIG_FXSLS:
-		if (!(cursig & ZT_BBIT)) {
+	   case DAHDI_SIG_FXSLS:
+		if (!(cursig & DAHDI_BBIT)) {
 			/* Check for ringing first */
-			__zt_hooksig_pvt(chan, ZT_RXSIG_RING);
+			__dahdi_hooksig_pvt(chan, DAHDI_RXSIG_RING);
 			break;
 		}
-		if ((chan->sig != ZT_SIG_FXSLS) && (cursig & ZT_ABIT)) { 
+		if ((chan->sig != DAHDI_SIG_FXSLS) && (cursig & DAHDI_ABIT)) { 
 			    /* if went on hook */
-			__zt_hooksig_pvt(chan, ZT_RXSIG_ONHOOK);
+			__dahdi_hooksig_pvt(chan, DAHDI_RXSIG_ONHOOK);
 		} else {
-			__zt_hooksig_pvt(chan, ZT_RXSIG_OFFHOOK);
+			__dahdi_hooksig_pvt(chan, DAHDI_RXSIG_OFFHOOK);
 		}
 		break;
-	   case ZT_SIG_CAS:
+	   case DAHDI_SIG_CAS:
 		/* send event that something changed */
-		__qevent(chan, ZT_EVENT_BITSCHANGED);
+		__qevent(chan, DAHDI_EVENT_BITSCHANGED);
 		break;
 
 	   default:
@@ -6280,7 +6280,7 @@ void zt_rbsbits(struct zt_chan *chan, int cursig)
 	spin_unlock_irqrestore(&chan->lock, flags);
 }
 
-static inline void __zt_ec_chunk(struct zt_chan *ss, unsigned char *rxchunk, const unsigned char *txchunk)
+static inline void __dahdi_ec_chunk(struct dahdi_chan *ss, unsigned char *rxchunk, const unsigned char *txchunk)
 {
 	short rxlin, txlin;
 	int x;
@@ -6290,21 +6290,21 @@ static inline void __zt_ec_chunk(struct zt_chan *ss, unsigned char *rxchunk, con
 
 	if (ss->readchunkpreec) {
 		/* Save a copy of the audio before the echo can has its way with it */
-		for (x = 0; x < ZT_CHUNKSIZE; x++)
+		for (x = 0; x < DAHDI_CHUNKSIZE; x++)
 			/* We only ever really need to deal with signed linear - let's just convert it now */
-			ss->readchunkpreec[x] = ZT_XLAW(rxchunk[x], ss);
+			ss->readchunkpreec[x] = DAHDI_XLAW(rxchunk[x], ss);
 	}
 
 	/* Perform echo cancellation on a chunk if necessary */
 	if (ss->ec) {
 #if defined(CONFIG_ZAPTEL_MMX) || defined(ECHO_CAN_FP)
-		zt_kernel_fpu_begin();
+		dahdi_kernel_fpu_begin();
 #endif		
 		if (ss->echostate & __ECHO_STATE_MUTE) {
 			/* Special stuff for training the echo can */
-			for (x=0;x<ZT_CHUNKSIZE;x++) {
-				rxlin = ZT_XLAW(rxchunk[x], ss);
-				txlin = ZT_XLAW(txchunk[x], ss);
+			for (x=0;x<DAHDI_CHUNKSIZE;x++) {
+				rxlin = DAHDI_XLAW(rxchunk[x], ss);
+				txlin = DAHDI_XLAW(txchunk[x], ss);
 				if (ss->echostate == ECHO_STATE_PRETRAINING) {
 					if (--ss->echotimer <= 0) {
 						ss->echotimer = 0;
@@ -6324,25 +6324,25 @@ static inline void __zt_ec_chunk(struct zt_chan *ss, unsigned char *rxchunk, con
 					}
 				}
 				rxlin = 0;
-				rxchunk[x] = ZT_LIN2X((int)rxlin, ss);
+				rxchunk[x] = DAHDI_LIN2X((int)rxlin, ss);
 			}
 		} else {
-#if !defined(ZT_EC_ARRAY_UPDATE)
-			for (x=0;x<ZT_CHUNKSIZE;x++) {
-				rxlin = ZT_XLAW(rxchunk[x], ss);
-				rxlin = echo_can_update(ss->ec, ZT_XLAW(txchunk[x], ss), rxlin);
-				rxchunk[x] = ZT_LIN2X((int) rxlin, ss);
+#if !defined(DAHDI_EC_ARRAY_UPDATE)
+			for (x=0;x<DAHDI_CHUNKSIZE;x++) {
+				rxlin = DAHDI_XLAW(rxchunk[x], ss);
+				rxlin = echo_can_update(ss->ec, DAHDI_XLAW(txchunk[x], ss), rxlin);
+				rxchunk[x] = DAHDI_LIN2X((int) rxlin, ss);
 			}
-#else /* defined(ZT_EC_ARRAY_UPDATE) */
-			short rxlins[ZT_CHUNKSIZE], txlins[ZT_CHUNKSIZE];
-			for (x = 0; x < ZT_CHUNKSIZE; x++) {
-				rxlins[x] = ZT_XLAW(rxchunk[x], ss);
-				txlins[x] = ZT_XLAW(txchunk[x], ss);
+#else /* defined(DAHDI_EC_ARRAY_UPDATE) */
+			short rxlins[DAHDI_CHUNKSIZE], txlins[DAHDI_CHUNKSIZE];
+			for (x = 0; x < DAHDI_CHUNKSIZE; x++) {
+				rxlins[x] = DAHDI_XLAW(rxchunk[x], ss);
+				txlins[x] = DAHDI_XLAW(txchunk[x], ss);
 			}
 			echo_can_array_update(ss->ec, rxlins, txlins);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				rxchunk[x] = ZT_LIN2X((int) rxlins[x], ss);
-#endif /* defined(ZT_EC_ARRAY_UPDATE) */
+			for (x = 0; x < DAHDI_CHUNKSIZE; x++)
+				rxchunk[x] = DAHDI_LIN2X((int) rxlins[x], ss);
+#endif /* defined(DAHDI_EC_ARRAY_UPDATE) */
 		}
 #if defined(CONFIG_ZAPTEL_MMX) || defined(ECHO_CAN_FP)
 		kernel_fpu_end();
@@ -6351,17 +6351,17 @@ static inline void __zt_ec_chunk(struct zt_chan *ss, unsigned char *rxchunk, con
 	spin_unlock_irqrestore(&ss->lock, flags);
 }
 
-void zt_ec_chunk(struct zt_chan *ss, unsigned char *rxchunk, const unsigned char *txchunk)
+void dahdi_ec_chunk(struct dahdi_chan *ss, unsigned char *rxchunk, const unsigned char *txchunk)
 {
-	__zt_ec_chunk(ss, rxchunk, txchunk);
+	__dahdi_ec_chunk(ss, rxchunk, txchunk);
 }
 
-void zt_ec_span(struct zt_span *span)
+void dahdi_ec_span(struct dahdi_span *span)
 {
 	int x;
 	for (x = 0; x < span->channels; x++) {
 		if (span->chans[x].ec)
-			__zt_ec_chunk(&span->chans[x], span->chans[x].readchunk, span->chans[x].writechunk);
+			__dahdi_ec_chunk(&span->chans[x], span->chans[x].readchunk, span->chans[x].writechunk);
 	}
 }
 
@@ -6374,7 +6374,7 @@ static inline int sf_detect (sf_detect_state_t *s,
 int     i,rv = 0;
 long x,y;
 
-#define	SF_DETECT_SAMPLES (ZT_CHUNKSIZE * 5)
+#define	SF_DETECT_SAMPLES (DAHDI_CHUNKSIZE * 5)
 #define	SF_DETECT_MIN_ENERGY 500
 #define	NB 14  /* number of bits to shift left */
          
@@ -6414,30 +6414,30 @@ long x,y;
 	return(rv);		
 }
 
-static inline void __zt_process_putaudio_chunk(struct zt_chan *ss, unsigned char *rxb)
+static inline void __dahdi_process_putaudio_chunk(struct dahdi_chan *ss, unsigned char *rxb)
 {
 	/* We transmit data from our master channel */
 	/* Called with ss->lock held */
-	struct zt_chan *ms = ss->master;
+	struct dahdi_chan *ms = ss->master;
 	/* Linear version of received data */
-	short putlin[ZT_CHUNKSIZE],k[ZT_CHUNKSIZE];
+	short putlin[DAHDI_CHUNKSIZE],k[DAHDI_CHUNKSIZE];
 	int x,r;
 
 	if (ms->dialing) ms->afterdialingtimer = 50;
 	else if (ms->afterdialingtimer) ms->afterdialingtimer--;
-	if (ms->afterdialingtimer && (!(ms->flags & ZT_FLAG_PSEUDO))) {
+	if (ms->afterdialingtimer && (!(ms->flags & DAHDI_FLAG_PSEUDO))) {
 		/* Be careful since memset is likely a macro */
-		rxb[0] = ZT_LIN2X(0, ms);
-		memset(&rxb[1], rxb[0], ZT_CHUNKSIZE - 1);  /* receive as silence if dialing */
+		rxb[0] = DAHDI_LIN2X(0, ms);
+		memset(&rxb[1], rxb[0], DAHDI_CHUNKSIZE - 1);  /* receive as silence if dialing */
 	} 
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		rxb[x] = ms->rxgain[rxb[x]];
-		putlin[x] = ZT_XLAW(rxb[x], ms);
+		putlin[x] = DAHDI_XLAW(rxb[x], ms);
 	}
 
 #ifndef NO_ECHOCAN_DISABLE
 	if (ms->ec) {
-		for (x=0;x<ZT_CHUNKSIZE;x++) {
+		for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 			if (echo_can_disable_detector_update(&ms->rxecdis, putlin[x])) {
 				printk("zaptel Disabled echo canceller because of tone (rx) on channel %d\n", ss->channo);
 				ms->echocancel = 0;
@@ -6454,71 +6454,71 @@ static inline void __zt_process_putaudio_chunk(struct zt_chan *ss, unsigned char
 	/* if doing rx tone decoding */
 	if (ms->rxp1 && ms->rxp2 && ms->rxp3)
 	{
-		r = sf_detect(&ms->rd,putlin,ZT_CHUNKSIZE,ms->rxp1,
+		r = sf_detect(&ms->rd,putlin,DAHDI_CHUNKSIZE,ms->rxp1,
 			ms->rxp2,ms->rxp3);
 		/* Convert back */
-		for(x=0;x<ZT_CHUNKSIZE;x++)
-			rxb[x] = ZT_LIN2X(putlin[x], ms);
+		for(x=0;x<DAHDI_CHUNKSIZE;x++)
+			rxb[x] = DAHDI_LIN2X(putlin[x], ms);
 		if (r) /* if something happened */
 		{
 			if (r != ms->rd.lastdetect)
 			{
-				if (((r == 2) && !(ms->toneflags & ZT_REVERSE_RXTONE)) ||
-				    ((r == 1) && (ms->toneflags & ZT_REVERSE_RXTONE)))
+				if (((r == 2) && !(ms->toneflags & DAHDI_REVERSE_RXTONE)) ||
+				    ((r == 1) && (ms->toneflags & DAHDI_REVERSE_RXTONE)))
 				{
-					__qevent(ms,ZT_EVENT_RINGOFFHOOK);
+					__qevent(ms,DAHDI_EVENT_RINGOFFHOOK);
 				}
 				else
 				{
-					__qevent(ms,ZT_EVENT_ONHOOK);
+					__qevent(ms,DAHDI_EVENT_ONHOOK);
 				}
 				ms->rd.lastdetect = r;
 			}
 		}
 	}		
 
-	if (!(ms->flags &  ZT_FLAG_PSEUDO)) {
-		memcpy(ms->putlin, putlin, ZT_CHUNKSIZE * sizeof(short));
-		memcpy(ms->putraw, rxb, ZT_CHUNKSIZE);
+	if (!(ms->flags &  DAHDI_FLAG_PSEUDO)) {
+		memcpy(ms->putlin, putlin, DAHDI_CHUNKSIZE * sizeof(short));
+		memcpy(ms->putraw, rxb, DAHDI_CHUNKSIZE);
 	}
 	
 	/* Take the rxc, twiddle it for conferencing if appropriate and put it
 	   back */
 	if ((!ms->confmute && !ms->afterdialingtimer) ||
-	    (ms->flags & ZT_FLAG_PSEUDO)) {
-		switch(ms->confmode & ZT_CONF_MODE_MASK) {
-		case ZT_CONF_NORMAL:		/* Normal mode */
+	    (ms->flags & DAHDI_FLAG_PSEUDO)) {
+		switch(ms->confmode & DAHDI_CONF_MODE_MASK) {
+		case DAHDI_CONF_NORMAL:		/* Normal mode */
 			/* Do nothing.  rx goes output */
 			break;
-		case ZT_CONF_MONITOR:		/* Monitor a channel's rx mode */
+		case DAHDI_CONF_MONITOR:		/* Monitor a channel's rx mode */
 			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO)) break;
+			if (!(ms->flags & DAHDI_FLAG_PSEUDO)) break;
 			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_FLAG_PSEUDO) {
+			if (chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO) {
 				ACSS(putlin, chans[ms->confna]->getlin);
 			} else {
 				ACSS(putlin, chans[ms->confna]->putlin);
 			}
 			/* Convert back */
-			for(x=0;x<ZT_CHUNKSIZE;x++)
-				rxb[x] = ZT_LIN2X(putlin[x], ms);
+			for(x=0;x<DAHDI_CHUNKSIZE;x++)
+				rxb[x] = DAHDI_LIN2X(putlin[x], ms);
 			break;
-		case ZT_CONF_MONITORTX:	/* Monitor a channel's tx mode */
+		case DAHDI_CONF_MONITORTX:	/* Monitor a channel's tx mode */
 			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO)) break;
+			if (!(ms->flags & DAHDI_FLAG_PSEUDO)) break;
 			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_FLAG_PSEUDO) {
+			if (chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO) {
 				ACSS(putlin, chans[ms->confna]->putlin);
 			} else {
 				ACSS(putlin, chans[ms->confna]->getlin);
 			}
 			/* Convert back */
-			for(x=0;x<ZT_CHUNKSIZE;x++)
-				rxb[x] = ZT_LIN2X(putlin[x], ms);
+			for(x=0;x<DAHDI_CHUNKSIZE;x++)
+				rxb[x] = DAHDI_LIN2X(putlin[x], ms);
 			break;
-		case ZT_CONF_MONITORBOTH:	/* Monitor a channel's tx and rx mode */
+		case DAHDI_CONF_MONITORBOTH:	/* Monitor a channel's tx and rx mode */
 			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO)) break;
+			if (!(ms->flags & DAHDI_FLAG_PSEUDO)) break;
 			/* Note: Technically, saturation should be done at 
 			   the end of the whole addition, but for performance
 			   reasons, we don't do that.  Besides, it only matters
@@ -6526,42 +6526,42 @@ static inline void __zt_process_putaudio_chunk(struct zt_chan *ss, unsigned char
 			ACSS(putlin, chans[ms->confna]->getlin);
 			ACSS(putlin, chans[ms->confna]->putlin);
 			/* Convert back */
-			for(x=0;x<ZT_CHUNKSIZE;x++)
-				rxb[x] = ZT_LIN2X(putlin[x], ms);
+			for(x=0;x<DAHDI_CHUNKSIZE;x++)
+				rxb[x] = DAHDI_LIN2X(putlin[x], ms);
 			break;
-		case ZT_CONF_MONITOR_RX_PREECHO:		/* Monitor a channel's rx mode */
+		case DAHDI_CONF_MONITOR_RX_PREECHO:		/* Monitor a channel's rx mode */
 			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO))
+			if (!(ms->flags & DAHDI_FLAG_PSEUDO))
 				break;
 
 			if (!chans[ms->confna]->readchunkpreec)
 				break;
 
 			/* Add monitored channel */
-			ACSS(putlin, chans[ms->confna]->flags & ZT_FLAG_PSEUDO ?
+			ACSS(putlin, chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO ?
 			     chans[ms->confna]->getlin : chans[ms->confna]->readchunkpreec);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				rxb[x] = ZT_LIN2X(putlin[x], ms);
+			for (x = 0; x < DAHDI_CHUNKSIZE; x++)
+				rxb[x] = DAHDI_LIN2X(putlin[x], ms);
 
 			break;
-		case ZT_CONF_MONITOR_TX_PREECHO:	/* Monitor a channel's tx mode */
+		case DAHDI_CONF_MONITOR_TX_PREECHO:	/* Monitor a channel's tx mode */
 			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO))
+			if (!(ms->flags & DAHDI_FLAG_PSEUDO))
 				break;
 
 			if (!chans[ms->confna]->readchunkpreec)
 				break;
 
 			/* Add monitored channel */
-			ACSS(putlin, chans[ms->confna]->flags & ZT_FLAG_PSEUDO ?
+			ACSS(putlin, chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO ?
 			     chans[ms->confna]->readchunkpreec : chans[ms->confna]->getlin);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				rxb[x] = ZT_LIN2X(putlin[x], ms);
+			for (x = 0; x < DAHDI_CHUNKSIZE; x++)
+				rxb[x] = DAHDI_LIN2X(putlin[x], ms);
 
 			break;
-		case ZT_CONF_MONITORBOTH_PREECHO:	/* Monitor a channel's tx and rx mode */
+		case DAHDI_CONF_MONITORBOTH_PREECHO:	/* Monitor a channel's tx and rx mode */
 			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO))
+			if (!(ms->flags & DAHDI_FLAG_PSEUDO))
 				break;
 
 			if (!chans[ms->confna]->readchunkpreec)
@@ -6573,93 +6573,93 @@ static inline void __zt_process_putaudio_chunk(struct zt_chan *ss, unsigned char
 			   when you're so loud you're clipping anyway */
 			ACSS(putlin, chans[ms->confna]->getlin);
 			ACSS(putlin, chans[ms->confna]->readchunkpreec);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				rxb[x] = ZT_LIN2X(putlin[x], ms);
+			for (x = 0; x < DAHDI_CHUNKSIZE; x++)
+				rxb[x] = DAHDI_LIN2X(putlin[x], ms);
 
 			break;
-		case ZT_CONF_REALANDPSEUDO:
+		case DAHDI_CONF_REALANDPSEUDO:
 			  /* do normal conf mode processing */
-			if (ms->confmode & ZT_CONF_TALKER) {
+			if (ms->confmode & DAHDI_CONF_TALKER) {
 				/* Store temp value */
-				memcpy(k, putlin, ZT_CHUNKSIZE * sizeof(short));
+				memcpy(k, putlin, DAHDI_CHUNKSIZE * sizeof(short));
 				/* Add conf value */
 				ACSS(k, conf_sums_next[ms->_confn]);
 				/*  get amount actually added */
-				memcpy(ms->conflast, k, ZT_CHUNKSIZE * sizeof(short));
+				memcpy(ms->conflast, k, DAHDI_CHUNKSIZE * sizeof(short));
 				SCSS(ms->conflast, conf_sums_next[ms->_confn]);
 				/* Really add in new value */
 				ACSS(conf_sums_next[ms->_confn], ms->conflast);
-			} else memset(ms->conflast, 0, ZT_CHUNKSIZE * sizeof(short));
+			} else memset(ms->conflast, 0, DAHDI_CHUNKSIZE * sizeof(short));
 			  /* do the pseudo-channel part processing */
-			memset(putlin, 0, ZT_CHUNKSIZE * sizeof(short));
-			if (ms->confmode & ZT_CONF_PSEUDO_LISTENER) {
+			memset(putlin, 0, DAHDI_CHUNKSIZE * sizeof(short));
+			if (ms->confmode & DAHDI_CONF_PSEUDO_LISTENER) {
 				/* Subtract out previous last sample written to conf */
 				SCSS(putlin, ms->conflast2);
 				/* Add in conference */
 				ACSS(putlin, conf_sums[ms->_confn]);
 			}
 			/* Convert back */
-			for(x=0;x<ZT_CHUNKSIZE;x++)
-				rxb[x] = ZT_LIN2X(putlin[x], ms);
+			for(x=0;x<DAHDI_CHUNKSIZE;x++)
+				rxb[x] = DAHDI_LIN2X(putlin[x], ms);
 			break;
-		case ZT_CONF_CONF:	/* Normal conference mode */
-			if (ms->flags & ZT_FLAG_PSEUDO) /* if a pseudo-channel */
+		case DAHDI_CONF_CONF:	/* Normal conference mode */
+			if (ms->flags & DAHDI_FLAG_PSEUDO) /* if a pseudo-channel */
 			   {
-				if (ms->confmode & ZT_CONF_LISTENER) {
+				if (ms->confmode & DAHDI_CONF_LISTENER) {
 					/* Subtract out last sample written to conf */
 					SCSS(putlin, ms->conflast);
 					/* Add in conference */
 					ACSS(putlin, conf_sums[ms->_confn]);
 				}
 				/* Convert back */
-				for(x=0;x<ZT_CHUNKSIZE;x++)
-					rxb[x] = ZT_LIN2X(putlin[x], ms);
-				memcpy(ss->putlin, putlin, ZT_CHUNKSIZE * sizeof(short));
+				for(x=0;x<DAHDI_CHUNKSIZE;x++)
+					rxb[x] = DAHDI_LIN2X(putlin[x], ms);
+				memcpy(ss->putlin, putlin, DAHDI_CHUNKSIZE * sizeof(short));
 				break;
 			   }
 			/* fall through */
-		case ZT_CONF_CONFANN:  /* Conference with announce */
-			if (ms->confmode & ZT_CONF_TALKER) {
+		case DAHDI_CONF_CONFANN:  /* Conference with announce */
+			if (ms->confmode & DAHDI_CONF_TALKER) {
 				/* Store temp value */
-				memcpy(k, putlin, ZT_CHUNKSIZE * sizeof(short));
+				memcpy(k, putlin, DAHDI_CHUNKSIZE * sizeof(short));
 				/* Add conf value */
 				ACSS(k, conf_sums_next[ms->_confn]);
 				/*  get amount actually added */
-				memcpy(ms->conflast, k, ZT_CHUNKSIZE * sizeof(short));
+				memcpy(ms->conflast, k, DAHDI_CHUNKSIZE * sizeof(short));
 				SCSS(ms->conflast, conf_sums_next[ms->_confn]);
 				/* Really add in new value */
 				ACSS(conf_sums_next[ms->_confn], ms->conflast);
 			} else 
-				memset(ms->conflast, 0, ZT_CHUNKSIZE * sizeof(short));
+				memset(ms->conflast, 0, DAHDI_CHUNKSIZE * sizeof(short));
 			  /* rxc unmodified */
 			break;
-		case ZT_CONF_CONFMON:
-		case ZT_CONF_CONFANNMON:
-			if (ms->confmode & ZT_CONF_TALKER) {
+		case DAHDI_CONF_CONFMON:
+		case DAHDI_CONF_CONFANNMON:
+			if (ms->confmode & DAHDI_CONF_TALKER) {
 				/* Store temp value */
-				memcpy(k, putlin, ZT_CHUNKSIZE * sizeof(short));
+				memcpy(k, putlin, DAHDI_CHUNKSIZE * sizeof(short));
 				/* Subtract last value */
 				SCSS(conf_sums[ms->_confn], ms->conflast);
 				/* Add conf value */
 				ACSS(k, conf_sums[ms->_confn]);
 				/*  get amount actually added */
-				memcpy(ms->conflast, k, ZT_CHUNKSIZE * sizeof(short));
+				memcpy(ms->conflast, k, DAHDI_CHUNKSIZE * sizeof(short));
 				SCSS(ms->conflast, conf_sums[ms->_confn]);
 				/* Really add in new value */
 				ACSS(conf_sums[ms->_confn], ms->conflast);
 			} else 
-				memset(ms->conflast, 0, ZT_CHUNKSIZE * sizeof(short));
-			for (x=0;x<ZT_CHUNKSIZE;x++)
-				rxb[x] = ZT_LIN2X((int)conf_sums_prev[ms->_confn][x], ms);
+				memset(ms->conflast, 0, DAHDI_CHUNKSIZE * sizeof(short));
+			for (x=0;x<DAHDI_CHUNKSIZE;x++)
+				rxb[x] = DAHDI_LIN2X((int)conf_sums_prev[ms->_confn][x], ms);
 			break;
-		case ZT_CONF_DIGITALMON:
+		case DAHDI_CONF_DIGITALMON:
 			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO)) break;
+			if (!(ms->flags & DAHDI_FLAG_PSEUDO)) break;
 			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_FLAG_PSEUDO) {
-				memcpy(rxb, chans[ms->confna]->getraw, ZT_CHUNKSIZE);
+			if (chans[ms->confna]->flags & DAHDI_FLAG_PSEUDO) {
+				memcpy(rxb, chans[ms->confna]->getraw, DAHDI_CHUNKSIZE);
 			} else {
-				memcpy(rxb, chans[ms->confna]->putraw, ZT_CHUNKSIZE);
+				memcpy(rxb, chans[ms->confna]->putraw, DAHDI_CHUNKSIZE);
 			}
 			break;			
 		}
@@ -6667,11 +6667,11 @@ static inline void __zt_process_putaudio_chunk(struct zt_chan *ss, unsigned char
 }
 
 /* HDLC (or other) receiver buffer functions for read side */
-static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int bytes)
+static inline void __putbuf_chunk(struct dahdi_chan *ss, unsigned char *rxb, int bytes)
 {
 	/* We transmit data from our master channel */
 	/* Called with ss->lock held */
-	struct zt_chan *ms = ss->master;
+	struct dahdi_chan *ms = ss->master;
 	/* Our receive buffer */
 	unsigned char *buf;
 #if defined(CONFIG_ZAPATA_NET)  || defined(CONFIG_ZAPATA_PPP)
@@ -6697,7 +6697,7 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 			left = ms->blocksize - ms->readidx[ms->inreadbuf];
 			if (left > bytes)
 				left = bytes;
-			if (ms->flags & ZT_FLAG_HDLC) {
+			if (ms->flags & DAHDI_FLAG_HDLC) {
 				for (x=0;x<left;x++) {
 					/* Handle HDLC deframing */
 					fasthdlc_rx_load_nocheck(&ms->rxhdlc, *(rxb++));
@@ -6709,8 +6709,8 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 					else if (res & RETURN_COMPLETE_FLAG) {
 						/* Only count this if it's a non-empty frame */
 						if (ms->readidx[ms->inreadbuf]) {
-							if ((ms->flags & ZT_FLAG_FCS) && (ms->infcs != PPP_GOODFCS)) {
-								abort = ZT_EVENT_BADFCS;
+							if ((ms->flags & DAHDI_FLAG_FCS) && (ms->infcs != PPP_GOODFCS)) {
+								abort = DAHDI_EVENT_BADFCS;
 							} else
 								eof=1;
 							break;
@@ -6721,7 +6721,7 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 						  "idle" instead of "flag" */
 						if (!ms->readidx[ms->inreadbuf])
 							continue;
-						abort = ZT_EVENT_ABORT;
+						abort = DAHDI_EVENT_ABORT;
 						break;
 					} else {
 						unsigned char rxc;
@@ -6732,7 +6732,7 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 						if (ms->readidx[ms->inreadbuf] >= ms->blocksize) {
 							if (!ss->span->alarms) 
 								printk(KERN_WARNING "HDLC Receiver overrun on channel %s (master=%s)\n", ss->name, ss->master->name);
-							abort=ZT_EVENT_OVERRUN;
+							abort=DAHDI_EVENT_OVERRUN;
 							/* Force the HDLC state back to frame-search mode */
 							ms->rxhdlc.state = 0;
 							ms->rxhdlc.bits = 0;
@@ -6749,9 +6749,9 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 				bytes -= left;
 				/* End of frame is decided by block size of 'N' */
 				eof = (ms->readidx[ms->inreadbuf] >= ms->blocksize);
-				if (eof && (ss->flags & ZT_FLAG_NOSTDTXRX)) {
+				if (eof && (ss->flags & DAHDI_FLAG_NOSTDTXRX)) {
 					eof = 0;
-					abort = ZT_EVENT_OVERRUN;
+					abort = DAHDI_EVENT_OVERRUN;
 				}
 			}
 			if (eof)  {
@@ -6763,7 +6763,7 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 				printk("EOF, len is %d\n", ms->readn[ms->inreadbuf]);
 #endif
 #if defined(CONFIG_ZAPATA_NET) || defined(CONFIG_ZAPATA_PPP)
-				if (ms->flags & (ZT_FLAG_NETDEV | ZT_FLAG_PPP)) {
+				if (ms->flags & (DAHDI_FLAG_NETDEV | DAHDI_FLAG_PPP)) {
 #ifdef CONFIG_ZAPATA_NET
 #endif /* CONFIG_ZAPATA_NET */
 					/* Our network receiver logic is MUCH
@@ -6782,7 +6782,7 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 							memcpy(skb->data, ms->readbuf[ms->inreadbuf], ms->readn[ms->inreadbuf]);
 							skb_put(skb, ms->readn[ms->inreadbuf]);
 #ifdef CONFIG_ZAPATA_NET
-							if (ms->flags & ZT_FLAG_NETDEV) {
+							if (ms->flags & DAHDI_FLAG_NETDEV) {
 #ifdef LINUX26
 								struct net_device_stats *stats = hdlc_stats(ms->hdlcnetdev->netdev);
 #else  /* LINUX26 */
@@ -6795,7 +6795,7 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 
 						} else {
 #ifdef CONFIG_ZAPATA_NET
-							if (ms->flags & ZT_FLAG_NETDEV) {
+							if (ms->flags & DAHDI_FLAG_NETDEV) {
 #ifdef LINUX26
 								struct net_device_stats *stats = hdlc_stats(ms->hdlcnetdev->netdev);
 #else  /* LINUX26 */
@@ -6805,8 +6805,8 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 							}
 #endif
 #ifdef CONFIG_ZAPATA_PPP
-							if (ms->flags & ZT_FLAG_PPP) {
-								abort = ZT_EVENT_OVERRUN;
+							if (ms->flags & DAHDI_FLAG_PPP) {
+								abort = DAHDI_EVENT_OVERRUN;
 							}
 #endif
 #if 1
@@ -6831,13 +6831,13 @@ static inline void __putbuf_chunk(struct zt_chan *ss, unsigned char *rxb, int by
 
 					int comparemessage;
 
-					if (ms->flags & ZT_FLAG_MTP2) {
+					if (ms->flags & DAHDI_FLAG_MTP2) {
 						comparemessage = (ms->inreadbuf - 1) & (ms->numbufs - 1);
 
 						res = memcmp(ms->readbuf[comparemessage], ms->readbuf[ms->inreadbuf], ms->readn[ms->inreadbuf]);
 					}
 
-					if ((ms->flags & ZT_FLAG_MTP2) && !res) {
+					if ((ms->flags & DAHDI_FLAG_MTP2) && !res) {
 						/* Our messages are the same, so discard -
 						 * 	Don't advance buffers, reset indexes and buffer sizes. */
 						ms->readn[ms->inreadbuf] = 0;
@@ -6876,7 +6876,7 @@ out in the later versions, and is put back now. */
 #endif
 							wake_up_interruptible(&ms->readbufq);
 							wake_up_interruptible(&ms->sel);
-							if (ms->iomask & ZT_IOMUX_READ)
+							if (ms->iomask & DAHDI_IOMUX_READ)
 								wake_up_interruptible(&ms->eventbufq);
 						}
 					}
@@ -6888,29 +6888,29 @@ out in the later versions, and is put back now. */
 				ms->infcs = PPP_INITFCS;
 
 #ifdef CONFIG_ZAPATA_NET
-				if (ms->flags & ZT_FLAG_NETDEV) {
+				if (ms->flags & DAHDI_FLAG_NETDEV) {
 #ifdef LINUX26
 					struct net_device_stats *stats = hdlc_stats(ms->hdlcnetdev->netdev);
 #else  /* LINUX26 */
 					struct net_device_stats *stats = &ms->hdlcnetdev->netdev.stats;
 #endif /* LINUX26 */
 					stats->rx_errors++;
-					if (abort == ZT_EVENT_OVERRUN)
+					if (abort == DAHDI_EVENT_OVERRUN)
 						stats->rx_over_errors++;
-					if (abort == ZT_EVENT_BADFCS)
+					if (abort == DAHDI_EVENT_BADFCS)
 						stats->rx_crc_errors++;
-					if (abort == ZT_EVENT_ABORT)
+					if (abort == DAHDI_EVENT_ABORT)
 						stats->rx_frame_errors++;
 				} else 
 #endif			
 #ifdef CONFIG_ZAPATA_PPP
-				if (ms->flags & ZT_FLAG_PPP) {
+				if (ms->flags & DAHDI_FLAG_PPP) {
 					ms->do_ppp_error = 1;
 					tasklet_schedule(&ms->ppp_calls);
 				} else
 #endif
 
-				if ((ms->flags & ZT_FLAG_OPEN) && !ss->span->alarms) 
+				if ((ms->flags & DAHDI_FLAG_OPEN) && !ss->span->alarms) 
 						/* Notify the receiver... */
 					__qevent(ss->master, abort);
 #if 0
@@ -6921,7 +6921,7 @@ out in the later versions, and is put back now. */
 		} else /* No place to receive -- drop on the floor */
 			break;
 #ifdef CONFIG_ZAPATA_NET
-		if (skb && (ms->flags & ZT_FLAG_NETDEV))
+		if (skb && (ms->flags & DAHDI_FLAG_NETDEV))
 #ifdef NEW_HDLC_INTERFACE
 		{
 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)
@@ -6942,7 +6942,7 @@ out in the later versions, and is put back now. */
 #endif
 #endif
 #ifdef CONFIG_ZAPATA_PPP
-		if (skb && (ms->flags & ZT_FLAG_PPP)) {
+		if (skb && (ms->flags & DAHDI_FLAG_PPP)) {
 			unsigned char *tmp;
 			tmp = skb->data;
 			skb_pull(skb, 2);
@@ -6961,28 +6961,28 @@ out in the later versions, and is put back now. */
 	}
 }
 
-static inline void __zt_putbuf_chunk(struct zt_chan *ss, unsigned char *rxb)
+static inline void __dahdi_putbuf_chunk(struct dahdi_chan *ss, unsigned char *rxb)
 {
-	__putbuf_chunk(ss, rxb, ZT_CHUNKSIZE);
+	__putbuf_chunk(ss, rxb, DAHDI_CHUNKSIZE);
 }
 
-static void __zt_hdlc_abort(struct zt_chan *ss, int event)
+static void __dahdi_hdlc_abort(struct dahdi_chan *ss, int event)
 {
 	if (ss->inreadbuf >= 0)
 		ss->readidx[ss->inreadbuf] = 0;
-	if ((ss->flags & ZT_FLAG_OPEN) && !ss->span->alarms)
+	if ((ss->flags & DAHDI_FLAG_OPEN) && !ss->span->alarms)
 		__qevent(ss->master, event);
 }
 
-extern void zt_hdlc_abort(struct zt_chan *ss, int event)
+extern void dahdi_hdlc_abort(struct dahdi_chan *ss, int event)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&ss->lock, flags);
-	__zt_hdlc_abort(ss, event);
+	__dahdi_hdlc_abort(ss, event);
 	spin_unlock_irqrestore(&ss->lock, flags);
 }
 
-extern void zt_hdlc_putbuf(struct zt_chan *ss, unsigned char *rxb, int bytes)
+extern void dahdi_hdlc_putbuf(struct dahdi_chan *ss, unsigned char *rxb, int bytes)
 {
 	unsigned long flags;
 	int res;
@@ -7011,13 +7011,13 @@ extern void zt_hdlc_putbuf(struct zt_chan *ss, unsigned char *rxb, int bytes)
 #ifdef CONFIG_ZAPATA_DEBUG
 		printk("HDLC frame isn't fit into buffer space\n");
 #endif
-		__zt_hdlc_abort(ss, ZT_EVENT_OVERRUN);
+		__dahdi_hdlc_abort(ss, DAHDI_EVENT_OVERRUN);
 	}
 	res = left;
 	spin_unlock_irqrestore(&ss->lock, flags);
 }
 
-extern void zt_hdlc_finish(struct zt_chan *ss)
+extern void dahdi_hdlc_finish(struct dahdi_chan *ss)
 {
 	int oldreadbuf;
 	unsigned long flags;
@@ -7056,14 +7056,14 @@ extern void zt_hdlc_finish(struct zt_chan *ss)
 	if (!ss->rxdisable) {
 		wake_up_interruptible(&ss->readbufq);
 		wake_up_interruptible(&ss->sel);
-		if (ss->iomask & ZT_IOMUX_READ)
+		if (ss->iomask & DAHDI_IOMUX_READ)
 			wake_up_interruptible(&ss->eventbufq);
 	}
 	spin_unlock_irqrestore(&ss->lock, flags);
 }
 
 /* Returns 1 if EOF, 0 if data is still in frame, -1 if EOF and no buffers left */
-extern int zt_hdlc_getbuf(struct zt_chan *ss, unsigned char *bufptr, unsigned int *size)
+extern int dahdi_hdlc_getbuf(struct dahdi_chan *ss, unsigned char *bufptr, unsigned int *size)
 {
 	unsigned char *buf;
 	unsigned long flags;
@@ -7094,10 +7094,10 @@ extern int zt_hdlc_getbuf(struct zt_chan *ss, unsigned char *bufptr, unsigned in
 			ss->outwritebuf = (ss->outwritebuf + 1) % ss->numbufs;
 			if (ss->outwritebuf == ss->inwritebuf) {
 				ss->outwritebuf = -1;
-				if (ss->iomask & (ZT_IOMUX_WRITE | ZT_IOMUX_WRITEEMPTY))
+				if (ss->iomask & (DAHDI_IOMUX_WRITE | DAHDI_IOMUX_WRITEEMPTY))
 					wake_up_interruptible(&ss->eventbufq);
 				/* If we're only supposed to start when full, disable the transmitter */
-				if (ss->txbufpolicy == ZT_POLICY_WHEN_FULL)
+				if (ss->txbufpolicy == DAHDI_POLICY_WHEN_FULL)
 					ss->txdisable = 1;
 				res = -1;
 			}
@@ -7105,10 +7105,10 @@ extern int zt_hdlc_getbuf(struct zt_chan *ss, unsigned char *bufptr, unsigned in
 			if (ss->inwritebuf < 0)
 				ss->inwritebuf = oldbuf;
 
-			if (!(ss->flags & (ZT_FLAG_NETDEV | ZT_FLAG_PPP))) {
+			if (!(ss->flags & (DAHDI_FLAG_NETDEV | DAHDI_FLAG_PPP))) {
 				wake_up_interruptible(&ss->writebufq);
 				wake_up_interruptible(&ss->sel);
-				if ((ss->iomask & ZT_IOMUX_WRITE) && (res >= 0))
+				if ((ss->iomask & DAHDI_IOMUX_WRITE) && (res >= 0))
 					wake_up_interruptible(&ss->eventbufq);
 			}
 		}
@@ -7125,12 +7125,12 @@ extern int zt_hdlc_getbuf(struct zt_chan *ss, unsigned char *bufptr, unsigned in
 static void process_timers(void)
 {
 	unsigned long flags;
-	struct zt_timer *cur;
+	struct dahdi_timer *cur;
 	spin_lock_irqsave(&zaptimerlock, flags);
 	cur = zaptimers;
 	while(cur) {
 		if (cur->ms) {
-			cur->pos -= ZT_CHUNKSIZE;
+			cur->pos -= DAHDI_CHUNKSIZE;
 			if (cur->pos <= 0) {
 				cur->tripped++;
 				cur->pos = cur->ms;
@@ -7142,9 +7142,9 @@ static void process_timers(void)
 	spin_unlock_irqrestore(&zaptimerlock, flags);
 }
 
-static unsigned int zt_timer_poll(struct file *file, struct poll_table_struct *wait_table)
+static unsigned int dahdi_timer_poll(struct file *file, struct poll_table_struct *wait_table)
 {
-	struct zt_timer *timer = file->private_data;
+	struct dahdi_timer *timer = file->private_data;
 	unsigned long flags;
 	int ret = 0;
 	if (timer) {
@@ -7160,10 +7160,10 @@ static unsigned int zt_timer_poll(struct file *file, struct poll_table_struct *w
 
 /* device poll routine */
 static unsigned int
-zt_chan_poll(struct file *file, struct poll_table_struct *wait_table, int unit)
+dahdi_chan_poll(struct file *file, struct poll_table_struct *wait_table, int unit)
 {   
 	
-	struct zt_chan *chan = chans[unit];
+	struct dahdi_chan *chan = chans[unit];
 	int	ret;
 	unsigned long flags;
 
@@ -7190,33 +7190,33 @@ zt_chan_poll(struct file *file, struct poll_table_struct *wait_table, int unit)
 	return(ret);  /* return what we found */
 }
 
-static int zt_mmap(struct file *file, struct vm_area_struct *vm)
+static int dahdi_mmap(struct file *file, struct vm_area_struct *vm)
 {
 	int unit = UNIT(file);
 	if (unit == 250)
-		return zt_transcode_fops->mmap(file, vm);
+		return dahdi_transcode_fops->mmap(file, vm);
 	return -ENOSYS;
 }
 
-static unsigned int zt_poll(struct file *file, struct poll_table_struct *wait_table)
+static unsigned int dahdi_poll(struct file *file, struct poll_table_struct *wait_table)
 {
 	int unit = UNIT(file);
-	struct zt_chan *chan;
+	struct dahdi_chan *chan;
 
 	if (!unit)
 		return -EINVAL;
 
 	if (unit == 250)
-		return zt_transcode_fops->poll(file, wait_table);
+		return dahdi_transcode_fops->poll(file, wait_table);
 
 	if (unit == 253)
-		return zt_timer_poll(file, wait_table);
+		return dahdi_timer_poll(file, wait_table);
 		
 	if (unit == 254) {
 		chan = file->private_data;
 		if (!chan)
 			return -EINVAL;
-		return zt_chan_poll(file, wait_table,chan->channo);
+		return dahdi_chan_poll(file, wait_table,chan->channo);
 	}
 	if (unit == 255) {
 		chan = file->private_data;
@@ -7224,14 +7224,14 @@ static unsigned int zt_poll(struct file *file, struct poll_table_struct *wait_ta
 			printk("No pseudo channel structure to read?\n");
 			return -EINVAL;
 		}
-		return zt_chan_poll(file, wait_table, chan->channo);
+		return dahdi_chan_poll(file, wait_table, chan->channo);
 	}
-	return zt_chan_poll(file, wait_table, unit);
+	return dahdi_chan_poll(file, wait_table, unit);
 }
 
-static void __zt_transmit_chunk(struct zt_chan *chan, unsigned char *buf)
+static void __dahdi_transmit_chunk(struct dahdi_chan *chan, unsigned char *buf)
 {
-	unsigned char silly[ZT_CHUNKSIZE];
+	unsigned char silly[DAHDI_CHUNKSIZE];
 	/* Called with chan->lock locked */
 #ifdef	OPTIMIZE_CHANMUTE
 	if(likely(chan->chanmute))
@@ -7239,20 +7239,20 @@ static void __zt_transmit_chunk(struct zt_chan *chan, unsigned char *buf)
 #endif
 	if (!buf)
 		buf = silly;
-	__zt_getbuf_chunk(chan, buf);
+	__dahdi_getbuf_chunk(chan, buf);
 
-	if ((chan->flags & ZT_FLAG_AUDIO) || (chan->confmode)) {
+	if ((chan->flags & DAHDI_FLAG_AUDIO) || (chan->confmode)) {
 #ifdef CONFIG_ZAPTEL_MMX
-		zt_kernel_fpu_begin();
+		dahdi_kernel_fpu_begin();
 #endif
-		__zt_process_getaudio_chunk(chan, buf);
+		__dahdi_process_getaudio_chunk(chan, buf);
 #ifdef CONFIG_ZAPTEL_MMX
 		kernel_fpu_end();
 #endif
 	}
 }
 
-static inline void __zt_real_transmit(struct zt_chan *chan)
+static inline void __dahdi_real_transmit(struct dahdi_chan *chan)
 {
 	/* Called with chan->lock held */
 #ifdef	OPTIMIZE_CHANMUTE
@@ -7261,15 +7261,15 @@ static inline void __zt_real_transmit(struct zt_chan *chan)
 #endif
 	if (chan->confmode) {
 		/* Pull queued data off the conference */
-		__buf_pull(&chan->confout, chan->writechunk, chan, "zt_real_transmit");
+		__buf_pull(&chan->confout, chan->writechunk, chan, "dahdi_real_transmit");
 	} else {
-		__zt_transmit_chunk(chan, chan->writechunk);
+		__dahdi_transmit_chunk(chan, chan->writechunk);
 	}
 }
 
-static void __zt_getempty(struct zt_chan *ms, unsigned char *buf)
+static void __dahdi_getempty(struct dahdi_chan *ms, unsigned char *buf)
 {
-	int bytes = ZT_CHUNKSIZE;
+	int bytes = DAHDI_CHUNKSIZE;
 	int left;
 	unsigned char *txb = buf;
 	int x;
@@ -7284,13 +7284,13 @@ static void __zt_getempty(struct zt_chan *ms, unsigned char *buf)
 				left = bytes;
 			for (x=0;x<left;x++) {
 				/* Pick our default value from the next sample of the current tone */
-				getlin = zt_tone_nextsample(&ms->ts, ms->curtone);
-				*(txb++) = ZT_LIN2X(getlin, ms);
+				getlin = dahdi_tone_nextsample(&ms->ts, ms->curtone);
+				*(txb++) = DAHDI_LIN2X(getlin, ms);
 			}
 			ms->tonep+=left;
 			bytes -= left;
 			if (ms->tonep >= ms->curtone->tonesamples) {
-				struct zt_tone *last;
+				struct dahdi_tone *last;
 				/* Go to the next sample of the tone */
 				ms->tonep = 0;
 				last = ms->curtone;
@@ -7301,44 +7301,44 @@ static void __zt_getempty(struct zt_chan *ms, unsigned char *buf)
 						__do_dtmf(ms);
 				} else {
 					if (last != ms->curtone)
-						zt_init_tone_state(&ms->ts, ms->curtone);
+						dahdi_init_tone_state(&ms->ts, ms->curtone);
 				}
 			}
 		} else {
 			/* Use silence */
-			memset(txb, ZT_LIN2X(0, ms), bytes);
+			memset(txb, DAHDI_LIN2X(0, ms), bytes);
 			bytes = 0;
 		}
 	}
 		
 }
 
-static void __zt_receive_chunk(struct zt_chan *chan, unsigned char *buf)
+static void __dahdi_receive_chunk(struct dahdi_chan *chan, unsigned char *buf)
 {
 	/* Receive chunk of audio -- called with chan->lock held */
-	unsigned char waste[ZT_CHUNKSIZE];
+	unsigned char waste[DAHDI_CHUNKSIZE];
 
 #ifdef	OPTIMIZE_CHANMUTE
 	if(likely(chan->chanmute))
 		return;
 #endif
 	if (!buf) {
-		memset(waste, ZT_LIN2X(0, chan), sizeof(waste));
+		memset(waste, DAHDI_LIN2X(0, chan), sizeof(waste));
 		buf = waste;
 	}
-	if ((chan->flags & ZT_FLAG_AUDIO) || (chan->confmode)) {
+	if ((chan->flags & DAHDI_FLAG_AUDIO) || (chan->confmode)) {
 #ifdef CONFIG_ZAPTEL_MMX                         
-		zt_kernel_fpu_begin();
+		dahdi_kernel_fpu_begin();
 #endif
-		__zt_process_putaudio_chunk(chan, buf);
+		__dahdi_process_putaudio_chunk(chan, buf);
 #ifdef CONFIG_ZAPTEL_MMX
 		kernel_fpu_end();
 #endif
 	}
-	__zt_putbuf_chunk(chan, buf);
+	__dahdi_putbuf_chunk(chan, buf);
 }
 
-static inline void __zt_real_receive(struct zt_chan *chan)
+static inline void __dahdi_real_receive(struct dahdi_chan *chan)
 {
 	/* Called with chan->lock held */
 #ifdef	OPTIMIZE_CHANMUTE
@@ -7347,13 +7347,13 @@ static inline void __zt_real_receive(struct zt_chan *chan)
 #endif
 	if (chan->confmode) {
 		/* Load into queue if we have space */
-		__buf_push(&chan->confin, chan->readchunk, "zt_real_receive");
+		__buf_push(&chan->confin, chan->readchunk, "dahdi_real_receive");
 	} else {
-		__zt_receive_chunk(chan, chan->readchunk);
+		__dahdi_receive_chunk(chan, chan->readchunk);
 	}
 }
 
-int zt_transmit(struct zt_span *span)
+int dahdi_transmit(struct dahdi_span *span)
 {
 	int x,y,z;
 	unsigned long flags;
@@ -7361,31 +7361,31 @@ int zt_transmit(struct zt_span *span)
 #if 1
 	for (x=0;x<span->channels;x++) {
 		spin_lock_irqsave(&span->chans[x].lock, flags);
-		if (span->chans[x].flags & ZT_FLAG_NOSTDTXRX) {
+		if (span->chans[x].flags & DAHDI_FLAG_NOSTDTXRX) {
 			spin_unlock_irqrestore(&span->chans[x].lock, flags);
 			continue;
 		}
 		if (&span->chans[x] == span->chans[x].master) {
 			if (span->chans[x].otimer) {
-				span->chans[x].otimer -= ZT_CHUNKSIZE;
+				span->chans[x].otimer -= DAHDI_CHUNKSIZE;
 				if (span->chans[x].otimer <= 0) {
 					__rbs_otimer_expire(&span->chans[x]);
 				}
 			}
-			if (span->chans[x].flags & ZT_FLAG_AUDIO) {
-				__zt_real_transmit(&span->chans[x]);
+			if (span->chans[x].flags & DAHDI_FLAG_AUDIO) {
+				__dahdi_real_transmit(&span->chans[x]);
 			} else {
 				if (span->chans[x].nextslave) {
-					u_char data[ZT_CHUNKSIZE];
-					int pos=ZT_CHUNKSIZE;
+					u_char data[DAHDI_CHUNKSIZE];
+					int pos=DAHDI_CHUNKSIZE;
 					/* Process master/slaves one way */
-					for (y=0;y<ZT_CHUNKSIZE;y++) {
+					for (y=0;y<DAHDI_CHUNKSIZE;y++) {
 						/* Process slaves for this byte too */
 						z = x;
 						do {
-							if (pos==ZT_CHUNKSIZE) {
+							if (pos==DAHDI_CHUNKSIZE) {
 								/* Get next chunk */
-								__zt_transmit_chunk(&span->chans[x], data);
+								__dahdi_transmit_chunk(&span->chans[x], data);
 								pos = 0;
 							}
 							span->chans[z].writechunk[y] = data[pos++]; 
@@ -7394,10 +7394,10 @@ int zt_transmit(struct zt_span *span)
 					}
 				} else {
 					/* Process independents elsewise */
-					__zt_real_transmit(&span->chans[x]);
+					__dahdi_real_transmit(&span->chans[x]);
 				}
 			}
-			if (span->chans[x].sig == ZT_SIG_DACS_RBS) {
+			if (span->chans[x].sig == DAHDI_SIG_DACS_RBS) {
 				if (chans[span->chans[x].confna]) {
 				    	/* Just set bits for our destination */
 					if (span->chans[x].txsig != chans[span->chans[x].confna]->rxsig) {
@@ -7411,11 +7411,11 @@ int zt_transmit(struct zt_span *span)
 		spin_unlock_irqrestore(&span->chans[x].lock, flags);
 	}
 	if (span->mainttimer) {
-		span->mainttimer -= ZT_CHUNKSIZE;
+		span->mainttimer -= DAHDI_CHUNKSIZE;
 		if (span->mainttimer <= 0) {
 			span->mainttimer = 0;
 			if (span->maint)
-				span->maint(span, ZT_MAINT_LOOPSTOP);
+				span->maint(span, DAHDI_MAINT_LOOPSTOP);
 			span->maintstat = 0;
 			wake_up_interruptible(&span->maintq);
 		}
@@ -7424,7 +7424,7 @@ int zt_transmit(struct zt_span *span)
 	return 0;
 }
 
-int zt_receive(struct zt_span *span)
+int dahdi_receive(struct dahdi_span *span)
 {
 	int x,y,z;
 	unsigned long flags, flagso;
@@ -7438,16 +7438,16 @@ int zt_receive(struct zt_span *span)
 			spin_lock_irqsave(&span->chans[x].lock, flags);
 			if (span->chans[x].nextslave) {
 				/* Must process each slave at the same time */
-				u_char data[ZT_CHUNKSIZE];
+				u_char data[DAHDI_CHUNKSIZE];
 				int pos = 0;
-				for (y=0;y<ZT_CHUNKSIZE;y++) {
+				for (y=0;y<DAHDI_CHUNKSIZE;y++) {
 					/* Put all its slaves, too */
 					z = x;
 					do {
 						data[pos++] = span->chans[z].readchunk[y];
-						if (pos == ZT_CHUNKSIZE) {
-							if(!(span->chans[x].flags & ZT_FLAG_NOSTDTXRX))
-								__zt_receive_chunk(&span->chans[x], data);
+						if (pos == DAHDI_CHUNKSIZE) {
+							if(!(span->chans[x].flags & DAHDI_FLAG_NOSTDTXRX))
+								__dahdi_receive_chunk(&span->chans[x], data);
 							pos = 0;
 						}
 						z=span->chans[z].nextslave;
@@ -7455,25 +7455,25 @@ int zt_receive(struct zt_span *span)
 				}
 			} else {
 				/* Process a normal channel */
-				if (!(span->chans[x].flags & ZT_FLAG_NOSTDTXRX))
-					__zt_real_receive(&span->chans[x]);
+				if (!(span->chans[x].flags & DAHDI_FLAG_NOSTDTXRX))
+					__dahdi_real_receive(&span->chans[x]);
 			}
 			if (span->chans[x].itimer) {
-				span->chans[x].itimer -= ZT_CHUNKSIZE;
+				span->chans[x].itimer -= DAHDI_CHUNKSIZE;
 				if (span->chans[x].itimer <= 0) {
 					rbs_itimer_expire(&span->chans[x]);
 				}
 			}
 			if (span->chans[x].ringdebtimer)
 				span->chans[x].ringdebtimer--;
-			if (span->chans[x].sig & __ZT_SIG_FXS) {
-				if (span->chans[x].rxhooksig == ZT_RXSIG_RING)
-					span->chans[x].ringtrailer = ZT_RINGTRAILER;
+			if (span->chans[x].sig & __DAHDI_SIG_FXS) {
+				if (span->chans[x].rxhooksig == DAHDI_RXSIG_RING)
+					span->chans[x].ringtrailer = DAHDI_RINGTRAILER;
 				else if (span->chans[x].ringtrailer) {
-					span->chans[x].ringtrailer-= ZT_CHUNKSIZE;
+					span->chans[x].ringtrailer-= DAHDI_CHUNKSIZE;
 					/* See if RING trailer is expired */
 					if (!span->chans[x].ringtrailer && !span->chans[x].ringdebtimer) 
-						__qevent(&span->chans[x],ZT_EVENT_RINGOFFHOOK);
+						__qevent(&span->chans[x],DAHDI_EVENT_RINGOFFHOOK);
 				}
 			}
 			if (span->chans[x].pulsetimer)
@@ -7489,13 +7489,13 @@ int zt_receive(struct zt_span *span)
 						    span->chans[x].pulsecount,
 							span->chans[x].name);
 						} else if (span->chans[x].pulsecount > 11) {
-							__qevent(&span->chans[x], ZT_EVENT_PULSEDIGIT | '#');
+							__qevent(&span->chans[x], DAHDI_EVENT_PULSEDIGIT | '#');
 						} else if (span->chans[x].pulsecount > 10) {
-							__qevent(&span->chans[x], ZT_EVENT_PULSEDIGIT | '*');
+							__qevent(&span->chans[x], DAHDI_EVENT_PULSEDIGIT | '*');
 						} else if (span->chans[x].pulsecount > 9) {
-							__qevent(&span->chans[x], ZT_EVENT_PULSEDIGIT | '0');
+							__qevent(&span->chans[x], DAHDI_EVENT_PULSEDIGIT | '0');
 						} else {
-							__qevent(&span->chans[x], ZT_EVENT_PULSEDIGIT | ('0' + 
+							__qevent(&span->chans[x], DAHDI_EVENT_PULSEDIGIT | ('0' + 
 								span->chans[x].pulsecount));
 						}
 						span->chans[x].pulsecount = 0;
@@ -7514,14 +7514,14 @@ int zt_receive(struct zt_span *span)
 		process_timers();
 		/* If we have dynamic stuff, call the ioctl with 0,0 parameters to
 		   make it run */
-		if (zt_dynamic_ioctl)
-			zt_dynamic_ioctl(0,0);
+		if (dahdi_dynamic_ioctl)
+			dahdi_dynamic_ioctl(0,0);
 		for (x=1;x<maxchans;x++) {
-			if (chans[x] && chans[x]->confmode && !(chans[x]->flags & ZT_FLAG_PSEUDO)) {
+			if (chans[x] && chans[x]->confmode && !(chans[x]->flags & DAHDI_FLAG_PSEUDO)) {
 				u_char *data;
 				spin_lock_irqsave(&chans[x]->lock, flags);
 				data = __buf_peek(&chans[x]->confin);
-				__zt_receive_chunk(chans[x], data);
+				__dahdi_receive_chunk(chans[x], data);
 				if (data)
 					__buf_pull(&chans[x]->confin, NULL,chans[x], "confreceive");
 				spin_unlock_irqrestore(&chans[x]->lock, flags);
@@ -7531,15 +7531,15 @@ int zt_receive(struct zt_span *span)
 		rotate_sums();
 		/* do all the pseudo and/or conferenced channel receives (getbuf's) */
 		for (x=1;x<maxchans;x++) {
-			if (chans[x] && (chans[x]->flags & ZT_FLAG_PSEUDO)) {
+			if (chans[x] && (chans[x]->flags & DAHDI_FLAG_PSEUDO)) {
 				spin_lock_irqsave(&chans[x]->lock, flags);
-				__zt_transmit_chunk(chans[x], NULL);
+				__dahdi_transmit_chunk(chans[x], NULL);
 				spin_unlock_irqrestore(&chans[x]->lock, flags);
 			}
 		}
 		if (maxlinks) {
 #ifdef CONFIG_ZAPTEL_MMX
-			zt_kernel_fpu_begin();
+			dahdi_kernel_fpu_begin();
 #endif			
 			  /* process all the conf links */
 			for(x = 1; x <= maxlinks; x++) {
@@ -7555,20 +7555,20 @@ int zt_receive(struct zt_span *span)
 		}
 		/* do all the pseudo/conferenced channel transmits (putbuf's) */
 		for (x=1;x<maxchans;x++) {
-			if (chans[x] && (chans[x]->flags & ZT_FLAG_PSEUDO)) {
-				unsigned char tmp[ZT_CHUNKSIZE];
+			if (chans[x] && (chans[x]->flags & DAHDI_FLAG_PSEUDO)) {
+				unsigned char tmp[DAHDI_CHUNKSIZE];
 				spin_lock_irqsave(&chans[x]->lock, flags);
-				__zt_getempty(chans[x], tmp);
-				__zt_receive_chunk(chans[x], tmp);
+				__dahdi_getempty(chans[x], tmp);
+				__dahdi_receive_chunk(chans[x], tmp);
 				spin_unlock_irqrestore(&chans[x]->lock, flags);
 			}
 		}
 		for (x=1;x<maxchans;x++) {
-			if (chans[x] && chans[x]->confmode && !(chans[x]->flags & ZT_FLAG_PSEUDO)) {
+			if (chans[x] && chans[x]->confmode && !(chans[x]->flags & DAHDI_FLAG_PSEUDO)) {
 				u_char *data;
 				spin_lock_irqsave(&chans[x]->lock, flags);
 				data = __buf_pushpeek(&chans[x]->confout);
-				__zt_transmit_chunk(chans[x], data);
+				__dahdi_transmit_chunk(chans[x], data);
 				if (data)
 					__buf_push(&chans[x]->confout, NULL, "conftransmit");
 				spin_unlock_irqrestore(&chans[x]->lock, flags);
@@ -7576,7 +7576,7 @@ int zt_receive(struct zt_span *span)
 		}
 #ifdef	ZAPTEL_SYNC_TICK
 		for (x=0;x<maxspans;x++) {
-			struct zt_span	*s = spans[x];
+			struct dahdi_span	*s = spans[x];
 
 			if (s && s->sync_tick)
 				s->sync_tick(s, s == master);
@@ -7605,16 +7605,16 @@ MODULE_PARM(debug, "i");
 MODULE_PARM(deftaps, "i");
 #endif
 
-static struct file_operations zt_fops = {
+static struct file_operations dahdi_fops = {
 	owner: THIS_MODULE,
 	llseek: NULL,
-	open: zt_open,
-	release: zt_release,
-	ioctl: zt_ioctl,
-	read: zt_read,
-	write: zt_write,
-	poll: zt_poll,
-	mmap: zt_mmap,
+	open: dahdi_open,
+	release: dahdi_release,
+	ioctl: dahdi_ioctl,
+	read: dahdi_read,
+	write: dahdi_write,
+	poll: dahdi_poll,
+	mmap: dahdi_mmap,
 	flush: NULL,
 	fsync: NULL,
 	fasync: NULL,
@@ -7631,27 +7631,27 @@ static void watchdog_check(unsigned long ignored)
 	
 	local_irq_save(flags);
 	for (x=0;x<maxspans;x++) {
-		if (spans[x] && (spans[x]->flags & ZT_FLAG_RUNNING)) {
-			if (spans[x]->watchcounter == ZT_WATCHDOG_INIT) {
+		if (spans[x] && (spans[x]->flags & DAHDI_FLAG_RUNNING)) {
+			if (spans[x]->watchcounter == DAHDI_WATCHDOG_INIT) {
 				/* Whoops, dead card */
-				if ((spans[x]->watchstate == ZT_WATCHSTATE_OK) || 
-					(spans[x]->watchstate == ZT_WATCHSTATE_UNKNOWN)) {
-					spans[x]->watchstate = ZT_WATCHSTATE_RECOVERING;
+				if ((spans[x]->watchstate == DAHDI_WATCHSTATE_OK) || 
+					(spans[x]->watchstate == DAHDI_WATCHSTATE_UNKNOWN)) {
+					spans[x]->watchstate = DAHDI_WATCHSTATE_RECOVERING;
 					if (spans[x]->watchdog) {
 						printk("Kicking span %s\n", spans[x]->name);
-						spans[x]->watchdog(spans[x], ZT_WATCHDOG_NOINTS);
+						spans[x]->watchdog(spans[x], DAHDI_WATCHDOG_NOINTS);
 					} else {
 						printk("Span %s is dead with no revival\n", spans[x]->name);
-						spans[x]->watchstate = ZT_WATCHSTATE_FAILED;
+						spans[x]->watchstate = DAHDI_WATCHSTATE_FAILED;
 					}
 				}
 			} else {
-				if ((spans[x]->watchstate != ZT_WATCHSTATE_OK) &&
-					(spans[x]->watchstate != ZT_WATCHSTATE_UNKNOWN))
+				if ((spans[x]->watchstate != DAHDI_WATCHSTATE_OK) &&
+					(spans[x]->watchstate != DAHDI_WATCHSTATE_UNKNOWN))
 						printk("Span %s is alive!\n", spans[x]->name);
-				spans[x]->watchstate = ZT_WATCHSTATE_OK;
+				spans[x]->watchstate = DAHDI_WATCHSTATE_OK;
 			}
-			spans[x]->watchcounter = ZT_WATCHDOG_INIT;
+			spans[x]->watchcounter = DAHDI_WATCHDOG_INIT;
 		}
 	}
 	local_irq_restore(flags);
@@ -7680,7 +7680,7 @@ static void __exit watchdog_cleanup(void)
 
 #endif
 
-int zt_register_chardev(struct zt_chardev *dev)
+int dahdi_register_chardev(struct dahdi_chardev *dev)
 {
 #ifdef CONFIG_DEVFS_FS
 	umode_t mode = S_IFCHR|S_IRUGO|S_IWUGO;
@@ -7691,20 +7691,20 @@ int zt_register_chardev(struct zt_chardev *dev)
 
 	strcpy(udevname, "zap");
 	strcat(udevname, dev->name);
-	CLASS_DEV_CREATE(zap_class, MKDEV(ZT_MAJOR, dev->minor), NULL, udevname);
+	CLASS_DEV_CREATE(zap_class, MKDEV(DAHDI_MAJOR, dev->minor), NULL, udevname);
 #endif /* CONFIG_ZAP_UDEV */
 	
 #ifdef CONFIG_DEVFS_FS
-	dev->devfs_handle = devfs_register(zaptel_devfs_dir, dev->name, DEVFS_FL_DEFAULT, ZT_MAJOR, dev->minor, mode, &zt_fops, NULL);
+	dev->devfs_handle = devfs_register(zaptel_devfs_dir, dev->name, DEVFS_FL_DEFAULT, DAHDI_MAJOR, dev->minor, mode, &dahdi_fops, NULL);
 #endif /* CONFIG_DEVFS_FS */
 
 	return 0;
 }
 
-int zt_unregister_chardev(struct zt_chardev *dev)
+int dahdi_unregister_chardev(struct dahdi_chardev *dev)
 {
 #ifdef CONFIG_ZAP_UDEV
-	class_device_destroy(zap_class, MKDEV(ZT_MAJOR, dev->minor));
+	class_device_destroy(zap_class, MKDEV(DAHDI_MAJOR, dev->minor));
 #endif /* CONFIG_ZAP_UDEV */
 
 #ifdef CONFIG_DEVFS_FS
@@ -7714,7 +7714,7 @@ int zt_unregister_chardev(struct zt_chardev *dev)
 	return 0;
 }
 
-static int __init zt_init(void) {
+static int __init dahdi_init(void) {
 	int res = 0;
 
 #ifdef CONFIG_PROC_FS
@@ -7723,35 +7723,35 @@ static int __init zt_init(void) {
 
 #ifdef CONFIG_ZAP_UDEV /* udev support functions */
 	zap_class = class_create(THIS_MODULE, "zaptel");
-	CLASS_DEV_CREATE(zap_class, MKDEV(ZT_MAJOR, 253), NULL, "zaptimer");
-	CLASS_DEV_CREATE(zap_class, MKDEV(ZT_MAJOR, 254), NULL, "zapchannel");
-	CLASS_DEV_CREATE(zap_class, MKDEV(ZT_MAJOR, 255), NULL, "zappseudo");
-	CLASS_DEV_CREATE(zap_class, MKDEV(ZT_MAJOR, 0), NULL, "zapctl");
+	CLASS_DEV_CREATE(zap_class, MKDEV(DAHDI_MAJOR, 253), NULL, "zaptimer");
+	CLASS_DEV_CREATE(zap_class, MKDEV(DAHDI_MAJOR, 254), NULL, "zapchannel");
+	CLASS_DEV_CREATE(zap_class, MKDEV(DAHDI_MAJOR, 255), NULL, "zappseudo");
+	CLASS_DEV_CREATE(zap_class, MKDEV(DAHDI_MAJOR, 0), NULL, "zapctl");
 #endif /* CONFIG_ZAP_UDEV */
 
 #ifdef CONFIG_DEVFS_FS
 	{
 		umode_t mode = S_IFCHR|S_IRUGO|S_IWUGO;
 
-		devfs_register_chrdev(ZT_MAJOR, "zaptel", &zt_fops);
+		devfs_register_chrdev(DAHDI_MAJOR, "zaptel", &dahdi_fops);
 		if (!(zaptel_devfs_dir = devfs_mk_dir(NULL, "zap", NULL)))
 			return -EBUSY; /* This would be bad */
-		timer = devfs_register(zaptel_devfs_dir, "timer", DEVFS_FL_DEFAULT, ZT_MAJOR, 253, mode, &zt_fops, NULL);
-		channel = devfs_register(zaptel_devfs_dir, "channel", DEVFS_FL_DEFAULT, ZT_MAJOR, 254, mode, &zt_fops, NULL);
-		pseudo = devfs_register(zaptel_devfs_dir, "pseudo", DEVFS_FL_DEFAULT, ZT_MAJOR, 255, mode, &zt_fops, NULL);
-		ctl = devfs_register(zaptel_devfs_dir, "ctl", DEVFS_FL_DEFAULT, ZT_MAJOR, 0, mode, &zt_fops, NULL);
+		timer = devfs_register(zaptel_devfs_dir, "timer", DEVFS_FL_DEFAULT, DAHDI_MAJOR, 253, mode, &dahdi_fops, NULL);
+		channel = devfs_register(zaptel_devfs_dir, "channel", DEVFS_FL_DEFAULT, DAHDI_MAJOR, 254, mode, &dahdi_fops, NULL);
+		pseudo = devfs_register(zaptel_devfs_dir, "pseudo", DEVFS_FL_DEFAULT, DAHDI_MAJOR, 255, mode, &dahdi_fops, NULL);
+		ctl = devfs_register(zaptel_devfs_dir, "ctl", DEVFS_FL_DEFAULT, DAHDI_MAJOR, 0, mode, &dahdi_fops, NULL);
 	}
 #else
-	if ((res = register_chrdev(ZT_MAJOR, "zaptel", &zt_fops))) {
-		printk(KERN_ERR "Unable to register Zaptel character device handler on %d\n", ZT_MAJOR);
+	if ((res = register_chrdev(DAHDI_MAJOR, "zaptel", &dahdi_fops))) {
+		printk(KERN_ERR "Unable to register Zaptel character device handler on %d\n", DAHDI_MAJOR);
 		return res;
 	}
 #endif /* CONFIG_DEVFS_FS */
 
-	printk(KERN_INFO "Zapata Telephony Interface Registered on major %d\n", ZT_MAJOR);
+	printk(KERN_INFO "Zapata Telephony Interface Registered on major %d\n", DAHDI_MAJOR);
 	printk(KERN_INFO "Zaptel Version: %s\n", ZAPTEL_VERSION);
 	echo_can_init();
-	zt_conv_init();
+	dahdi_conv_init();
 	fasthdlc_precalc();
 	rotate_sums();
 	rwlock_init(&chan_lock);
@@ -7761,7 +7761,7 @@ static int __init zt_init(void) {
 	return res;
 }
 
-static void __exit zt_cleanup(void) {
+static void __exit dahdi_cleanup(void) {
 	int x;
 
 #ifdef CONFIG_PROC_FS
@@ -7769,7 +7769,7 @@ static void __exit zt_cleanup(void) {
 #endif
 
 	printk(KERN_INFO "Zapata Telephony Interface Unloaded\n");
-	for (x = 0; x < ZT_TONE_ZONE_MAX; x++) {
+	for (x = 0; x < DAHDI_TONE_ZONE_MAX; x++) {
 		if (tone_zones[x])
 			kfree(tone_zones[x]);
 	}
@@ -7780,16 +7780,16 @@ static void __exit zt_cleanup(void) {
 	devfs_unregister(pseudo);
 	devfs_unregister(ctl);
 	devfs_unregister(zaptel_devfs_dir);
-	devfs_unregister_chrdev(ZT_MAJOR, "zaptel");
+	devfs_unregister_chrdev(DAHDI_MAJOR, "zaptel");
 #else
 #ifdef CONFIG_ZAP_UDEV
-	class_device_destroy(zap_class, MKDEV(ZT_MAJOR, 253)); /* timer */
-	class_device_destroy(zap_class, MKDEV(ZT_MAJOR, 254)); /* channel */
-	class_device_destroy(zap_class, MKDEV(ZT_MAJOR, 255)); /* pseudo */
-	class_device_destroy(zap_class, MKDEV(ZT_MAJOR, 0)); /* ctl */
+	class_device_destroy(zap_class, MKDEV(DAHDI_MAJOR, 253)); /* timer */
+	class_device_destroy(zap_class, MKDEV(DAHDI_MAJOR, 254)); /* channel */
+	class_device_destroy(zap_class, MKDEV(DAHDI_MAJOR, 255)); /* pseudo */
+	class_device_destroy(zap_class, MKDEV(DAHDI_MAJOR, 0)); /* ctl */
 	class_destroy(zap_class);
 #endif /* CONFIG_ZAP_UDEV */
-	unregister_chrdev(ZT_MAJOR, "zaptel");
+	unregister_chrdev(DAHDI_MAJOR, "zaptel");
 #endif
 #ifdef CONFIG_ZAPTEL_WATCHDOG
 	watchdog_cleanup();
@@ -7798,5 +7798,5 @@ static void __exit zt_cleanup(void) {
 	echo_can_shutdown();
 }
 
-module_init(zt_init);
-module_exit(zt_cleanup);
+module_init(dahdi_init);
+module_exit(dahdi_cleanup);
diff --git a/drivers/dahdi/dahdi_dummy.c b/drivers/dahdi/dahdi_dummy.c
index 3921d46..046da79 100644
--- a/drivers/dahdi/dahdi_dummy.c
+++ b/drivers/dahdi/dahdi_dummy.c
@@ -99,8 +99,8 @@
 #endif
 
 struct ztdummy {
-	struct zt_span span;
-	struct zt_chan chan;
+	struct dahdi_span span;
+	struct dahdi_chan chan;
 #ifdef LINUX26
 	unsigned int counter;
 #ifdef USE_RTC
@@ -310,8 +310,8 @@ static void ztdummy_rtc_interrupt(void *private_data)
 			taskletpending = 1;
 			tasklet_hi_schedule(&ztd_tlet);
 		}
-		zt_receive(&ztd->span);
-		zt_transmit(&ztd->span);
+		dahdi_receive(&ztd->span);
+		dahdi_transmit(&ztd->span);
 	}
 	spin_unlock_irqrestore(&ztd->rtclock, flags);
 }
@@ -321,8 +321,8 @@ static enum hrtimer_restart ztdummy_hr_int(struct hrtimer *htmr)
 	unsigned long overrun;
 	
 	/* Trigger Zaptel */
-	zt_receive(&ztd->span);
-	zt_transmit(&ztd->span);
+	dahdi_receive(&ztd->span);
+	dahdi_transmit(&ztd->span);
 
 	/* Overrun should always return 1, since we are in the timer that 
 	 * expired.
@@ -357,8 +357,8 @@ static void ztdummy_timer(unsigned long param)
 	ztd->counter += ZAPTEL_TIME;
 	while (ztd->counter >= HZ) {
 		ztd->counter -= HZ;
-		zt_receive(&ztd->span);
-		zt_transmit(&ztd->span);
+		dahdi_receive(&ztd->span);
+		dahdi_transmit(&ztd->span);
 	}
 }
 #endif
@@ -371,8 +371,8 @@ static void ztdummy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 	status = inw (io_addr + USBSTS);
 	if (status != 0)  {	/* interrupt from our USB port */
 		static int check_int = 0;
-		zt_receive(&ztd->span);
-		zt_transmit(&ztd->span);
+		dahdi_receive(&ztd->span);
+		dahdi_transmit(&ztd->span);
 		/* TODO: What's the relation between monitor and
 		 * DEBUG_TICKS */
 		if (monitor && check_int) {
@@ -394,11 +394,11 @@ static int ztdummy_initialize(struct ztdummy *ztd)
 	ztd->chan.chanpos = 1;
 	ztd->span.chans = &ztd->chan;
 	ztd->span.channels = 0;		/* no channels on our span */
-	ztd->span.deflaw = ZT_LAW_MULAW;
+	ztd->span.deflaw = DAHDI_LAW_MULAW;
 	init_waitqueue_head(&ztd->span.maintq);
 	ztd->span.pvt = ztd;
 	ztd->chan.pvt = ztd;
-	if (zt_register(&ztd->span, 0)) {
+	if (dahdi_register(&ztd->span, 0)) {
 		return -1;
 	}
 	return 0;
@@ -452,7 +452,7 @@ int init_module(void)
 	err = rtc_register(&ztd->rtc_task);
 	if (err < 0) {
 		printk(KERN_ERR "ztdummy: Unable to register zaptel rtc driver\n");
-		zt_unregister(&ztd->span);
+		dahdi_unregister(&ztd->span);
 		kfree(ztd);
 		return err;
 	}
@@ -526,7 +526,7 @@ void cleanup_module(void)
 #else
 	free_irq(s->irq, ztd);  /* disable interrupts */
 #endif
-	zt_unregister(&ztd->span);
+	dahdi_unregister(&ztd->span);
 	kfree(ztd);
 #ifndef LINUX26
 	unlink_td(s, td, 1);
diff --git a/drivers/dahdi/dahdi_dummy.h b/drivers/dahdi/dahdi_dummy.h
index 25e37c9..0f027cf 100644
--- a/drivers/dahdi/dahdi_dummy.h
+++ b/drivers/dahdi/dahdi_dummy.h
@@ -30,8 +30,8 @@
 #endif
 
 struct ztdummy {
-	struct zt_span span;
-	struct zt_chan chan;
+	struct dahdi_span span;
+	struct dahdi_chan chan;
 #ifdef LINUX26
 	unsigned int counter;
 #ifdef USE_RTC
diff --git a/drivers/dahdi/dahdi_dynamic.c b/drivers/dahdi/dahdi_dynamic.c
index 42d6291..6daa052 100644
--- a/drivers/dahdi/dahdi_dynamic.c
+++ b/drivers/dahdi/dahdi_dynamic.c
@@ -74,7 +74,7 @@
  */
 
 /* Arbitrary limit to the max # of channels in a span */
-#define ZT_DYNAMIC_MAX_CHANS	256
+#define DAHDI_DYNAMIC_MAX_CHANS	256
 
 #define ZTD_FLAG_YELLOW_ALARM		(1 << 0)
 #define ZTD_FLAG_SIGBITS_PRESENT	(1 << 1)
@@ -84,9 +84,9 @@
 #define ERR_NCHAN					(1 << 17)
 #define ERR_LEN						(1 << 18)
 
-EXPORT_SYMBOL(zt_dynamic_register);
-EXPORT_SYMBOL(zt_dynamic_unregister);
-EXPORT_SYMBOL(zt_dynamic_receive);
+EXPORT_SYMBOL(dahdi_dynamic_register);
+EXPORT_SYMBOL(dahdi_dynamic_unregister);
+EXPORT_SYMBOL(dahdi_dynamic_receive);
 
 #ifdef ENABLE_TASKLETS
 static int taskletrun;
@@ -100,7 +100,7 @@ static void ztd_tasklet(unsigned long data);
 #endif
 
 
-static struct zt_dynamic {
+static struct dahdi_dynamic {
 	char addr[40];
 	char dname[20];
 	int err;
@@ -109,17 +109,17 @@ static struct zt_dynamic {
 	long rxjif;
 	unsigned short txcnt;
 	unsigned short rxcnt;
-	struct zt_span span;
-	struct zt_chan *chans;
-	struct zt_dynamic *next;
-	struct zt_dynamic_driver *driver;
+	struct dahdi_span span;
+	struct dahdi_chan *chans;
+	struct dahdi_dynamic *next;
+	struct dahdi_dynamic_driver *driver;
 	void *pvt;
 	int timing;
 	int master;
 	unsigned char *msgbuf;
 } *dspans;
 
-static struct zt_dynamic_driver *drivers =  NULL;
+static struct dahdi_dynamic_driver *drivers =  NULL;
 
 static int debug = 0;
 
@@ -141,13 +141,13 @@ static void checkmaster(void)
 	unsigned long flags;
 	int newhasmaster=0;
 	int best = 9999999;
-	struct zt_dynamic *z, *master=NULL;
+	struct dahdi_dynamic *z, *master=NULL;
 	spin_lock_irqsave(&dlock, flags);
 	z = dspans;
 	while(z) {
 		if (z->timing) {
 			z->master = 0;
-			if (!(z->span.alarms & ZT_ALARM_RED) &&
+			if (!(z->span.alarms & DAHDI_ALARM_RED) &&
 			    (z->timing < best) && !z->dead) {
 				/* If not in alarm and they're
 				   a better timing source, use them */
@@ -169,7 +169,7 @@ static void checkmaster(void)
 		printk("TDMoX: No master.\n");
 }
 
-static void ztd_sendmessage(struct zt_dynamic *z)
+static void ztd_sendmessage(struct dahdi_dynamic *z)
 {
 	unsigned char *buf = z->msgbuf;
 	unsigned short bits;
@@ -178,12 +178,12 @@ static void ztd_sendmessage(struct zt_dynamic *z)
 	int offset;
 
 	/* Byte 0: Number of samples per channel */
-	*buf = ZT_CHUNKSIZE;
+	*buf = DAHDI_CHUNKSIZE;
 	buf++; msglen++;
 
 	/* Byte 1: Flags */
 	*buf = 0;
-	if (z->span.alarms & ZT_ALARM_RED)
+	if (z->span.alarms & DAHDI_ALARM_RED)
 		*buf |= ZTD_FLAG_YELLOW_ALARM;
 	*buf |= ZTD_FLAG_SIGBITS_PRESENT;
 	buf++; msglen++;
@@ -220,9 +220,9 @@ static void ztd_sendmessage(struct zt_dynamic *z)
 	}
 	
 	for (x=0;x<z->span.channels;x++) {
-		memcpy(buf, z->chans[x].writechunk, ZT_CHUNKSIZE);
-		buf += ZT_CHUNKSIZE;
-		msglen += ZT_CHUNKSIZE;
+		memcpy(buf, z->chans[x].writechunk, DAHDI_CHUNKSIZE);
+		buf += DAHDI_CHUNKSIZE;
+		msglen += DAHDI_CHUNKSIZE;
 	}
 	
 	z->driver->transmit(z->pvt, z->msgbuf, msglen);
@@ -232,8 +232,8 @@ static void ztd_sendmessage(struct zt_dynamic *z)
 static void __ztdynamic_run(void)
 {
 	unsigned long flags;
-	struct zt_dynamic *z;
-	struct zt_dynamic_driver *drv;
+	struct dahdi_dynamic *z;
+	struct dahdi_dynamic_driver *drv;
 	int y;
 	spin_lock_irqsave(&dlock, flags);
 	z = dspans;
@@ -242,10 +242,10 @@ static void __ztdynamic_run(void)
 			/* Ignore dead spans */
 			for (y=0;y<z->span.channels;y++) {
 				/* Echo cancel double buffered data */
-				zt_ec_chunk(&z->span.chans[y], z->span.chans[y].readchunk, z->span.chans[y].writechunk);
+				dahdi_ec_chunk(&z->span.chans[y], z->span.chans[y].readchunk, z->span.chans[y].writechunk);
 			}
-			zt_receive(&z->span);
-			zt_transmit(&z->span);
+			dahdi_receive(&z->span);
+			dahdi_transmit(&z->span);
 			/* Handle all transmissions now */
 			ztd_sendmessage(z);
 		}
@@ -280,9 +280,9 @@ static void ztdynamic_run(void)
 #define ztdynamic_run __ztdynamic_run
 #endif
 
-void zt_dynamic_receive(struct zt_span *span, unsigned char *msg, int msglen)
+void dahdi_dynamic_receive(struct dahdi_span *span, unsigned char *msg, int msglen)
 {
-	struct zt_dynamic *ztd = span->pvt;
+	struct dahdi_dynamic *ztd = span->pvt;
 	int newerr=0;
 	unsigned long flags;
 	int sflags;
@@ -305,11 +305,11 @@ void zt_dynamic_receive(struct zt_span *span, unsigned char *msg, int msglen)
 	}
 	
 	/* First, check the chunksize */
-	if (*msg != ZT_CHUNKSIZE) {
+	if (*msg != DAHDI_CHUNKSIZE) {
 		spin_unlock_irqrestore(&dlock, flags);
 		newerr = ERR_NSAMP | msg[0];
 		if (newerr != 	ztd->err) {
-			printk("Span %s: Expected %d samples, but receiving %d\n", span->name, ZT_CHUNKSIZE, msg[0]);
+			printk("Span %s: Expected %d samples, but receiving %d\n", span->name, DAHDI_CHUNKSIZE, msg[0]);
 		}
 		ztd->err = newerr;
 		return;
@@ -341,7 +341,7 @@ void zt_dynamic_receive(struct zt_span *span, unsigned char *msg, int msglen)
 	/* Start with header */
 	xlen = 6;
 	/* Add samples of audio */
-	xlen += nchans * ZT_CHUNKSIZE;
+	xlen += nchans * DAHDI_CHUNKSIZE;
 	/* If RBS info is there, add that */
 	if (sflags & ZTD_FLAG_SIGBITS_PRESENT) {
 		/* Account for sigbits -- one short per 4 channels*/
@@ -375,15 +375,15 @@ void zt_dynamic_receive(struct zt_span *span, unsigned char *msg, int msglen)
 			
 			/* Update signalling if appropriate */
 			if (sig != span->chans[x].rxsig)
-				zt_rbsbits(&span->chans[x], sig);
+				dahdi_rbsbits(&span->chans[x], sig);
 				
 		}
 	}
 	
 	/* Record data for channels */
 	for (x=0;x<nchans;x++) {
-		memcpy(span->chans[x].readchunk, msg, ZT_CHUNKSIZE);
-		msg += ZT_CHUNKSIZE;
+		memcpy(span->chans[x].readchunk, msg, DAHDI_CHUNKSIZE);
+		msg += DAHDI_CHUNKSIZE;
 	}
 
 	master = ztd->master;
@@ -394,13 +394,13 @@ void zt_dynamic_receive(struct zt_span *span, unsigned char *msg, int msglen)
 	spin_unlock_irqrestore(&dlock, flags);
 	
 	/* Check for Yellow alarm */
-	newalarm = span->alarms & ~(ZT_ALARM_YELLOW | ZT_ALARM_RED);
+	newalarm = span->alarms & ~(DAHDI_ALARM_YELLOW | DAHDI_ALARM_RED);
 	if (sflags & ZTD_FLAG_YELLOW_ALARM)
-		newalarm |= ZT_ALARM_YELLOW;
+		newalarm |= DAHDI_ALARM_YELLOW;
 
 	if (newalarm != span->alarms) {
 		span->alarms = newalarm;
-		zt_alarm_notify(span);
+		dahdi_alarm_notify(span);
 		checkmaster();
 	}
 	
@@ -417,11 +417,11 @@ void zt_dynamic_receive(struct zt_span *span, unsigned char *msg, int msglen)
 	
 }
 
-static void dynamic_destroy(struct zt_dynamic *z)
+static void dynamic_destroy(struct dahdi_dynamic *z)
 {
 	/* Unregister span if appropriate */
-	if (z->span.flags & ZT_FLAG_REGISTERED)
-		zt_unregister(&z->span);
+	if (z->span.flags & DAHDI_FLAG_REGISTERED)
+		dahdi_unregister(&z->span);
 
 	/* Destroy the pvt stuff if there */
 	if (z->pvt)
@@ -440,9 +440,9 @@ static void dynamic_destroy(struct zt_dynamic *z)
 	checkmaster();
 }
 
-static struct zt_dynamic *find_dynamic(ZT_DYNAMIC_SPAN *zds)
+static struct dahdi_dynamic *find_dynamic(DAHDI_DYNAMIC_SPAN *zds)
 {
-	struct zt_dynamic *z;
+	struct dahdi_dynamic *z;
 	z = dspans;
 	while(z) {
 		if (!strcmp(z->dname, zds->driver) &&
@@ -453,9 +453,9 @@ static struct zt_dynamic *find_dynamic(ZT_DYNAMIC_SPAN *zds)
 	return z;
 }
 
-static struct zt_dynamic_driver *find_driver(char *name)
+static struct dahdi_dynamic_driver *find_driver(char *name)
 {
-	struct zt_dynamic_driver *ztd;
+	struct dahdi_dynamic_driver *ztd;
 	ztd = drivers;
 	while(ztd) {
 		/* here's our driver */
@@ -466,10 +466,10 @@ static struct zt_dynamic_driver *find_driver(char *name)
 	return ztd;
 }
 
-static int destroy_dynamic(ZT_DYNAMIC_SPAN *zds)
+static int destroy_dynamic(DAHDI_DYNAMIC_SPAN *zds)
 {
 	unsigned long flags;
-	struct zt_dynamic *z, *cur, *prev=NULL;
+	struct dahdi_dynamic *z, *cur, *prev=NULL;
 	spin_lock_irqsave(&dlock, flags);
 	z = find_dynamic(zds);
 	if (!z) {
@@ -503,15 +503,15 @@ static int destroy_dynamic(ZT_DYNAMIC_SPAN *zds)
 	return 0;
 }
 
-static int ztd_rbsbits(struct zt_chan *chan, int bits)
+static int ztd_rbsbits(struct dahdi_chan *chan, int bits)
 {
 	/* Don't have to do anything */
 	return 0;
 }
 
-static int ztd_open(struct zt_chan *chan)
+static int ztd_open(struct dahdi_chan *chan)
 {
-	struct zt_dynamic *z;
+	struct dahdi_dynamic *z;
 	z = chan->span->pvt;
 	if (z) {
 		if (z->dead)
@@ -527,14 +527,14 @@ static int ztd_open(struct zt_chan *chan)
 	return 0;
 }
 
-static int ztd_chanconfig(struct zt_chan *chan, int sigtype)
+static int ztd_chanconfig(struct dahdi_chan *chan, int sigtype)
 {
 	return 0;
 }
 
-static int ztd_close(struct zt_chan *chan)
+static int ztd_close(struct dahdi_chan *chan)
 {
-	struct zt_dynamic *z;
+	struct dahdi_dynamic *z;
 	z = chan->span->pvt;
 	if (z) 
 		z->usecount--;
@@ -548,10 +548,10 @@ static int ztd_close(struct zt_chan *chan)
 	return 0;
 }
 
-static int create_dynamic(ZT_DYNAMIC_SPAN *zds)
+static int create_dynamic(DAHDI_DYNAMIC_SPAN *zds)
 {
-	struct zt_dynamic *z;
-	struct zt_dynamic_driver *ztd;
+	struct dahdi_dynamic *z;
+	struct dahdi_dynamic_driver *ztd;
 	unsigned long flags;
 	int x;
 	int bufsize;
@@ -560,8 +560,8 @@ static int create_dynamic(ZT_DYNAMIC_SPAN *zds)
 		printk("Can't be less than 1 channel (%d)!\n", zds->numchans);
 		return -EINVAL;
 	}
-	if (zds->numchans >= ZT_DYNAMIC_MAX_CHANS) {
-		printk("Can't create dynamic span with greater than %d channels.  See ztdynamic.c and increase ZT_DYNAMIC_MAX_CHANS\n", zds->numchans);
+	if (zds->numchans >= DAHDI_DYNAMIC_MAX_CHANS) {
+		printk("Can't create dynamic span with greater than %d channels.  See ztdynamic.c and increase DAHDI_DYNAMIC_MAX_CHANS\n", zds->numchans);
 		return -EINVAL;
 	}
 
@@ -579,25 +579,25 @@ static int create_dynamic(ZT_DYNAMIC_SPAN *zds)
 
 
 	/* Allocate memory */
-	z = (struct zt_dynamic *)kmalloc(sizeof(struct zt_dynamic), GFP_KERNEL);
+	z = (struct dahdi_dynamic *)kmalloc(sizeof(struct dahdi_dynamic), GFP_KERNEL);
 	if (!z) 
 		return -ENOMEM;
 
 	/* Zero it out */
-	memset(z, 0, sizeof(struct zt_dynamic));
+	memset(z, 0, sizeof(struct dahdi_dynamic));
 
 	/* Allocate other memories */
-	z->chans = vmalloc(sizeof(struct zt_chan) * zds->numchans);
+	z->chans = vmalloc(sizeof(struct dahdi_chan) * zds->numchans);
 	if (!z->chans) {
 		dynamic_destroy(z);
 		return -ENOMEM;
 	}
 
 	/* Zero out channel stuff */
-	memset(z->chans, 0, sizeof(struct zt_chan) * zds->numchans);
+	memset(z->chans, 0, sizeof(struct dahdi_chan) * zds->numchans);
 
 	/* Allocate message buffer with sample space and header space */
-	bufsize = zds->numchans * ZT_CHUNKSIZE + zds->numchans / 4 + 48;
+	bufsize = zds->numchans * DAHDI_CHUNKSIZE + zds->numchans / 4 + 48;
 
 	z->msgbuf = kmalloc(bufsize, GFP_KERNEL);
 
@@ -617,8 +617,8 @@ static int create_dynamic(ZT_DYNAMIC_SPAN *zds)
 	sprintf(z->span.desc, "Dynamic '%s' span at '%s'", zds->driver, zds->addr);
 	z->span.channels = zds->numchans;
 	z->span.pvt = z;
-	z->span.deflaw = ZT_LAW_MULAW;
-	z->span.flags |= ZT_FLAG_RBS;
+	z->span.deflaw = DAHDI_LAW_MULAW;
+	z->span.flags |= DAHDI_FLAG_RBS;
 	z->span.chans = z->chans;
 	z->span.rbsbits = ztd_rbsbits;
 	z->span.open = ztd_open;
@@ -626,10 +626,10 @@ static int create_dynamic(ZT_DYNAMIC_SPAN *zds)
 	z->span.chanconfig = ztd_chanconfig;
 	for (x=0;x<zds->numchans;x++) {
 		sprintf(z->chans[x].name, "ZTD/%s/%s/%d", zds->driver, zds->addr, x+1);
-		z->chans[x].sigcap = ZT_SIG_EM | ZT_SIG_CLEAR | ZT_SIG_FXSLS |
-				     ZT_SIG_FXSKS | ZT_SIG_FXSGS | ZT_SIG_FXOLS |
-				     ZT_SIG_FXOKS | ZT_SIG_FXOGS | ZT_SIG_SF | 
-				     ZT_SIG_DACS_RBS | ZT_SIG_CAS;
+		z->chans[x].sigcap = DAHDI_SIG_EM | DAHDI_SIG_CLEAR | DAHDI_SIG_FXSLS |
+				     DAHDI_SIG_FXSKS | DAHDI_SIG_FXSGS | DAHDI_SIG_FXOLS |
+				     DAHDI_SIG_FXOKS | DAHDI_SIG_FXOGS | DAHDI_SIG_SF | 
+				     DAHDI_SIG_DACS_RBS | DAHDI_SIG_CAS;
 		z->chans[x].chanpos = x + 1;
 		z->chans[x].pvt = z;
 	}
@@ -668,7 +668,7 @@ static int create_dynamic(ZT_DYNAMIC_SPAN *zds)
 	z->driver = ztd;
 
 	/* Whee!  We're created.  Now register the span */
-	if (zt_register(&z->span, 0)) {
+	if (dahdi_register(&z->span, 0)) {
 		printk("Unable to register span '%s'\n", z->span.name);
 		dynamic_destroy(z);
 		return -EINVAL;
@@ -701,7 +701,7 @@ static void ztd_tasklet(unsigned long data)
 
 static int ztdynamic_ioctl(unsigned int cmd, unsigned long data)
 {
-	ZT_DYNAMIC_SPAN zds;
+	DAHDI_DYNAMIC_SPAN zds;
 	int res;
 	switch(cmd) {
 	case 0:
@@ -711,8 +711,8 @@ static int ztdynamic_ioctl(unsigned int cmd, unsigned long data)
 		if (!hasmaster)
 			ztdynamic_run();
 		return 0;
-	case ZT_DYNAMIC_CREATE:
-		if (copy_from_user(&zds, (ZT_DYNAMIC_SPAN *)data, sizeof(zds)))
+	case DAHDI_DYNAMIC_CREATE:
+		if (copy_from_user(&zds, (DAHDI_DYNAMIC_SPAN *)data, sizeof(zds)))
 			return -EFAULT;
 		if (debug)
 			printk("Dynamic Create\n");
@@ -721,11 +721,11 @@ static int ztdynamic_ioctl(unsigned int cmd, unsigned long data)
 			return res;
 		zds.spanno = res;
 		/* Let them know the new span number */
-		if (copy_to_user((ZT_DYNAMIC_SPAN *)data, &zds, sizeof(zds)))
+		if (copy_to_user((DAHDI_DYNAMIC_SPAN *)data, &zds, sizeof(zds)))
 			return -EFAULT;
 		return 0;
-	case ZT_DYNAMIC_DESTROY:
-		if (copy_from_user(&zds, (ZT_DYNAMIC_SPAN *)data, sizeof(zds)))
+	case DAHDI_DYNAMIC_DESTROY:
+		if (copy_from_user(&zds, (DAHDI_DYNAMIC_SPAN *)data, sizeof(zds)))
 			return -EFAULT;
 		if (debug)
 			printk("Dynamic Destroy\n");
@@ -735,7 +735,7 @@ static int ztdynamic_ioctl(unsigned int cmd, unsigned long data)
 	return -ENOTTY;
 }
 
-int zt_dynamic_register(struct zt_dynamic_driver *dri)
+int dahdi_dynamic_register(struct dahdi_dynamic_driver *dri)
 {
 	unsigned long flags;
 	int res = 0;
@@ -750,10 +750,10 @@ int zt_dynamic_register(struct zt_dynamic_driver *dri)
 	return res;
 }
 
-void zt_dynamic_unregister(struct zt_dynamic_driver *dri)
+void dahdi_dynamic_unregister(struct dahdi_dynamic_driver *dri)
 {
-	struct zt_dynamic_driver *cur, *prev=NULL;
-	struct zt_dynamic *z, *zp, *zn;
+	struct dahdi_dynamic_driver *cur, *prev=NULL;
+	struct dahdi_dynamic *z, *zp, *zn;
 	unsigned long flags;
 	write_lock_irqsave(&drvlock, flags);
 	cur = drivers;
@@ -799,17 +799,17 @@ static void check_for_red_alarm(unsigned long ignored)
 	unsigned long flags;
 	int newalarm;
 	int alarmchanged = 0;
-	struct zt_dynamic *z;
+	struct dahdi_dynamic *z;
 	spin_lock_irqsave(&dlock, flags);
 	z = dspans;
 	while(z) {
-		newalarm = z->span.alarms & ~ZT_ALARM_RED;
+		newalarm = z->span.alarms & ~DAHDI_ALARM_RED;
 		/* If nothing received for a second, consider that RED ALARM */
 		if ((jiffies - z->rxjif) > 1 * HZ) {
-			newalarm |= ZT_ALARM_RED;
+			newalarm |= DAHDI_ALARM_RED;
 			if (z->span.alarms != newalarm) {
 				z->span.alarms = newalarm;
-				zt_alarm_notify(&z->span);
+				dahdi_alarm_notify(&z->span);
 				alarmchanged++;
 			}
 		}
@@ -826,7 +826,7 @@ static void check_for_red_alarm(unsigned long ignored)
 
 int ztdynamic_init(void)
 {
-	zt_set_dynamic_ioctl(ztdynamic_ioctl);
+	dahdi_set_dynamic_ioctl(ztdynamic_ioctl);
 	/* Start process to check for RED ALARM */
 	init_timer(&alarmcheck);
 	alarmcheck.expires = 0;
@@ -849,7 +849,7 @@ void ztdynamic_cleanup(void)
 		tasklet_kill(&ztd_tlet);
 	}
 #endif
-	zt_set_dynamic_ioctl(NULL);
+	dahdi_set_dynamic_ioctl(NULL);
 	del_timer(&alarmcheck);
 	printk("Zaptel Dynamic Span support unloaded\n");
 }
diff --git a/drivers/dahdi/dahdi_dynamic_eth.c b/drivers/dahdi/dahdi_dynamic_eth.c
index 1795487..5c2851f 100644
--- a/drivers/dahdi/dahdi_dynamic_eth.c
+++ b/drivers/dahdi/dahdi_dynamic_eth.c
@@ -59,17 +59,17 @@ static struct sk_buff_head skbs;
 static struct ztdeth {
 	unsigned char addr[ETH_ALEN];
 	unsigned short subaddr; /* Network byte order */
-	struct zt_span *span;
+	struct dahdi_span *span;
 	char ethdev[IFNAMSIZ];
 	struct net_device *dev;
 	struct ztdeth *next;
 } *zdevs = NULL;
 
-struct zt_span *ztdeth_getspan(unsigned char *addr, unsigned short subaddr)
+struct dahdi_span *ztdeth_getspan(unsigned char *addr, unsigned short subaddr)
 {
 	unsigned long flags;
 	struct ztdeth *z;
-	struct zt_span *span = NULL;
+	struct dahdi_span *span = NULL;
 	spin_lock_irqsave(&zlock, flags);
 	z = zdevs;
 	while(z) {
@@ -90,7 +90,7 @@ static int ztdeth_rcv(struct sk_buff *skb, struct net_device *dev, struct packet
 static int ztdeth_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
 #endif
 {
-	struct zt_span *span;
+	struct dahdi_span *span;
 	struct ztdeth_header *zh;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
 	zh = (struct ztdeth_header *)skb_network_header(skb);
@@ -104,7 +104,7 @@ static int ztdeth_rcv(struct sk_buff *skb, struct net_device *dev, struct packet
 #endif	
 	if (span) {
 		skb_pull(skb, sizeof(struct ztdeth_header));
-		zt_dynamic_receive(span, (unsigned char *)skb->data, skb->len);
+		dahdi_dynamic_receive(span, (unsigned char *)skb->data, skb->len);
 	}
 	kfree_skb(skb);
 	return 0;
@@ -300,7 +300,7 @@ static void ztdeth_destroy(void *pvt)
 	}
 }
 
-static void *ztdeth_create(struct zt_span *span, char *addr)
+static void *ztdeth_create(struct dahdi_span *span, char *addr)
 {
 	struct ztdeth *z;
 	char src[256];
@@ -408,7 +408,7 @@ static void *ztdeth_create(struct zt_span *span, char *addr)
 	return z;
 }
 
-static struct zt_dynamic_driver ztd_eth = {
+static struct dahdi_dynamic_driver ztd_eth = {
 	"eth",
 	"Ethernet",
 	ztdeth_create,
@@ -425,7 +425,7 @@ static int __init ztdeth_init(void)
 {
 	dev_add_pack(&ztdeth_ptype);
 	register_netdevice_notifier(&ztdeth_nblock);
-	zt_dynamic_register(&ztd_eth);
+	dahdi_dynamic_register(&ztd_eth);
 
 	skb_queue_head_init(&skbs);
 
@@ -436,7 +436,7 @@ static void __exit ztdeth_exit(void)
 {
 	dev_remove_pack(&ztdeth_ptype);
 	unregister_netdevice_notifier(&ztdeth_nblock);
-	zt_dynamic_unregister(&ztd_eth);
+	dahdi_dynamic_unregister(&ztd_eth);
 }
 
 MODULE_DESCRIPTION("Zaptel Dynamic TDMoE Support");
diff --git a/drivers/dahdi/dahdi_dynamic_loc.c b/drivers/dahdi/dahdi_dynamic_loc.c
index 69057a0..d5ee144 100644
--- a/drivers/dahdi/dahdi_dynamic_loc.c
+++ b/drivers/dahdi/dahdi_dynamic_loc.c
@@ -75,7 +75,7 @@ static struct ztdlocal {
 	unsigned short id;
 	struct ztdlocal *monitor_rx_peer; /* Indicates the peer span that monitors this span */
 	struct ztdlocal *peer; /* Indicates the rw peer for this span */
-	struct zt_span *span;
+	struct dahdi_span *span;
 	struct ztdlocal *next;
 } *zdevs = NULL;
 
@@ -87,10 +87,10 @@ static struct ztdlocal {
 	spin_lock_irqsave(&zlock, flags);
 	z = pvt;
 	if (z->peer && z->peer->span) {
-		zt_dynamic_receive(z->peer->span, msg, msglen);
+		dahdi_dynamic_receive(z->peer->span, msg, msglen);
 	}
 	if (z->monitor_rx_peer && z->monitor_rx_peer->span) {
-		zt_dynamic_receive(z->monitor_rx_peer->span, msg, msglen);
+		dahdi_dynamic_receive(z->monitor_rx_peer->span, msg, msglen);
 	}
 	spin_unlock_irqrestore(&zlock, flags);
 	return 0;
@@ -167,7 +167,7 @@ static int digit2int(char d)
 	}
 }
 
-/*static*/ void *ztdlocal_create(struct zt_span *span, char *address)
+/*static*/ void *ztdlocal_create(struct dahdi_span *span, char *address)
 {
 	struct ztdlocal *z, *l;
 	unsigned long flags;
@@ -253,7 +253,7 @@ INVALID_ADDRESS:
 	return NULL;
 }
 
-static struct zt_dynamic_driver ztd_local = {
+static struct dahdi_dynamic_driver ztd_local = {
 	"loc",
 	"Local",
 	ztdlocal_create,
@@ -264,13 +264,13 @@ static struct zt_dynamic_driver ztd_local = {
 
 /*static*/ int __init ztdlocal_init(void)
 {
-	zt_dynamic_register(&ztd_local);
+	dahdi_dynamic_register(&ztd_local);
 	return 0;
 }
 
 /*static*/ void __exit ztdlocal_exit(void)
 {
-	zt_dynamic_unregister(&ztd_local);
+	dahdi_dynamic_unregister(&ztd_local);
 }
 
 module_init(ztdlocal_init);
diff --git a/drivers/dahdi/dahdi_transcode.c b/drivers/dahdi/dahdi_transcode.c
index eaf2f9b..d21d89a 100644
--- a/drivers/dahdi/dahdi_transcode.c
+++ b/drivers/dahdi/dahdi_transcode.c
@@ -48,18 +48,18 @@
 #include <dahdi/user.h>
 
 static int debug = 0;
-static struct zt_transcoder *trans;
+static struct dahdi_transcoder *trans;
 static spinlock_t translock = SPIN_LOCK_UNLOCKED;
 
-EXPORT_SYMBOL(zt_transcoder_register);
-EXPORT_SYMBOL(zt_transcoder_unregister);
-EXPORT_SYMBOL(zt_transcoder_alert);
-EXPORT_SYMBOL(zt_transcoder_alloc);
-EXPORT_SYMBOL(zt_transcoder_free);
+EXPORT_SYMBOL(dahdi_transcoder_register);
+EXPORT_SYMBOL(dahdi_transcoder_unregister);
+EXPORT_SYMBOL(dahdi_transcoder_alert);
+EXPORT_SYMBOL(dahdi_transcoder_alloc);
+EXPORT_SYMBOL(dahdi_transcoder_free);
 
-struct zt_transcoder *zt_transcoder_alloc(int numchans)
+struct dahdi_transcoder *dahdi_transcoder_alloc(int numchans)
 {
-	struct zt_transcoder *ztc;
+	struct dahdi_transcoder *ztc;
 	unsigned int x;
 	size_t size = sizeof(*ztc) + (sizeof(ztc->channels[0]) * numchans);
 
@@ -99,15 +99,15 @@ static int schluffen(wait_queue_head_t *q)
 	return 0;
 }
 
-void zt_transcoder_free(struct zt_transcoder *ztc)
+void dahdi_transcoder_free(struct dahdi_transcoder *ztc)
 {
 	kfree(ztc);
 }
 
 /* Register a transcoder */
-int zt_transcoder_register(struct zt_transcoder *tc)
+int dahdi_transcoder_register(struct dahdi_transcoder *tc)
 {
-	struct zt_transcoder *cur;
+	struct dahdi_transcoder *cur;
 	int res = -EBUSY;
 
 	spin_lock(&translock);
@@ -129,9 +129,9 @@ int zt_transcoder_register(struct zt_transcoder *tc)
 }
 
 /* Unregister a transcoder */
-int zt_transcoder_unregister(struct zt_transcoder *tc) 
+int dahdi_transcoder_unregister(struct dahdi_transcoder *tc) 
 {
-	struct zt_transcoder *cur, *prev;
+	struct dahdi_transcoder *cur, *prev;
 	int res = -EINVAL;
 
 	spin_lock(&translock);
@@ -159,21 +159,21 @@ int zt_transcoder_unregister(struct zt_transcoder *tc)
 }
 
 /* Alert a transcoder */
-int zt_transcoder_alert(struct zt_transcoder_channel *ztc)
+int dahdi_transcoder_alert(struct dahdi_transcoder_channel *ztc)
 {
 	if (debug)
 		printk("ZT Transcoder Alert!\n");
 	if (ztc->tch)
-		ztc->tch->status &= ~ZT_TC_FLAG_BUSY;
+		ztc->tch->status &= ~DAHDI_TC_FLAG_BUSY;
 	wake_up_interruptible(&ztc->ready);
 
 	return 0;
 }
 
-static int zt_tc_open(struct inode *inode, struct file *file)
+static int dahdi_tc_open(struct inode *inode, struct file *file)
 {
-	struct zt_transcoder_channel *ztc;
-	struct zt_transcode_header *zth;
+	struct dahdi_transcoder_channel *ztc;
+	struct dahdi_transcode_header *zth;
 	struct page *page;
 
 	if (!(ztc = kmalloc(sizeof(*ztc), GFP_KERNEL)))
@@ -186,11 +186,11 @@ static int zt_tc_open(struct inode *inode, struct file *file)
 	
 	memset(ztc, 0, sizeof(*ztc));
 	memset(zth, 0, sizeof(*zth));
-	ztc->flags = ZT_TC_FLAG_TRANSIENT | ZT_TC_FLAG_BUSY;
+	ztc->flags = DAHDI_TC_FLAG_TRANSIENT | DAHDI_TC_FLAG_BUSY;
 	ztc->tch = zth;
 	if (debug)
 		printk("Allocated Transcoder Channel, header is at %p!\n", zth);
-	zth->magic = ZT_TRANSCODE_MAGIC;
+	zth->magic = DAHDI_TRANSCODE_MAGIC;
 	file->private_data = ztc;
 	for (page = virt_to_page(zth);
 	     page < virt_to_page((unsigned long) zth + sizeof(*zth));
@@ -200,15 +200,15 @@ static int zt_tc_open(struct inode *inode, struct file *file)
 	return 0;
 }
 
-static void ztc_release(struct zt_transcoder_channel *ztc)
+static void ztc_release(struct dahdi_transcoder_channel *ztc)
 {
-	struct zt_transcode_header *zth = ztc->tch;
+	struct dahdi_transcode_header *zth = ztc->tch;
 	struct page *page;
 
 	if (!ztc)
 		return;
 
-	ztc->flags &= ~(ZT_TC_FLAG_BUSY);
+	ztc->flags &= ~(DAHDI_TC_FLAG_BUSY);
 
 	if(ztc->tch) {
 		for (page = virt_to_page(zth);
@@ -220,24 +220,24 @@ static void ztc_release(struct zt_transcoder_channel *ztc)
 
 	ztc->tch = NULL;
 	/* Actually reset the transcoder channel */
-	if (ztc->flags & ZT_TC_FLAG_TRANSIENT)
+	if (ztc->flags & DAHDI_TC_FLAG_TRANSIENT)
 		kfree(ztc);
 	if (debug)
 		printk("Released Transcoder!\n");
 }
 
-static int zt_tc_release(struct inode *inode, struct file *file)
+static int dahdi_tc_release(struct inode *inode, struct file *file)
 {
 	ztc_release(file->private_data);
 
 	return 0;
 }
 
-static int do_reset(struct zt_transcoder_channel **ztc)
+static int do_reset(struct dahdi_transcoder_channel **ztc)
 {
-	struct zt_transcoder_channel *newztc = NULL, *origztc = NULL;
-	struct zt_transcode_header *zth = (*ztc)->tch;
-	struct zt_transcoder *tc;
+	struct dahdi_transcoder_channel *newztc = NULL, *origztc = NULL;
+	struct dahdi_transcode_header *zth = (*ztc)->tch;
+	struct dahdi_transcoder *tc;
 	unsigned int x;
 	unsigned int match = 0;
 
@@ -254,13 +254,13 @@ static int do_reset(struct zt_transcoder_channel **ztc)
 
 			match = 1;
 			for (x = 0; x < tc->numchannels; x++) {
-				if (tc->channels[x].flags & ZT_TC_FLAG_BUSY)
+				if (tc->channels[x].flags & DAHDI_TC_FLAG_BUSY)
 					continue;
 				if ((tc->channels[x].chan_built) && ((zth->srcfmt | zth->dstfmt) != tc->channels[x].built_fmts))
 					continue;
 
 				newztc = &tc->channels[x];
-				newztc->flags = ZT_TC_FLAG_BUSY;
+				newztc->flags = DAHDI_TC_FLAG_BUSY;
 				break;
 			}
 		}
@@ -274,36 +274,36 @@ static int do_reset(struct zt_transcoder_channel **ztc)
 		(*ztc) = newztc;
 		(*ztc)->tch = origztc->tch;
 		origztc->tch = NULL;
-		(*ztc)->flags |= (origztc->flags & ~(ZT_TC_FLAG_TRANSIENT));
+		(*ztc)->flags |= (origztc->flags & ~(DAHDI_TC_FLAG_TRANSIENT));
 		ztc_release(origztc);
 	}
 
 	/* Actually reset the transcoder channel */
 	if ((*ztc)->parent && ((*ztc)->parent->operation))
-		return (*ztc)->parent->operation((*ztc), ZT_TCOP_ALLOCATE);
+		return (*ztc)->parent->operation((*ztc), DAHDI_TCOP_ALLOCATE);
 
 	return -EINVAL;
 }
 
-static int wait_busy(struct zt_transcoder_channel *ztc)
+static int wait_busy(struct dahdi_transcoder_channel *ztc)
 {
 	int ret;
 
 	for (;;) {
-		if (!(ztc->tch->status & ZT_TC_FLAG_BUSY))
+		if (!(ztc->tch->status & DAHDI_TC_FLAG_BUSY))
 			return 0;
 		if ((ret = schluffen(&ztc->ready)))
 			return ret;
 	}
 }
 
-static int zt_tc_getinfo(unsigned long data)
+static int dahdi_tc_getinfo(unsigned long data)
 {
-	struct zt_transcode_info info;
+	struct dahdi_transcode_info info;
 	unsigned int x;
-	struct zt_transcoder *tc;
+	struct dahdi_transcoder *tc;
 	
-	if (copy_from_user(&info, (struct zt_transcode_info *) data, sizeof(info)))
+	if (copy_from_user(&info, (struct dahdi_transcode_info *) data, sizeof(info)))
 		return -EFAULT;
 
 	spin_lock(&translock);
@@ -318,16 +318,16 @@ static int zt_tc_getinfo(unsigned long data)
 	info.srcfmts = tc->srcfmts;
 	info.dstfmts = tc->dstfmts;
 
-	return copy_to_user((struct zt_transcode_info *) data, &info, sizeof(info)) ? -EFAULT : 0;
+	return copy_to_user((struct dahdi_transcode_info *) data, &info, sizeof(info)) ? -EFAULT : 0;
 }
 
-static int zt_tc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data)
+static int dahdi_tc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data)
 {
 	int op;
 	int ret;
-	struct zt_transcoder_channel *ztc = file->private_data;
+	struct dahdi_transcoder_channel *ztc = file->private_data;
 
-	if (cmd != ZT_TRANSCODE_OP)
+	if (cmd != DAHDI_TRANSCODE_OP)
 		return -ENOSYS;
 
 	if (get_user(op, (int *) data))
@@ -337,33 +337,33 @@ static int zt_tc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 		printk("ZT Transcode ioctl op = %d!\n", op);
 
 	switch(op) {
-	case ZT_TCOP_GETINFO:
-		ret = zt_tc_getinfo(data);
+	case DAHDI_TCOP_GETINFO:
+		ret = dahdi_tc_getinfo(data);
 		break;
-	case ZT_TCOP_ALLOCATE:
+	case DAHDI_TCOP_ALLOCATE:
 		/* Reset transcoder, possibly changing who we point to */
 		ret = do_reset(&ztc);
 		file->private_data = ztc;
 		break;
-	case ZT_TCOP_RELEASE:
-		ret = ztc->parent->operation(ztc, ZT_TCOP_RELEASE);
+	case DAHDI_TCOP_RELEASE:
+		ret = ztc->parent->operation(ztc, DAHDI_TCOP_RELEASE);
 		break;
-	case ZT_TCOP_TEST:
-		ret = ztc->parent->operation(ztc, ZT_TCOP_TEST);
+	case DAHDI_TCOP_TEST:
+		ret = ztc->parent->operation(ztc, DAHDI_TCOP_TEST);
 		break;
-	case ZT_TCOP_TRANSCODE:
+	case DAHDI_TCOP_TRANSCODE:
 		if (!ztc->parent->operation)
 			return -EINVAL;
 
-		ztc->tch->status |= ZT_TC_FLAG_BUSY;
-		if (!(ret = ztc->parent->operation(ztc, ZT_TCOP_TRANSCODE))) {
+		ztc->tch->status |= DAHDI_TC_FLAG_BUSY;
+		if (!(ret = ztc->parent->operation(ztc, DAHDI_TCOP_TRANSCODE))) {
 			/* Wait for busy to go away if we're not non-blocking */
 			if (!(file->f_flags & O_NONBLOCK)) {
 				if (!(ret = wait_busy(ztc)))
 					ret = ztc->errorstatus;
 			}
 		} else
-			ztc->tch->status &= ~ZT_TC_FLAG_BUSY;
+			ztc->tch->status &= ~DAHDI_TC_FLAG_BUSY;
 		break;
 	default:
 		ret = -ENOSYS;
@@ -372,9 +372,9 @@ static int zt_tc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 	return ret;
 }
 
-static int zt_tc_mmap(struct file *file, struct vm_area_struct *vma)
+static int dahdi_tc_mmap(struct file *file, struct vm_area_struct *vma)
 {
-	struct zt_transcoder_channel *ztc = file->private_data;
+	struct dahdi_transcoder_channel *ztc = file->private_data;
 	unsigned long physical;
 	int res;
 
@@ -388,20 +388,20 @@ static int zt_tc_mmap(struct file *file, struct vm_area_struct *vma)
 		return -EINVAL;
 	}
 
-	if ((vma->vm_end - vma->vm_start) != sizeof(struct zt_transcode_header)) {
+	if ((vma->vm_end - vma->vm_start) != sizeof(struct dahdi_transcode_header)) {
 		if (debug)
-			printk("zttranscode: Attempted to mmap with size %d != %zd!\n", (int) (vma->vm_end - vma->vm_start), sizeof(struct zt_transcode_header));
+			printk("zttranscode: Attempted to mmap with size %d != %zd!\n", (int) (vma->vm_end - vma->vm_start), sizeof(struct dahdi_transcode_header));
 		return -EINVAL;
 	}
 
 	physical = (unsigned long) virt_to_phys(ztc->tch);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
-	res = remap_pfn_range(vma, vma->vm_start, physical >> PAGE_SHIFT, sizeof(struct zt_transcode_header), PAGE_SHARED);
+	res = remap_pfn_range(vma, vma->vm_start, physical >> PAGE_SHIFT, sizeof(struct dahdi_transcode_header), PAGE_SHARED);
 #else
   #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-	res = remap_page_range(vma->vm_start, physical, sizeof(struct zt_transcode_header), PAGE_SHARED);
+	res = remap_page_range(vma->vm_start, physical, sizeof(struct dahdi_transcode_header), PAGE_SHARED);
   #else
-	res = remap_page_range(vma, vma->vm_start, physical, sizeof(struct zt_transcode_header), PAGE_SHARED);
+	res = remap_page_range(vma, vma->vm_start, physical, sizeof(struct dahdi_transcode_header), PAGE_SHARED);
   #endif
 #endif
 	if (res) {
@@ -416,33 +416,33 @@ static int zt_tc_mmap(struct file *file, struct vm_area_struct *vma)
 	return 0;
 }
 
-static unsigned int zt_tc_poll(struct file *file, struct poll_table_struct *wait_table)
+static unsigned int dahdi_tc_poll(struct file *file, struct poll_table_struct *wait_table)
 {
-	struct zt_transcoder_channel *ztc = file->private_data;
+	struct dahdi_transcoder_channel *ztc = file->private_data;
 
 	if (!ztc)
 		return -EINVAL;
 
 	poll_wait(file, &ztc->ready, wait_table);
-	return ztc->tch->status & ZT_TC_FLAG_BUSY ? 0 : POLLPRI;
+	return ztc->tch->status & DAHDI_TC_FLAG_BUSY ? 0 : POLLPRI;
 }
 
-static struct file_operations __zt_transcode_fops = {
+static struct file_operations __dahdi_transcode_fops = {
 	owner: THIS_MODULE,
 	llseek: NULL,
-	open: zt_tc_open,
-	release: zt_tc_release,
-	ioctl: zt_tc_ioctl,
+	open: dahdi_tc_open,
+	release: dahdi_tc_release,
+	ioctl: dahdi_tc_ioctl,
 	read: NULL,
 	write: NULL,
-	poll: zt_tc_poll,
-	mmap: zt_tc_mmap,
+	poll: dahdi_tc_poll,
+	mmap: dahdi_tc_mmap,
 	flush: NULL,
 	fsync: NULL,
 	fasync: NULL,
 };
 
-static struct zt_chardev transcode_chardev = {
+static struct dahdi_chardev transcode_chardev = {
 	.name = "transcode",
 	.minor = 250,
 };
@@ -451,14 +451,14 @@ int zttranscode_init(void)
 {
 	int res;
 
-	if (zt_transcode_fops) {
-		printk("Whoa, zt_transcode_fops already set?!\n");
+	if (dahdi_transcode_fops) {
+		printk("Whoa, dahdi_transcode_fops already set?!\n");
 		return -EBUSY;
 	}
 
-	zt_transcode_fops = &__zt_transcode_fops;
+	dahdi_transcode_fops = &__dahdi_transcode_fops;
 
-	if ((res = zt_register_chardev(&transcode_chardev)))
+	if ((res = dahdi_register_chardev(&transcode_chardev)))
 		return res;
 
 	printk("Zaptel Transcoder support loaded\n");
@@ -468,9 +468,9 @@ int zttranscode_init(void)
 
 void zttranscode_cleanup(void)
 {
-	zt_unregister_chardev(&transcode_chardev);
+	dahdi_unregister_chardev(&transcode_chardev);
 
-	zt_transcode_fops = NULL;
+	dahdi_transcode_fops = NULL;
 
 	printk("Zaptel Transcoder support unloaded\n");
 }
diff --git a/drivers/dahdi/digits.h b/drivers/dahdi/digits.h
index 9f4ea9b..160fdc7 100644
--- a/drivers/dahdi/digits.h
+++ b/drivers/dahdi/digits.h
@@ -20,28 +20,28 @@
 #ifndef _DIGITS_H
 #define _DIGITS_H
 
-#define DEFAULT_DTMF_LENGTH	100 * ZT_CHUNKSIZE
-#define DEFAULT_MFR1_LENGTH	68 * ZT_CHUNKSIZE
-#define DEFAULT_MFR2_LENGTH	100 * ZT_CHUNKSIZE
-#define	PAUSE_LENGTH		500 * ZT_CHUNKSIZE
+#define DEFAULT_DTMF_LENGTH	100 * DAHDI_CHUNKSIZE
+#define DEFAULT_MFR1_LENGTH	68 * DAHDI_CHUNKSIZE
+#define DEFAULT_MFR2_LENGTH	100 * DAHDI_CHUNKSIZE
+#define	PAUSE_LENGTH		500 * DAHDI_CHUNKSIZE
 
 /* At the end of silence, the tone stops */
-static struct zt_tone dtmf_silence = {
+static struct dahdi_tone dtmf_silence = {
 	.tonesamples = DEFAULT_DTMF_LENGTH,
 };
 
 /* At the end of silence, the tone stops */
-static struct zt_tone mfr1_silence = {
+static struct dahdi_tone mfr1_silence = {
 	.tonesamples = DEFAULT_MFR1_LENGTH,
 };
 
 /* At the end of silence, the tone stops */
-static struct zt_tone mfr2_silence = {
+static struct dahdi_tone mfr2_silence = {
 	.tonesamples = DEFAULT_MFR2_LENGTH,
 };
 
 /* A pause in the dialing */
-static struct zt_tone tone_pause = {
+static struct dahdi_tone tone_pause = {
 	.tonesamples = PAUSE_LENGTH,
 };
 
diff --git a/drivers/dahdi/hpec/hpec_dahdi.h b/drivers/dahdi/hpec/hpec_dahdi.h
index 2f90571..3eddbf2 100644
--- a/drivers/dahdi/hpec/hpec_dahdi.h
+++ b/drivers/dahdi/hpec/hpec_dahdi.h
@@ -23,7 +23,7 @@
 #if !defined(_HPEC_ZAPTEL_H)
 #define _HPEC_ZAPTEL_H
 
-#define ZT_EC_ARRAY_UPDATE
+#define DAHDI_EC_ARRAY_UPDATE
 
 #include "hpec_user.h"
 #include "hpec.h"
@@ -62,7 +62,7 @@ static void memfree(void *ptr)
 static void echo_can_init(void)
 {
 	printk("Zaptel Echo Canceller: Digium High-Performance Echo Canceller\n");
-	hpec_init(logger, debug, ZT_CHUNKSIZE, memalloc, memfree);
+	hpec_init(logger, debug, DAHDI_CHUNKSIZE, memalloc, memfree);
 }
 
 static void echo_can_identify(char *buf, size_t len)
@@ -87,7 +87,7 @@ static inline void echo_can_array_update(struct echo_can_state *ec, short *iref,
 
 DECLARE_MUTEX(alloc_lock);
 
-static int echo_can_create(struct zt_echocanparams *ecp, struct zt_echocanparam *p,
+static int echo_can_create(struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p,
 			   struct echo_can_state **ec)
 {
 	if (ecp->param_count > 0) {
@@ -119,7 +119,7 @@ static int hpec_license_ioctl(unsigned int cmd, unsigned long data)
 	int result = 0;
 
 	switch (cmd) {
-	case ZT_EC_LICENSE_CHALLENGE:
+	case DAHDI_EC_LICENSE_CHALLENGE:
 		if (down_interruptible(&license_lock))
 			return -EINTR;
 		memset(&challenge, 0, sizeof(challenge));
@@ -129,7 +129,7 @@ static int hpec_license_ioctl(unsigned int cmd, unsigned long data)
 			result = -EFAULT;
 		up(&license_lock);
 		return result;
-	case ZT_EC_LICENSE_RESPONSE:
+	case DAHDI_EC_LICENSE_RESPONSE:
 		if (down_interruptible(&license_lock))
 			return -EINTR;
 		if (copy_from_user(&license, (unsigned char *) data, sizeof(license)))
diff --git a/drivers/dahdi/hpec/hpec_user.h b/drivers/dahdi/hpec/hpec_user.h
index bf006eb..fcaae3d 100644
--- a/drivers/dahdi/hpec/hpec_user.h
+++ b/drivers/dahdi/hpec/hpec_user.h
@@ -33,8 +33,8 @@ struct hpec_license {
 	__u8 response[16];
 };
 
-#define ZT_EC_LICENSE_CHALLENGE _IOR(ZT_CODE, 60, struct hpec_challenge)
-#define ZT_EC_LICENSE_RESPONSE  _IOW(ZT_CODE, 61, struct hpec_license)
+#define DAHDI_EC_LICENSE_CHALLENGE _IOR(DAHDI_CODE, 60, struct hpec_challenge)
+#define DAHDI_EC_LICENSE_RESPONSE  _IOW(DAHDI_CODE, 61, struct hpec_license)
 
 #endif /* !defined(_HPEC_USER_H) */
 
diff --git a/drivers/dahdi/kb1ec.h b/drivers/dahdi/kb1ec.h
index cfafdf6..caeefbd 100644
--- a/drivers/dahdi/kb1ec.h
+++ b/drivers/dahdi/kb1ec.h
@@ -521,7 +521,7 @@ static inline short echo_can_update(struct echo_can_state *ec, short iref, short
 	return u;
 }
 
-static int echo_can_create(struct zt_echocanparams *ecp, struct zt_echocanparam *p,
+static int echo_can_create(struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p,
 			   struct echo_can_state **ec)
 {
 	int maxy;
diff --git a/drivers/dahdi/mg2ec.h b/drivers/dahdi/mg2ec.h
index 1d4189b..fce1d03 100644
--- a/drivers/dahdi/mg2ec.h
+++ b/drivers/dahdi/mg2ec.h
@@ -642,7 +642,7 @@ static inline short echo_can_update(struct echo_can_state *ec, short iref, short
 	return u;
 }
 
-static int echo_can_create(struct zt_echocanparams *ecp, struct zt_echocanparam *p,
+static int echo_can_create(struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p,
 			   struct echo_can_state **ec)
 {
 	int maxy;
diff --git a/drivers/dahdi/pciradio.c b/drivers/dahdi/pciradio.c
index 5dab834..82c8a39 100644
--- a/drivers/dahdi/pciradio.c
+++ b/drivers/dahdi/pciradio.c
@@ -106,8 +106,8 @@ With driver:	303826  (1.5 %)
 #define RAD_CTCSS_ACQUIRE_TIME 10
 #define RAD_CTCSS_TALKOFF_TIME 1000
 
-#define ZT_RADPAR_CTCSSACQUIRETIME 18 /* DEBUG only, this belongs in zaptel.h */
-#define ZT_RADPAR_CTCSSTALKOFFTIME 19 /* DEBUG only, this belongs in zaptel.h */
+#define DAHDI_RADPAR_CTCSSACQUIRETIME 18 /* DEBUG only, this belongs in zaptel.h */
+#define DAHDI_RADPAR_CTCSSTALKOFFTIME 19 /* DEBUG only, this belongs in zaptel.h */
 
 /*
 * MX828 Commands
@@ -151,7 +151,7 @@ struct encdec
 
 struct pciradio {
 	struct pci_dev *dev;
-	struct zt_span span;
+	struct dahdi_span span;
 	unsigned char ios;
 	int usecount;
 	unsigned int intcount;
@@ -204,7 +204,7 @@ struct pciradio {
 #define	RADMODE_IGNORECT 16
 #define	RADMODE_NOENCODE 32
 	unsigned char corthresh[NUM_CHANS];
-	struct zt_chan chans[NUM_CHANS];
+	struct dahdi_chan chans[NUM_CHANS];
 	unsigned char mx828_addr;
 	struct encdec encdec;
 	unsigned long lastremcmd;
@@ -690,12 +690,12 @@ static inline void pciradio_transmitprep(struct pciradio *rad, unsigned char int
 		/* Write is at interrupt address.  Start writing from normal offset */
 		writechunk = rad->writechunk;
 	else 
-		writechunk = rad->writechunk + ZT_CHUNKSIZE;
+		writechunk = rad->writechunk + DAHDI_CHUNKSIZE;
 
 	/* Calculate Transmission */
-	zt_transmit(&rad->span);
+	dahdi_transmit(&rad->span);
 
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		/* Send a sample, as a 32-bit word */
 		writechunk[x] = 0;
 		writechunk[x] |= (rad->chans[0].writechunk[x] << 24);
@@ -711,20 +711,20 @@ static inline void pciradio_receiveprep(struct pciradio *rad, unsigned char ints
 	int x;
 
 	if (ints & 0x08)
-		readchunk = rad->readchunk + ZT_CHUNKSIZE;
+		readchunk = rad->readchunk + DAHDI_CHUNKSIZE;
 	else
 		/* Read is at interrupt address.  Valid data is available at normal offset */
 		readchunk = rad->readchunk;
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		rad->chans[0].readchunk[x] = (readchunk[x] >> 24) & 0xff;
 		rad->chans[1].readchunk[x] = (readchunk[x] >> 16) & 0xff;
 		rad->chans[2].readchunk[x] = (readchunk[x] >> 8) & 0xff;
 		rad->chans[3].readchunk[x] = (readchunk[x]) & 0xff;
 	}
 	for (x=0;x<rad->nchans;x++) {
-		zt_ec_chunk(&rad->chans[x], rad->chans[x].readchunk, rad->chans[x].writechunk);
+		dahdi_ec_chunk(&rad->chans[x], rad->chans[x].readchunk, rad->chans[x].writechunk);
 	}
-	zt_receive(&rad->span);
+	dahdi_receive(&rad->span);
 }
 
 static void pciradio_stop_dma(struct pciradio *rad);
@@ -931,10 +931,10 @@ ZAP_IRQ_HANDLER(pciradio_interrupt)
 								else
 								    printk("Chan %d got rx\n",x + 1);
 							}
-						    zt_hooksig(&rad->chans[x],ZT_RXSIG_OFFHOOK);
+						    dahdi_hooksig(&rad->chans[x],DAHDI_RXSIG_OFFHOOK);
 						} else {
 						    if (debug) printk("Chan %d lost rx\n",x + 1);
-						    zt_hooksig(&rad->chans[x],ZT_RXSIG_ONHOOK);
+						    dahdi_hooksig(&rad->chans[x],DAHDI_RXSIG_ONHOOK);
 						}
 						rad->encdec.req[x] = 1; 
 					}
@@ -981,45 +981,45 @@ ZAP_IRQ_HANDLER(pciradio_interrupt)
 	
 }
 
-static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
+static int pciradio_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data)
 {
 	int i,mycode;
 	unsigned long flags;
 	unsigned char byte1,byte2,mask;
 	union {
-		struct zt_radio_stat s;
-		struct zt_radio_param p;
+		struct dahdi_radio_stat s;
+		struct dahdi_radio_param p;
 	} stack;
 
 	struct pciradio *rad = chan->pvt;
 	DECLARE_WAIT_QUEUE_HEAD(mywait);
 
 	switch (cmd) {
-	case ZT_RADIO_GETPARAM:
-		if (copy_from_user(&stack.p,(struct zt_radio_param *)data,sizeof(struct zt_radio_param))) return -EFAULT;
+	case DAHDI_RADIO_GETPARAM:
+		if (copy_from_user(&stack.p,(struct dahdi_radio_param *)data,sizeof(struct dahdi_radio_param))) return -EFAULT;
 		spin_lock_irqsave(&rad->lock,flags);
 		stack.p.data = 0; /* start with 0 value in output */
 		switch(stack.p.radpar) {
-		case ZT_RADPAR_INVERTCOR:
+		case DAHDI_RADPAR_INVERTCOR:
 			if (rad->radmode[chan->chanpos - 1] & RADMODE_INVERTCOR)
 				stack.p.data = 1;
 			break;
-		case ZT_RADPAR_IGNORECOR:
+		case DAHDI_RADPAR_IGNORECOR:
 			if (rad->radmode[chan->chanpos - 1] & RADMODE_IGNORECOR)
 				stack.p.data = 1;
 			break;
-		case ZT_RADPAR_IGNORECT:
+		case DAHDI_RADPAR_IGNORECT:
 			if (rad->radmode[chan->chanpos - 1] & RADMODE_IGNORECT)
 				stack.p.data = 1;
 			break;
-		case ZT_RADPAR_NOENCODE:
+		case DAHDI_RADPAR_NOENCODE:
 			if (rad->radmode[chan->chanpos - 1] & RADMODE_NOENCODE)
 				stack.p.data = 1;
 			break;
-		case ZT_RADPAR_CORTHRESH:
+		case DAHDI_RADPAR_CORTHRESH:
 			stack.p.data = rad->corthresh[chan->chanpos - 1] & 7;
 			break;
-		case ZT_RADPAR_EXTRXTONE:
+		case DAHDI_RADPAR_EXTRXTONE:
 			if (rad->radmode[chan->chanpos - 1] & RADMODE_EXTTONE)
 			{
 				stack.p.data = 1;
@@ -1029,10 +1029,10 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 				}
 			}
 			break;
-		case ZT_RADPAR_NUMTONES:
+		case DAHDI_RADPAR_NUMTONES:
 			stack.p.data = NUM_CODES;
 			break;
-		case ZT_RADPAR_RXTONE:
+		case DAHDI_RADPAR_RXTONE:
 			if ((stack.p.index < 1) || (stack.p.index > NUM_CODES)) {
 				spin_unlock_irqrestore(&rad->lock,flags);
 				return -EINVAL;
@@ -1040,14 +1040,14 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			stack.p.data = 
 				cttable_rx[rad->rxcode[chan->chanpos - 1][stack.p.index] & 0x7fff].code;
 			break;
-		case ZT_RADPAR_RXTONECLASS:
+		case DAHDI_RADPAR_RXTONECLASS:
 			if ((stack.p.index < 1) || (stack.p.index > NUM_CODES)) {
 				spin_unlock_irqrestore(&rad->lock,flags);
 				return -EINVAL;
 			}
 			stack.p.data = rad->rxclass[chan->chanpos - 1][stack.p.index] & 0xffff;
 			break;
-		case ZT_RADPAR_TXTONE:
+		case DAHDI_RADPAR_TXTONE:
 			if (stack.p.index > NUM_CODES) {
 				spin_unlock_irqrestore(&rad->lock,flags);
 				return -EINVAL;
@@ -1057,34 +1057,34 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			if (rad->txcode[chan->chanpos - 1][stack.p.index] & 0x8000)
 				stack.p.data |= 0x8000;
 			break;
-		case ZT_RADPAR_DEBOUNCETIME:
+		case DAHDI_RADPAR_DEBOUNCETIME:
 			stack.p.data = rad->debouncetime[chan->chanpos - 1];
 			break;
 
-		case ZT_RADPAR_CTCSSACQUIRETIME:
+		case DAHDI_RADPAR_CTCSSACQUIRETIME:
 			stack.p.data = rad->ctcssacquiretime[chan->chanpos - 1];
 			break;
 
-		case ZT_RADPAR_CTCSSTALKOFFTIME:
+		case DAHDI_RADPAR_CTCSSTALKOFFTIME:
 			stack.p.data = rad->ctcsstalkofftime[chan->chanpos - 1];
 			break;
 
-		case ZT_RADPAR_BURSTTIME:
+		case DAHDI_RADPAR_BURSTTIME:
 			stack.p.data = rad->bursttime[chan->chanpos - 1];
 			break;
-		case ZT_RADPAR_UIODATA:
+		case DAHDI_RADPAR_UIODATA:
 			stack.p.data = 0;
 			byte1 = __pciradio_getcreg(rad,8);
 			if (byte1 & (1 << (chan->chanpos - 1))) stack.p.data |= 1;
 			if (byte1 & (1 << (chan->chanpos + 3))) stack.p.data |= 2;
 			break;
-		case ZT_RADPAR_UIOMODE:
+		case DAHDI_RADPAR_UIOMODE:
 			stack.p.data = 0;
 			byte1 = __pciradio_getcreg(rad,0xe);
 			if (byte1 & (1 << (chan->chanpos - 1))) stack.p.data |= 1;
 			if (byte1 & (1 << (chan->chanpos + 3))) stack.p.data |= 2;
 			break;
-		case ZT_RADPAR_REMMODE:
+		case DAHDI_RADPAR_REMMODE:
 			stack.p.data = rad->remmode[chan->chanpos - 1];
 			break;
 		default:
@@ -1092,37 +1092,37 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			return -EINVAL;
 		}
 		spin_unlock_irqrestore(&rad->lock,flags);
-		if (copy_to_user((struct zt_radio_param *)data,&stack.p,sizeof(struct zt_radio_param))) return -EFAULT;
+		if (copy_to_user((struct dahdi_radio_param *)data,&stack.p,sizeof(struct dahdi_radio_param))) return -EFAULT;
 		break;
-	case ZT_RADIO_SETPARAM:
-		if (copy_from_user(&stack.p,(struct zt_radio_param *)data,sizeof(struct zt_radio_param))) return -EFAULT;
+	case DAHDI_RADIO_SETPARAM:
+		if (copy_from_user(&stack.p,(struct dahdi_radio_param *)data,sizeof(struct dahdi_radio_param))) return -EFAULT;
 		spin_lock_irqsave(&rad->lock,flags);
 		switch(stack.p.radpar) {
-		case ZT_RADPAR_INVERTCOR:
+		case DAHDI_RADPAR_INVERTCOR:
 			if (stack.p.data)
 				rad->radmode[chan->chanpos - 1] |= RADMODE_INVERTCOR;
 			else
 				rad->radmode[chan->chanpos - 1] &= ~RADMODE_INVERTCOR;
 			break;
-		case ZT_RADPAR_IGNORECOR:
+		case DAHDI_RADPAR_IGNORECOR:
 			if (stack.p.data)
 				rad->radmode[chan->chanpos - 1] |= RADMODE_IGNORECOR;
 			else
 				rad->radmode[chan->chanpos - 1] &= ~RADMODE_IGNORECOR;
 			break;
-		case ZT_RADPAR_IGNORECT:
+		case DAHDI_RADPAR_IGNORECT:
 			if (stack.p.data)
 				rad->radmode[chan->chanpos - 1] |= RADMODE_IGNORECT;
 			else
 				rad->radmode[chan->chanpos - 1] &= ~RADMODE_IGNORECT;
 			break;
-		case ZT_RADPAR_NOENCODE:
+		case DAHDI_RADPAR_NOENCODE:
 			if (stack.p.data)
 				rad->radmode[chan->chanpos - 1] |= RADMODE_NOENCODE;
 			else
 				rad->radmode[chan->chanpos - 1] &= ~RADMODE_NOENCODE;
 			break;
-		case ZT_RADPAR_CORTHRESH:
+		case DAHDI_RADPAR_CORTHRESH:
 			if ((stack.p.data < 0) || (stack.p.data > 7)) {
 				spin_unlock_irqrestore(&rad->lock,flags);
 				return -EINVAL;
@@ -1133,7 +1133,7 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			mx828_command_wait(rad,chan->chanpos - 1, MX828_GEN_CTRL, &byte1, &byte2);
 			spin_lock_irqsave(&rad->lock,flags);
 			break;
-		case ZT_RADPAR_EXTRXTONE:
+		case DAHDI_RADPAR_EXTRXTONE:
 			if (stack.p.data)
 				rad->radmode[chan->chanpos - 1] |= RADMODE_EXTTONE;
 			else
@@ -1143,7 +1143,7 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			else
 				rad->radmode[chan->chanpos - 1] &= ~RADMODE_EXTINVERT;
 			break;
-		case ZT_RADPAR_INITTONE:
+		case DAHDI_RADPAR_INITTONE:
 			for(i = 0; i <= NUM_CODES; i++)
 			{
 				rad->rxcode[chan->chanpos - 1][i] = 0;
@@ -1163,7 +1163,7 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			}
 			spin_lock_irqsave(&rad->lock,flags);
 			break;
-		case ZT_RADPAR_RXTONE:
+		case DAHDI_RADPAR_RXTONE:
 			if (!stack.p.index) /* if RX DCS mode */
 			{
 				if ((stack.p.data < 0) || (stack.p.data > 777)) {
@@ -1198,14 +1198,14 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			rad->rxcode[chan->chanpos - 1][0] = 0;
 			rad->encdec.req[chan->chanpos - 1] = 1;
 			break;
-		case ZT_RADPAR_RXTONECLASS:
+		case DAHDI_RADPAR_RXTONECLASS:
 			if ((stack.p.index < 1) || (stack.p.index > NUM_CODES)) {
 				spin_unlock_irqrestore(&rad->lock,flags);
 				return -EINVAL;
 			}
 			rad->rxclass[chan->chanpos - 1][stack.p.index] = stack.p.data & 0xffff;
 			break;
-		case ZT_RADPAR_TXTONE:
+		case DAHDI_RADPAR_TXTONE:
 			if (stack.p.index > NUM_CODES) {
 				spin_unlock_irqrestore(&rad->lock,flags);
 				return -EINVAL;
@@ -1222,22 +1222,22 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			rad->txcode[chan->chanpos - 1][stack.p.index] = mycode;
 			rad->encdec.req[chan->chanpos - 1] = 1;
 			break;
-		case ZT_RADPAR_DEBOUNCETIME:
+		case DAHDI_RADPAR_DEBOUNCETIME:
 			rad->debouncetime[chan->chanpos - 1] = stack.p.data;
 			break;
 
-		case ZT_RADPAR_CTCSSACQUIRETIME:
+		case DAHDI_RADPAR_CTCSSACQUIRETIME:
 			rad->ctcssacquiretime[chan->chanpos - 1] = stack.p.data;
 			break;
 
-		case ZT_RADPAR_CTCSSTALKOFFTIME:
+		case DAHDI_RADPAR_CTCSSTALKOFFTIME:
 			rad->ctcsstalkofftime[chan->chanpos - 1] = stack.p.data;
 			break;
 
-		case ZT_RADPAR_BURSTTIME:
+		case DAHDI_RADPAR_BURSTTIME:
 			rad->bursttime[chan->chanpos - 1] = stack.p.data;
 			break;
-		case ZT_RADPAR_UIODATA:
+		case DAHDI_RADPAR_UIODATA:
 			byte1 = __pciradio_getcreg(rad,8);
 			byte1 &= ~(1 << (chan->chanpos - 1));
 			byte1 &= ~(1 << (chan->chanpos + 3));
@@ -1245,7 +1245,7 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			if (stack.p.data & 2) byte1 |= (1 << (chan->chanpos + 3));
 			__pciradio_setcreg(rad,8,byte1);
 			break;
-		case ZT_RADPAR_UIOMODE:
+		case DAHDI_RADPAR_UIOMODE:
 			byte1 = __pciradio_getcreg(rad,0xe);
 			byte1 &= ~(1 << (chan->chanpos - 1));
 			byte1 &= ~(1 << (chan->chanpos + 3));
@@ -1253,18 +1253,18 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			if (stack.p.data & 2) byte1 |= (1 << (chan->chanpos + 3));
 			__pciradio_setcreg(rad,0xe,byte1);
 			break;
-		case ZT_RADPAR_REMMODE:
+		case DAHDI_RADPAR_REMMODE:
 			rad->remmode[chan->chanpos - 1] = stack.p.data;
 			break;
-		case ZT_RADPAR_REMCOMMAND:
+		case DAHDI_RADPAR_REMCOMMAND:
 			/* if no remote mode, return an error */
-			if (rad->remmode[chan->chanpos - 1] == ZT_RADPAR_REM_NONE)
+			if (rad->remmode[chan->chanpos - 1] == DAHDI_RADPAR_REM_NONE)
 			{
 				spin_unlock_irqrestore(&rad->lock,flags);
 				return -EINVAL;
 			}
 			i = 0;
-			if (rad->remmode[chan->chanpos - 1] == ZT_RADPAR_REM_RBI1)
+			if (rad->remmode[chan->chanpos - 1] == DAHDI_RADPAR_REM_RBI1)
 			{
 				/* set UIOA and UIOB for output */
 				byte1 = __pciradio_getcreg(rad,0xe);
@@ -1337,7 +1337,7 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 				rad->rxbuf[rad->rxindex] = 0;
 				if ((rad->rxindex < stack.p.data) &&
 				  (rad->srxtimer < SRX_TIMEOUT) &&
-				    ((rad->remmode[chan->chanpos - 1] == ZT_RADPAR_REM_SERIAL) ||
+				    ((rad->remmode[chan->chanpos - 1] == DAHDI_RADPAR_REM_SERIAL) ||
 					(!strchr((char *)rad->rxbuf,'\r'))))
 				{
 					spin_unlock_irqrestore(&rad->lock,flags);
@@ -1354,7 +1354,7 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 				break;
 			}
 			/* wait for done if in SERIAL_ASCII mode, or if no Rx aftwards */
-			if ((rad->remmode[chan->chanpos - 1] == ZT_RADPAR_REM_SERIAL_ASCII) ||
+			if ((rad->remmode[chan->chanpos - 1] == DAHDI_RADPAR_REM_SERIAL_ASCII) ||
 				(!stack.p.data))
 			{			
 				/* wait for TX to be done if not already */
@@ -1369,9 +1369,9 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 			}
 			rad->remote_locked = 0;
 			spin_unlock_irqrestore(&rad->lock,flags);
-			if (rad->remmode[chan->chanpos - 1] == ZT_RADPAR_REM_SERIAL_ASCII)
+			if (rad->remmode[chan->chanpos - 1] == DAHDI_RADPAR_REM_SERIAL_ASCII)
 				interruptible_sleep_on_timeout(&mywait,100);
-			if (copy_to_user((struct zt_radio_stat *)data,&stack.p,sizeof(struct zt_radio_param))) return -EFAULT;
+			if (copy_to_user((struct dahdi_radio_stat *)data,&stack.p,sizeof(struct dahdi_radio_param))) return -EFAULT;
 			return 0;
 		default:
 			spin_unlock_irqrestore(&rad->lock,flags);
@@ -1379,14 +1379,14 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 		}
 		spin_unlock_irqrestore(&rad->lock,flags);
 		break;
-	case ZT_RADIO_GETSTAT:
+	case DAHDI_RADIO_GETSTAT:
 		spin_lock_irqsave(&rad->lock,flags);
 		/* start with clean object */
-		memset(&stack.s,0,sizeof(struct zt_radio_stat));
+		memset(&stack.s,0,sizeof(struct dahdi_radio_stat));
 		/* if we have rx */
 		if (rad->gotrx[chan->chanpos - 1])
 		{
-			stack.s.radstat |= ZT_RADSTAT_RX;
+			stack.s.radstat |= DAHDI_RADSTAT_RX;
 			if (rad->rxcode[chan->chanpos - 1][0])
 			    stack.s.ctcode_rx = 
 				dcstable[rad->rxcode[chan->chanpos - 1][0]].code | 0x8000;
@@ -1402,8 +1402,8 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 		{
 			unsigned short x,myindex;
 
-			stack.s.radstat |= ZT_RADSTAT_TX;
-			stack.s.radstat |= ZT_RADSTAT_TX;
+			stack.s.radstat |= DAHDI_RADSTAT_TX;
+			stack.s.radstat |= DAHDI_RADSTAT_TX;
 
 			myindex = 0;
 			if ((!rad->rxcode[chan->chanpos - 1][0]) 
@@ -1418,17 +1418,17 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 		}
 
 		if (rad->radmode[chan->chanpos - 1] & RADMODE_IGNORECOR)
-			stack.s.radstat |= ZT_RADSTAT_IGNCOR;
+			stack.s.radstat |= DAHDI_RADSTAT_IGNCOR;
 		if (rad->radmode[chan->chanpos - 1] & RADMODE_IGNORECT)
-			stack.s.radstat |= ZT_RADSTAT_IGNCT;
+			stack.s.radstat |= DAHDI_RADSTAT_IGNCT;
 		if (rad->radmode[chan->chanpos - 1] & RADMODE_NOENCODE)
-			stack.s.radstat |= ZT_RADSTAT_NOENCODE;
+			stack.s.radstat |= DAHDI_RADSTAT_NOENCODE;
 		if (rad->gotcor[chan->chanpos - 1])
-			stack.s.radstat |= ZT_RADSTAT_RXCOR;
+			stack.s.radstat |= DAHDI_RADSTAT_RXCOR;
 		if (rad->gotct[chan->chanpos - 1])
-			stack.s.radstat |= ZT_RADSTAT_RXCT;
+			stack.s.radstat |= DAHDI_RADSTAT_RXCT;
 		spin_unlock_irqrestore(&rad->lock,flags);
-		if (copy_to_user((struct zt_radio_stat *)data,&stack.s,sizeof(struct zt_radio_stat))) return -EFAULT;
+		if (copy_to_user((struct dahdi_radio_stat *)data,&stack.s,sizeof(struct dahdi_radio_stat))) return -EFAULT;
 		break;
 	default:
 		return -ENOTTY;
@@ -1437,7 +1437,7 @@ static int pciradio_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long
 
 }
 
-static int pciradio_open(struct zt_chan *chan)
+static int pciradio_open(struct dahdi_chan *chan)
 {
 	struct pciradio *rad = chan->pvt;
 	if (rad->dead)
@@ -1449,14 +1449,14 @@ static int pciradio_open(struct zt_chan *chan)
 	return 0;
 }
 
-static int pciradio_watchdog(struct zt_span *span, int event)
+static int pciradio_watchdog(struct dahdi_span *span, int event)
 {
 	printk("PCI RADIO: Restarting DMA\n");
 	pciradio_restart_dma(span->pvt);
 	return 0;
 }
 
-static int pciradio_close(struct zt_chan *chan)
+static int pciradio_close(struct dahdi_chan *chan)
 {
 	struct pciradio *rad = chan->pvt;
 	rad->usecount--;
@@ -1469,16 +1469,16 @@ static int pciradio_close(struct zt_chan *chan)
 	return 0;
 }
 
-static int pciradio_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
+static int pciradio_hooksig(struct dahdi_chan *chan, dahdi_txsig_t txsig)
 {
 	struct pciradio *rad = chan->pvt;
 
 	switch(txsig) {
-	case ZT_TXSIG_START:
-	case ZT_TXSIG_OFFHOOK:
+	case DAHDI_TXSIG_START:
+	case DAHDI_TXSIG_OFFHOOK:
 		rad->gottx[chan->chanpos - 1] = 1;
 		break;
-	case ZT_TXSIG_ONHOOK:
+	case DAHDI_TXSIG_ONHOOK:
 		rad->gottx[chan->chanpos - 1] = 0;
 		break;
 	default:
@@ -1497,10 +1497,10 @@ static int pciradio_initialize(struct pciradio *rad)
 	/* Zapata stuff */
 	sprintf(rad->span.name, "PCIRADIO/%d", rad->pos);
 	sprintf(rad->span.desc, "Board %d", rad->pos + 1);
-	rad->span.deflaw = ZT_LAW_MULAW;
+	rad->span.deflaw = DAHDI_LAW_MULAW;
 	for (x=0;x<rad->nchans;x++) {
 		sprintf(rad->chans[x].name, "PCIRADIO/%d/%d", rad->pos, x);
-		rad->chans[x].sigcap = ZT_SIG_SF | ZT_SIG_EM;
+		rad->chans[x].sigcap = DAHDI_SIG_SF | DAHDI_SIG_EM;
 		rad->chans[x].chanpos = x+1;
 		rad->chans[x].pvt = rad;
 		rad->debouncetime[x] = RAD_GOTRX_DEBOUNCE_TIME;
@@ -1512,13 +1512,13 @@ static int pciradio_initialize(struct pciradio *rad)
 	rad->span.hooksig = pciradio_hooksig;
 	rad->span.open = pciradio_open;
 	rad->span.close = pciradio_close;
-	rad->span.flags = ZT_FLAG_RBS;
+	rad->span.flags = DAHDI_FLAG_RBS;
 	rad->span.ioctl = pciradio_ioctl;
 	rad->span.watchdog = pciradio_watchdog;
 	init_waitqueue_head(&rad->span.maintq);
 
 	rad->span.pvt = rad;
-	if (zt_register(&rad->span, 0)) {
+	if (dahdi_register(&rad->span, 0)) {
 		printk("Unable to register span with zaptel\n");
 		return -1;
 	}
@@ -1645,12 +1645,12 @@ unsigned long endjif;
 
 	/* Setup DMA Addresses */
 	outl(rad->writedma,                    rad->ioaddr + RAD_DMAWS);		/* Write start */
-	outl(rad->writedma + ZT_CHUNKSIZE * 4 - 4, rad->ioaddr + RAD_DMAWI);		/* Middle (interrupt) */
-	outl(rad->writedma + ZT_CHUNKSIZE * 8 - 4, rad->ioaddr + RAD_DMAWE);			/* End */
+	outl(rad->writedma + DAHDI_CHUNKSIZE * 4 - 4, rad->ioaddr + RAD_DMAWI);		/* Middle (interrupt) */
+	outl(rad->writedma + DAHDI_CHUNKSIZE * 8 - 4, rad->ioaddr + RAD_DMAWE);			/* End */
 	
 	outl(rad->readdma,                    	 rad->ioaddr + RAD_DMARS);	/* Read start */
-	outl(rad->readdma + ZT_CHUNKSIZE * 4 - 4, 	 rad->ioaddr + RAD_DMARI);	/* Middle (interrupt) */
-	outl(rad->readdma + ZT_CHUNKSIZE * 8 - 4, rad->ioaddr + RAD_DMARE);	/* End */
+	outl(rad->readdma + DAHDI_CHUNKSIZE * 4 - 4, 	 rad->ioaddr + RAD_DMARI);	/* Middle (interrupt) */
+	outl(rad->readdma + DAHDI_CHUNKSIZE * 8 - 4, rad->ioaddr + RAD_DMARE);	/* End */
 	
 	/* Clear interrupts */
 	outb(0xff, rad->ioaddr + RAD_INTSTAT);
@@ -1759,7 +1759,7 @@ static int __devinit pciradio_init_one(struct pci_dev *pdev, const struct pci_de
 
 			/* Allocate enough memory for two zt chunks, receive and transmit.  Each sample uses
 			   32 bits.  Allocate an extra set just for control too */
-			rad->writechunk = pci_alloc_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, &rad->writedma);
+			rad->writechunk = pci_alloc_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, &rad->writedma);
 			if (!rad->writechunk) {
 				printk("pciradio: Unable to allocate DMA-able memory\n");
 				if (rad->freeregion)
@@ -1767,8 +1767,8 @@ static int __devinit pciradio_init_one(struct pci_dev *pdev, const struct pci_de
 				return -ENOMEM;
 			}
 
-			rad->readchunk = rad->writechunk + ZT_MAX_CHUNKSIZE * 2;	/* in doublewords */
-			rad->readdma = rad->writedma + ZT_MAX_CHUNKSIZE * 8;		/* in bytes */
+			rad->readchunk = rad->writechunk + DAHDI_MAX_CHUNKSIZE * 2;	/* in doublewords */
+			rad->readdma = rad->writedma + DAHDI_MAX_CHUNKSIZE * 8;		/* in bytes */
 
 			if (pciradio_initialize(rad)) {
 				printk("pciradio: Unable to intialize\n");
@@ -1782,7 +1782,7 @@ static int __devinit pciradio_init_one(struct pci_dev *pdev, const struct pci_de
 				free_irq(pdev->irq, rad);
 				if (rad->freeregion)
 					release_region(rad->ioaddr, 0xff);
-				pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)rad->writechunk, rad->writedma);
+				pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)rad->writechunk, rad->writedma);
 				kfree(rad);
 				return -EIO;
 			}
@@ -1806,9 +1806,9 @@ static int __devinit pciradio_init_one(struct pci_dev *pdev, const struct pci_de
 				free_irq(pdev->irq, rad);
 				if (rad->freeregion)
 					release_region(rad->ioaddr, 0xff);
-				pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)rad->writechunk, rad->writedma);
+				pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)rad->writechunk, rad->writedma);
 				pci_set_drvdata(pdev, NULL);
-				zt_unregister(&rad->span);
+				dahdi_unregister(&rad->span);
 				kfree(rad);
 				return -EIO;
 
@@ -1818,7 +1818,7 @@ static int __devinit pciradio_init_one(struct pci_dev *pdev, const struct pci_de
 				printk("pciradio: Unable to request IRQ %d\n", pdev->irq);
 				if (rad->freeregion)
 					release_region(rad->ioaddr, 0xff);
-				pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)rad->writechunk, rad->writedma);
+				pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)rad->writechunk, rad->writedma);
 				pci_set_drvdata(pdev, NULL);
 				kfree(rad);
 				return -EIO;
@@ -1827,7 +1827,7 @@ static int __devinit pciradio_init_one(struct pci_dev *pdev, const struct pci_de
 			/* Enable interrupts */
 			pciradio_enable_interrupts(rad);
 			/* Initialize Write/Buffers to all blank data */
-			memset((void *)rad->writechunk,0,ZT_MAX_CHUNKSIZE * 2 * 2 * 4);
+			memset((void *)rad->writechunk,0,DAHDI_MAX_CHUNKSIZE * 2 * 2 * 4);
 
 			/* Start DMA */
 			pciradio_start_dma(rad);
@@ -1841,7 +1841,7 @@ static int __devinit pciradio_init_one(struct pci_dev *pdev, const struct pci_de
 
 static void pciradio_release(struct pciradio *rad)
 {
-	zt_unregister(&rad->span);
+	dahdi_unregister(&rad->span);
 	if (rad->freeregion)
 		release_region(rad->ioaddr, 0xff);
 	kfree(rad);
@@ -1861,7 +1861,7 @@ static void __devexit pciradio_remove_one(struct pci_dev *pdev)
 		pciradio_disable_interrupts(rad);
 		
 		/* Immediately free resources */
-		pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)rad->writechunk, rad->writedma);
+		pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)rad->writechunk, rad->writedma);
 		free_irq(pdev->irq, rad);
 
 		/* Reset PCI chip and registers */
diff --git a/drivers/dahdi/sec-2.h b/drivers/dahdi/sec-2.h
index 94ce6ab..1759606 100644
--- a/drivers/dahdi/sec-2.h
+++ b/drivers/dahdi/sec-2.h
@@ -126,7 +126,7 @@ static void echo_can_shutdown(void)
 /* #define MIN_TX_POWER_FOR_ADAPTION 4096
 #define MIN_RX_POWER_FOR_ADAPTION 64 */
 
-static int echo_can_create(struct zt_echocanparams *ecp, struct zt_echocanparam *p,
+static int echo_can_create(struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p,
 			   struct echo_can_state **ec)
 {
 	size_t size;
diff --git a/drivers/dahdi/sec.h b/drivers/dahdi/sec.h
index be31807..f15b681 100644
--- a/drivers/dahdi/sec.h
+++ b/drivers/dahdi/sec.h
@@ -130,7 +130,7 @@ static int16_t echo_can_update(struct echo_can_state *ec, int16_t tx, int16_t rx
 #define MIN_RX_POWER_FOR_ADAPTION   64
 */
 
-static int echo_can_create(struct zt_echocanparams *ecp, struct zt_echocanparam *p,
+static int echo_can_create(struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p,
 			   struct echo_can_state **ec)
 {
 	size_t size;
diff --git a/drivers/dahdi/tor2.c b/drivers/dahdi/tor2.c
index e12dfa8..2863363 100644
--- a/drivers/dahdi/tor2.c
+++ b/drivers/dahdi/tor2.c
@@ -101,9 +101,9 @@ struct tor2 {
 	unsigned long xilinx8_region;	/* 8 bit Region allocated to Xilinx */
 	unsigned long xilinx8_len;	/* Length of 8 bit Xilinx region */
 	volatile unsigned char *mem8;	/* Virtual representation of 8 bit Xilinx memory area */
-	struct zt_span spans[SPANS_PER_CARD];		/* Spans */
+	struct dahdi_span spans[SPANS_PER_CARD];		/* Spans */
 	struct tor2_span tspans[SPANS_PER_CARD];	/* Span data */
-	struct zt_chan *chans[SPANS_PER_CARD];		/* Pointers to blocks of 24(30/31) contiguous zt_chans for each span */
+	struct dahdi_chan *chans[SPANS_PER_CARD];		/* Pointers to blocks of 24(30/31) contiguous dahdi_chans for each span */
 	struct tor2_chan tchans[32 * SPANS_PER_CARD];	/* Channel user data */
 	unsigned char txsigs[SPANS_PER_CARD][16];	/* Copy of tx sig registers */
 	int loopupcnt[SPANS_PER_CARD];	/* loop up code counter */
@@ -111,8 +111,8 @@ struct tor2 {
 	int spansstarted;		/* number of spans started */
 	spinlock_t lock;		/* lock context */
 	unsigned char leds;		/* copy of LED register */
-	unsigned char ec_chunk1[SPANS_PER_CARD][32][ZT_CHUNKSIZE]; /* first EC chunk buffer */
-	unsigned char ec_chunk2[SPANS_PER_CARD][32][ZT_CHUNKSIZE]; /* second EC chunk buffer */
+	unsigned char ec_chunk1[SPANS_PER_CARD][32][DAHDI_CHUNKSIZE]; /* first EC chunk buffer */
+	unsigned char ec_chunk2[SPANS_PER_CARD][32][DAHDI_CHUNKSIZE]; /* second EC chunk buffer */
 #ifdef ENABLE_TASKLETS
 	int taskletrun;
 	int taskletsched;
@@ -181,11 +181,11 @@ static int highestorder;
 static int timingcable;
 
 static void set_clear(struct tor2 *tor);
-static int tor2_startup(struct zt_span *span);
-static int tor2_shutdown(struct zt_span *span);
-static int tor2_rbsbits(struct zt_chan *chan, int bits);
-static int tor2_maint(struct zt_span *span, int cmd);
-static int tor2_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data);
+static int tor2_startup(struct dahdi_span *span);
+static int tor2_shutdown(struct dahdi_span *span);
+static int tor2_rbsbits(struct dahdi_chan *chan, int bits);
+static int tor2_maint(struct dahdi_span *span, int cmd);
+static int tor2_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data);
 ZAP_IRQ_HANDLER(tor2_intr);
 
 /* translations of data channels for 24 channels in a 32 bit PCM highway */
@@ -197,7 +197,7 @@ unsigned datxlt_e1[] = {
     1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
 	25,26,27,28,29,30,31 };
 
-static int tor2_spanconfig(struct zt_span *span, struct zt_lineconfig *lc)
+static int tor2_spanconfig(struct dahdi_span *span, struct dahdi_lineconfig *lc)
 {
 	int i;
 	struct tor2_span *p = span->pvt;
@@ -221,19 +221,19 @@ static int tor2_spanconfig(struct zt_span *span, struct zt_lineconfig *lc)
 		p->tor->psyncs[lc->sync - 1] = p->span + 1;
 	}
 	/* If we're already running, then go ahead and apply the changes */
-	if (span->flags & ZT_FLAG_RUNNING)
+	if (span->flags & DAHDI_FLAG_RUNNING)
 		return tor2_startup(span);
 
 	return 0;
 }
 
-static int tor2_chanconfig(struct zt_chan *chan, int sigtype)
+static int tor2_chanconfig(struct dahdi_chan *chan, int sigtype)
 {
 	int alreadyrunning;
 	unsigned long flags;
 	struct tor2_chan *p = chan->pvt;
 
-	alreadyrunning = chan->span->flags & ZT_FLAG_RUNNING;
+	alreadyrunning = chan->span->flags & DAHDI_FLAG_RUNNING;
 	if (debug) {
 		if (alreadyrunning)
 			printk("Tor2: Reconfigured channel %d (%s) sigtype %d\n", chan->channo, chan->name, sigtype);
@@ -249,7 +249,7 @@ static int tor2_chanconfig(struct zt_chan *chan, int sigtype)
 	return 0;
 }
 
-static int tor2_open(struct zt_chan *chan)
+static int tor2_open(struct dahdi_chan *chan)
 {
 #ifndef LINUX26
 	MOD_INC_USE_COUNT;
@@ -257,7 +257,7 @@ static int tor2_open(struct zt_chan *chan)
 	return 0;
 }
 
-static int tor2_close(struct zt_chan *chan)
+static int tor2_close(struct dahdi_chan *chan)
 {
 #ifndef LINUX26
 	MOD_DEC_USE_COUNT;
@@ -287,27 +287,27 @@ static void init_spans(struct tor2 *tor)
 		tor->spans[x].close  = tor2_close;
 		if (tor->cardtype == TYPE_T1) {
 			tor->spans[x].channels = 24;
-			tor->spans[x].deflaw = ZT_LAW_MULAW;
-			tor->spans[x].linecompat = ZT_CONFIG_AMI | ZT_CONFIG_B8ZS | ZT_CONFIG_D4 | ZT_CONFIG_ESF;
+			tor->spans[x].deflaw = DAHDI_LAW_MULAW;
+			tor->spans[x].linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
 			tor->spans[x].spantype = "T1";
 		} else {
 			tor->spans[x].channels = 31;
-			tor->spans[x].deflaw = ZT_LAW_ALAW;
-			tor->spans[x].linecompat = ZT_CONFIG_HDB3 | ZT_CONFIG_CCS | ZT_CONFIG_CRC4;
+			tor->spans[x].deflaw = DAHDI_LAW_ALAW;
+			tor->spans[x].linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 			tor->spans[x].spantype = "E1";
 		}
 		tor->spans[x].chans = tor->chans[x];
-		tor->spans[x].flags = ZT_FLAG_RBS;
+		tor->spans[x].flags = DAHDI_FLAG_RBS;
 		tor->spans[x].ioctl = tor2_ioctl;
 		tor->spans[x].pvt = &tor->tspans[x];
 		tor->tspans[x].tor = tor;
 		tor->tspans[x].span = x;
 		init_waitqueue_head(&tor->spans[x].maintq);
 		for (y=0;y<tor->spans[x].channels;y++) {
-			struct zt_chan *mychans = tor->chans[x] + y;
+			struct dahdi_chan *mychans = tor->chans[x] + y;
 			sprintf(mychans->name, "Tor2/%d/%d/%d", tor->num, x + 1, y + 1);
-			mychans->sigcap = ZT_SIG_EM | ZT_SIG_CLEAR | ZT_SIG_FXSLS | ZT_SIG_FXSGS | ZT_SIG_FXSKS |
- 									 ZT_SIG_FXOLS | ZT_SIG_FXOGS | ZT_SIG_FXOKS | ZT_SIG_CAS | ZT_SIG_SF | ZT_SIG_EM_E1;
+			mychans->sigcap = DAHDI_SIG_EM | DAHDI_SIG_CLEAR | DAHDI_SIG_FXSLS | DAHDI_SIG_FXSGS | DAHDI_SIG_FXSKS |
+ 									 DAHDI_SIG_FXOLS | DAHDI_SIG_FXOGS | DAHDI_SIG_FXOKS | DAHDI_SIG_CAS | DAHDI_SIG_SF | DAHDI_SIG_EM_E1;
 			c = (x * tor->spans[x].channels) + y;
 			mychans->pvt = &tor->tchans[c];
 			mychans->chanpos = y + 1;
@@ -319,29 +319,29 @@ static void init_spans(struct tor2 *tor)
 
 static int __devinit tor2_launch(struct tor2 *tor)
 {
-	if (tor->spans[0].flags & ZT_FLAG_REGISTERED)
+	if (tor->spans[0].flags & DAHDI_FLAG_REGISTERED)
 		return 0;
 	printk("Tor2: Launching card: %d\n", tor->order);
-	if (zt_register(&tor->spans[0], 0)) {
+	if (dahdi_register(&tor->spans[0], 0)) {
 		printk(KERN_ERR "Unable to register span %s\n", tor->spans[0].name);
 		return -1;
 	}
-	if (zt_register(&tor->spans[1], 0)) {
+	if (dahdi_register(&tor->spans[1], 0)) {
 		printk(KERN_ERR "Unable to register span %s\n", tor->spans[1].name);
-		zt_unregister(&tor->spans[0]);
+		dahdi_unregister(&tor->spans[0]);
 		return -1;
 	}
-	if (zt_register(&tor->spans[2], 0)) {
+	if (dahdi_register(&tor->spans[2], 0)) {
 		printk(KERN_ERR "Unable to register span %s\n", tor->spans[2].name);
-		zt_unregister(&tor->spans[0]);
-		zt_unregister(&tor->spans[1]);
+		dahdi_unregister(&tor->spans[0]);
+		dahdi_unregister(&tor->spans[1]);
 		return -1;
 	}
-	if (zt_register(&tor->spans[3], 0)) {
+	if (dahdi_register(&tor->spans[3], 0)) {
 		printk(KERN_ERR "Unable to register span %s\n", tor->spans[3].name);
-		zt_unregister(&tor->spans[0]);
-		zt_unregister(&tor->spans[1]);
-		zt_unregister(&tor->spans[2]);
+		dahdi_unregister(&tor->spans[0]);
+		dahdi_unregister(&tor->spans[1]);
+		dahdi_unregister(&tor->spans[2]);
 		return -1;
 	}
 	tor->plx[INTCSR] = cpu_to_le16(PLX_INTENA); /* enable PLX interrupt */
@@ -368,10 +368,10 @@ static int __devinit tor2_probe(struct pci_dev *pdev, const struct pci_device_id
 	memset(tor,0,sizeof(struct tor2));
 	spin_lock_init(&tor->lock);
 	for (x = 0; x < SPANS_PER_CARD; x++) {
-		tor->chans[x] = kmalloc(sizeof(struct zt_chan) * 31,GFP_KERNEL);
+		tor->chans[x] = kmalloc(sizeof(struct dahdi_chan) * 31,GFP_KERNEL);
 		if (!tor->chans[x])
 			return -ENOMEM;
-		memset(tor->chans[x],0,sizeof(struct zt_chan) * 31);
+		memset(tor->chans[x],0,sizeof(struct dahdi_chan) * 31);
 	}
 	/* Load the resources */
 	tor->pci = pdev;
@@ -603,14 +603,14 @@ static void __devexit tor2_remove(struct pci_dev *pdev)
 	tor->mem8[LEDREG] = 0;
 	tor->plx[INTCSR] = cpu_to_le16(0);
 	free_irq(tor->irq, tor);
-	if (tor->spans[0].flags & ZT_FLAG_REGISTERED)
-		zt_unregister(&tor->spans[0]);
-	if (tor->spans[1].flags & ZT_FLAG_REGISTERED)
-		zt_unregister(&tor->spans[1]);
-	if (tor->spans[2].flags & ZT_FLAG_REGISTERED)
-		zt_unregister(&tor->spans[2]);
-	if (tor->spans[3].flags & ZT_FLAG_REGISTERED)
-		zt_unregister(&tor->spans[3]);
+	if (tor->spans[0].flags & DAHDI_FLAG_REGISTERED)
+		dahdi_unregister(&tor->spans[0]);
+	if (tor->spans[1].flags & DAHDI_FLAG_REGISTERED)
+		dahdi_unregister(&tor->spans[1]);
+	if (tor->spans[2].flags & DAHDI_FLAG_REGISTERED)
+		dahdi_unregister(&tor->spans[2]);
+	if (tor->spans[3].flags & DAHDI_FLAG_REGISTERED)
+		dahdi_unregister(&tor->spans[3]);
 	release_mem_region(tor->plx_region, tor->plx_len);
 	release_mem_region(tor->xilinx32_region, tor->xilinx32_len);
 	release_mem_region(tor->xilinx8_region, tor->xilinx8_len);
@@ -656,7 +656,7 @@ static void set_clear(struct tor2 *tor)
 	for (s = 0; s < SPANS_PER_CARD; s++) {
 		for (i = 0; i < 24; i++) {
 			j = (i/8);
-			if (tor->spans[s].chans[i].flags & ZT_FLAG_CLEAR) 
+			if (tor->spans[s].chans[i].flags & DAHDI_FLAG_CLEAR) 
 				val |= 1 << (i % 8);
 
 			if ((i % 8)==7) {
@@ -673,7 +673,7 @@ static void set_clear(struct tor2 *tor)
 }
 
 
-static int tor2_rbsbits(struct zt_chan *chan, int bits)
+static int tor2_rbsbits(struct dahdi_chan *chan, int bits)
 {
 	u_char m,c;
 	int k,n,b;
@@ -704,7 +704,7 @@ static int tor2_rbsbits(struct zt_chan *chan, int bits)
 	c = p->tor->txsigs[k][b];
 	c &= ~m;  /* clear mask bit */
 	  /* set mask bit, if bit is to be set */
-	if (bits & ZT_ABIT) c |= m;
+	if (bits & DAHDI_ABIT) c |= m;
 	p->tor->txsigs[k][b] = c;
 	spin_lock_irqsave(&p->tor->lock, flags);	
 	t1out(p->tor,k + 1,0x70 + b,c);
@@ -713,7 +713,7 @@ static int tor2_rbsbits(struct zt_chan *chan, int bits)
 	c = p->tor->txsigs[k][b];
 	c &= ~m;  /* clear mask bit */
 	  /* set mask bit, if bit is to be set */
-	if (bits & ZT_BBIT) c |= m;
+	if (bits & DAHDI_BBIT) c |= m;
 	  /* save new signalling values */
 	p->tor->txsigs[k][b] = c;
 	  /* output them into the chip */
@@ -723,7 +723,7 @@ static int tor2_rbsbits(struct zt_chan *chan, int bits)
 	c = p->tor->txsigs[k][b];
 	c &= ~m;  /* clear mask bit */
 	  /* set mask bit, if bit is to be set */
-	if (bits & ZT_CBIT) c |= m;
+	if (bits & DAHDI_CBIT) c |= m;
 	  /* save new signalling values */
 	p->tor->txsigs[k][b] = c;
 	  /* output them into the chip */
@@ -733,7 +733,7 @@ static int tor2_rbsbits(struct zt_chan *chan, int bits)
 	c = p->tor->txsigs[k][b];
 	c &= ~m;  /* clear mask bit */
 	  /* set mask bit, if bit is to be set */
-	if (bits & ZT_DBIT) c |= m;
+	if (bits & DAHDI_DBIT) c |= m;
 	  /* save new signalling values */
 	p->tor->txsigs[k][b] = c;
 	  /* output them into the chip */
@@ -742,7 +742,7 @@ static int tor2_rbsbits(struct zt_chan *chan, int bits)
 	return 0;
 }
 
-static int tor2_shutdown(struct zt_span *span)
+static int tor2_shutdown(struct dahdi_span *span)
 {
 	int i;
 	int tspan;
@@ -757,9 +757,9 @@ static int tor2_shutdown(struct zt_span *span)
 	}
 
 	spin_lock_irqsave(&p->tor->lock, flags);
-	wasrunning = span->flags & ZT_FLAG_RUNNING;
+	wasrunning = span->flags & DAHDI_FLAG_RUNNING;
 
-	span->flags &= ~ZT_FLAG_RUNNING;
+	span->flags &= ~DAHDI_FLAG_RUNNING;
 	/* Zero out all registers */
 	if (p->tor->cardtype == TYPE_E1) {
 		for (i = 0; i < 192; i++)
@@ -771,10 +771,10 @@ static int tor2_shutdown(struct zt_span *span)
 	if (wasrunning)
 		p->tor->spansstarted--;
 	spin_unlock_irqrestore(&p->tor->lock, flags);	
-	if (!(p->tor->spans[0].flags & ZT_FLAG_RUNNING) &&
-	    !(p->tor->spans[1].flags & ZT_FLAG_RUNNING) &&
-	    !(p->tor->spans[2].flags & ZT_FLAG_RUNNING) &&
-	    !(p->tor->spans[3].flags & ZT_FLAG_RUNNING))
+	if (!(p->tor->spans[0].flags & DAHDI_FLAG_RUNNING) &&
+	    !(p->tor->spans[1].flags & DAHDI_FLAG_RUNNING) &&
+	    !(p->tor->spans[2].flags & DAHDI_FLAG_RUNNING) &&
+	    !(p->tor->spans[3].flags & DAHDI_FLAG_RUNNING))
 		/* No longer in use, disable interrupts */
 		p->tor->mem8[CTLREG] = 0;
 	if (debug)
@@ -783,7 +783,7 @@ static int tor2_shutdown(struct zt_span *span)
 }
 
 
-static int tor2_startup(struct zt_span *span)
+static int tor2_startup(struct dahdi_span *span)
 {
 	unsigned long endjif;
 	int i;
@@ -803,15 +803,15 @@ static int tor2_startup(struct zt_span *span)
 
 	spin_lock_irqsave(&p->tor->lock, flags);
 
-	alreadyrunning = span->flags & ZT_FLAG_RUNNING;
+	alreadyrunning = span->flags & DAHDI_FLAG_RUNNING;
 
 	/* initialize the start value for the entire chunk of last ec buffer */
 	for (i = 0; i < span->channels; i++)
 	{
 		memset(p->tor->ec_chunk1[p->span][i],
-			ZT_LIN2X(0,&span->chans[i]),ZT_CHUNKSIZE);
+			DAHDI_LIN2X(0,&span->chans[i]),DAHDI_CHUNKSIZE);
 		memset(p->tor->ec_chunk2[p->span][i],
-			ZT_LIN2X(0,&span->chans[i]),ZT_CHUNKSIZE);
+			DAHDI_LIN2X(0,&span->chans[i]),DAHDI_CHUNKSIZE);
 	}
 	/* Force re-evaluation of the timing source */
 	if (timingcable)
@@ -848,18 +848,18 @@ static int tor2_startup(struct zt_span *span)
 		crcing = "";
 		tcr1 = 9; /* base TCR1 value: TSis mode */
 		tcr2 = 0;
-		if (span->lineconfig & ZT_CONFIG_CCS) {
+		if (span->lineconfig & DAHDI_CONFIG_CCS) {
 			ccr1 |= 8; /* CCR1: Rx Sig mode: CCS */
 			coding = "CCS";
 		} else {
 			tcr1 |= 0x20; 
 			coding = "CAS";
 		}
-		if (span->lineconfig & ZT_CONFIG_HDB3) {
+		if (span->lineconfig & DAHDI_CONFIG_HDB3) {
 			ccr1 |= 0x44; /* CCR1: TX and RX HDB3 */
 			framing = "HDB3";
 		} else framing = "AMI";
-		if (span->lineconfig & ZT_CONFIG_CRC4) {
+		if (span->lineconfig & DAHDI_CONFIG_CRC4) {
 			ccr1 |= 0x11; /* CCR1: TX and TX CRC4 */
 			tcr2 |= 0x02; /* TCR2: CRC4 bit auto */
 			crcing = "/CRC4";
@@ -884,7 +884,7 @@ static int tor2_startup(struct zt_span *span)
 			t1out(p->tor,tspan,0x1b,0x9a); /* CCR3: set also ESR */
 			t1out(p->tor,tspan,0x1b,0x82); /* CCR3: TSCLKM only now */
 			
-			span->flags |= ZT_FLAG_RUNNING;
+			span->flags |= DAHDI_FLAG_RUNNING;
 			p->tor->spansstarted++;
 
 			/* enable interrupts */
@@ -937,9 +937,9 @@ static int tor2_startup(struct zt_span *span)
 		}
 		/* Enable F bits pattern */
 		i = 0x20;
-		if (span->lineconfig & ZT_CONFIG_ESF)
+		if (span->lineconfig & DAHDI_CONFIG_ESF)
 			i = 0x88;
-		if (span->lineconfig & ZT_CONFIG_B8ZS)
+		if (span->lineconfig & DAHDI_CONFIG_B8ZS)
 			i |= 0x44;
 		t1out(p->tor,tspan, 0x38, i);
 		if (i & 0x80)
@@ -969,7 +969,7 @@ static int tor2_startup(struct zt_span *span)
 	
 			t1out(p->tor,tspan,0x0a,0x30); /* LIRST back to normal, Resetting elastic stores */
 
-			span->flags |= ZT_FLAG_RUNNING;
+			span->flags |= DAHDI_FLAG_RUNNING;
 			p->tor->spansstarted++;
 
 			/* enable interrupts */
@@ -982,9 +982,9 @@ static int tor2_startup(struct zt_span *span)
 
 		if (debug) {
 			if (alreadyrunning) 
-				printk("Tor2: Reconfigured span %d (%s/%s) LBO: %s\n", span->spanno, coding, framing, zt_lboname(span->txlevel));
+				printk("Tor2: Reconfigured span %d (%s/%s) LBO: %s\n", span->spanno, coding, framing, dahdi_lboname(span->txlevel));
 			else
-				printk("Tor2: Startup span %d (%s/%s) LBO: %s\n", span->spanno, coding, framing, zt_lboname(span->txlevel));
+				printk("Tor2: Startup span %d (%s/%s) LBO: %s\n", span->spanno, coding, framing, dahdi_lboname(span->txlevel));
 		}
 	}
 	if (p->tor->syncs[0] == span->spanno) printk("SPAN %d: Primary Sync Source\n",span->spanno);
@@ -994,7 +994,7 @@ static int tor2_startup(struct zt_span *span)
 	return 0;
 }
 
-static int tor2_maint(struct zt_span *span, int cmd)
+static int tor2_maint(struct dahdi_span *span, int cmd)
 {
 	struct tor2_span *p = span->pvt;
 
@@ -1003,18 +1003,18 @@ static int tor2_maint(struct zt_span *span, int cmd)
 	if (p->tor->cardtype == TYPE_E1)
 	   {
 		switch(cmd) {
-		    case ZT_MAINT_NONE:
+		    case DAHDI_MAINT_NONE:
 			t1out(p->tor,tspan,0xa8,0); /* no loops */
 			break;
-		    case ZT_MAINT_LOCALLOOP:
+		    case DAHDI_MAINT_LOCALLOOP:
 			t1out(p->tor,tspan,0xa8,0x40); /* local loop */
 			break;
-		    case ZT_MAINT_REMOTELOOP:
+		    case DAHDI_MAINT_REMOTELOOP:
 			t1out(p->tor,tspan,0xa8,0x80); /* remote loop */
 			break;
-		    case ZT_MAINT_LOOPUP:
-		    case ZT_MAINT_LOOPDOWN:
-		    case ZT_MAINT_LOOPSTOP:
+		    case DAHDI_MAINT_LOOPUP:
+		    case DAHDI_MAINT_LOOPDOWN:
+		    case DAHDI_MAINT_LOOPSTOP:
 			return -ENOSYS;
 		    default:
 			printk("Tor2: Unknown maint command: %d\n", cmd);
@@ -1023,29 +1023,29 @@ static int tor2_maint(struct zt_span *span, int cmd)
 		return 0;
 	}
 	switch(cmd) {
-    case ZT_MAINT_NONE:
+    case DAHDI_MAINT_NONE:
 	t1out(p->tor,tspan,0x19,(japan ? 0x80 : 0x00)); /* no local loop */
 	t1out(p->tor,tspan,0x0a,0); /* no remote loop */
 	break;
-    case ZT_MAINT_LOCALLOOP:
+    case DAHDI_MAINT_LOCALLOOP:
 	t1out(p->tor,tspan,0x19,0x40 | (japan ? 0x80 : 0x00)); /* local loop */
 	t1out(p->tor,tspan,0x0a,0); /* no remote loop */
 	break;
-    case ZT_MAINT_REMOTELOOP:
+    case DAHDI_MAINT_REMOTELOOP:
 	t1out(p->tor,tspan,0x1e,(japan ? 0x80 : 0x00)); /* no local loop */
 	t1out(p->tor,tspan,0x0a,0x40); /* remote loop */
 	break;
-    case ZT_MAINT_LOOPUP:
+    case DAHDI_MAINT_LOOPUP:
 	t1out(p->tor,tspan,0x30,2); /* send loopup code */
 	t1out(p->tor,tspan,0x12,0x22); /* send loopup code */
 	t1out(p->tor,tspan,0x13,0x80); /* send loopup code */
 	break;
-    case ZT_MAINT_LOOPDOWN:
+    case DAHDI_MAINT_LOOPDOWN:
 	t1out(p->tor,tspan,0x30,2); /* send loopdown code */
 	t1out(p->tor,tspan,0x12,0x62); /* send loopdown code */
 	t1out(p->tor,tspan,0x13,0x90); /* send loopdown code */
 	break;
-    case ZT_MAINT_LOOPSTOP:
+    case DAHDI_MAINT_LOOPSTOP:
 	t1out(p->tor,tspan,0x30,0);	/* stop sending loopup code */
 	break;
     default:
@@ -1059,26 +1059,26 @@ static inline void tor2_run(struct tor2 *tor)
 {
 	int x,y;
 	for (x = 0; x < SPANS_PER_CARD; x++) {
-		if (tor->spans[x].flags & ZT_FLAG_RUNNING) {
+		if (tor->spans[x].flags & DAHDI_FLAG_RUNNING) {
 			/* since the Tormenta 2 PCI is double-buffered, you
 			   need to delay the transmit data 2 entire chunks so
 			   that the transmit will be in sync with the receive */
 			for (y=0;y<tor->spans[x].channels;y++) {
-				zt_ec_chunk(&tor->spans[x].chans[y], 
+				dahdi_ec_chunk(&tor->spans[x].chans[y], 
 				    tor->spans[x].chans[y].readchunk, 
 					tor->ec_chunk2[x][y]);
 				memcpy(tor->ec_chunk2[x][y],tor->ec_chunk1[x][y],
-					ZT_CHUNKSIZE);
+					DAHDI_CHUNKSIZE);
 				memcpy(tor->ec_chunk1[x][y],
 					tor->spans[x].chans[y].writechunk,
-						ZT_CHUNKSIZE);
+						DAHDI_CHUNKSIZE);
 			}
-			zt_receive(&tor->spans[x]);
+			dahdi_receive(&tor->spans[x]);
 		}
 	}
 	for (x = 0; x < SPANS_PER_CARD; x++) {
-		if (tor->spans[x].flags & ZT_FLAG_RUNNING)
-			zt_transmit(&tor->spans[x]);
+		if (tor->spans[x].flags & DAHDI_FLAG_RUNNING)
+			dahdi_transmit(&tor->spans[x]);
 	}
 }
 
@@ -1127,8 +1127,8 @@ static int tor2_findsync(struct tor2 *tor)
 					if (cards[x]->syncpos[i]) {
 						nonzero = 1;
 						if ((cards[x]->syncpos[i] == p) &&
-						    !(cards[x]->spans[i].alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE | ZT_ALARM_LOOPBACK)) &&
-							(cards[x]->spans[i].flags & ZT_FLAG_RUNNING)) {
+						    !(cards[x]->spans[i].alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | DAHDI_ALARM_LOOPBACK)) &&
+							(cards[x]->spans[i].flags & DAHDI_FLAG_RUNNING)) {
 								/* This makes a good sync source */
 								newsyncsrc = cards[x]->spans[i].spanno;
 								newsyncnum = x;
@@ -1213,7 +1213,7 @@ ZAP_IRQ_HANDLER(tor2_intr)
 
 	/* do the transmit output */
 	for (n = 0; n < tor->spans[0].channels; n++) {
-		for (i = 0; i < ZT_CHUNKSIZE; i++) {
+		for (i = 0; i < DAHDI_CHUNKSIZE; i++) {
 			/* span 1 */
 			txword = tor->spans[0].chans[n].writechunk[i] << 24;
 			/* span 2 */
@@ -1233,7 +1233,7 @@ ZAP_IRQ_HANDLER(tor2_intr)
 
 	/* Do the receive input */
 	for (n = 0; n < tor->spans[0].channels; n++) {
-		for (i = 0; i < ZT_CHUNKSIZE; i++) {
+		for (i = 0; i < DAHDI_CHUNKSIZE; i++) {
 			/* read from */
 #ifdef FIXTHISFOR64
 		        rxword = tor->mem32[tor->datxlt[n] + (32 * i)];
@@ -1260,14 +1260,14 @@ ZAP_IRQ_HANDLER(tor2_intr)
 				rxc = c & 15;
 				if (rxc != tor->spans[k - 1].chans[j + 16].rxsig) {
 					/* Check for changes in received bits */
-					if (!(tor->spans[k - 1].chans[j + 16].sig & ZT_SIG_CLEAR))
-						zt_rbsbits(&tor->spans[k - 1].chans[j + 16], rxc);
+					if (!(tor->spans[k - 1].chans[j + 16].sig & DAHDI_SIG_CLEAR))
+						dahdi_rbsbits(&tor->spans[k - 1].chans[j + 16], rxc);
 				}
 				rxc = c >> 4;
 				if (rxc != tor->spans[k - 1].chans[j].rxsig) {
 					/* Check for changes in received bits */
-					if (!(tor->spans[k - 1].chans[j].sig & ZT_SIG_CLEAR))
-						zt_rbsbits(&tor->spans[k - 1].chans[j], rxc);
+					if (!(tor->spans[k - 1].chans[j].sig & DAHDI_SIG_CLEAR))
+						dahdi_rbsbits(&tor->spans[k - 1].chans[j], rxc);
 				}
 			}
 		}
@@ -1283,12 +1283,12 @@ ZAP_IRQ_HANDLER(tor2_intr)
 			/* Get channel number */
 			i = (n * 8) + j;
 			rxc = 0;
-			if (abits & (1 << j)) rxc |= ZT_ABIT;
-			if (bbits & (1 << j)) rxc |= ZT_BBIT;
+			if (abits & (1 << j)) rxc |= DAHDI_ABIT;
+			if (bbits & (1 << j)) rxc |= DAHDI_BBIT;
 			if (tor->spans[k].chans[i].rxsig != rxc) {
 				/* Check for changes in received bits */
-				if (!(tor->spans[k].chans[i].sig & ZT_SIG_CLEAR)) {
-					zt_rbsbits(&tor->spans[k].chans[i], rxc);
+				if (!(tor->spans[k].chans[i].sig & DAHDI_SIG_CLEAR)) {
+					dahdi_rbsbits(&tor->spans[k].chans[i], rxc);
 				}
 			}
 		}
@@ -1299,12 +1299,12 @@ ZAP_IRQ_HANDLER(tor2_intr)
 		if (tor->alarmtimer[i]) {
 			if (!--tor->alarmtimer[i]) {
 				  /* clear recover status */
-				tor->spans[i].alarms &= ~ZT_ALARM_RECOVER;
+				tor->spans[i].alarms &= ~DAHDI_ALARM_RECOVER;
 				if (tor->cardtype == TYPE_E1)
 					t1out(tor,i + 1,0x21,0x5f); /* turn off yel */
 				else 
 					t1out(tor,i + 1,0x35,0x10); /* turn off yel */
-				zt_alarm_notify(&tor->spans[i]);  /* let them know */
+				dahdi_alarm_notify(&tor->spans[i]);  /* let them know */
 			   }
 		}
 	}
@@ -1324,11 +1324,11 @@ ZAP_IRQ_HANDLER(tor2_intr)
 			   {
 				  /* set into remote loop, if not there already */
 				if ((tor->loopupcnt[i]++ > 80) && 
-					(tor->spans[i].maintstat != ZT_MAINT_REMOTELOOP))
+					(tor->spans[i].maintstat != DAHDI_MAINT_REMOTELOOP))
 				   {
 					t1out(tor,i + 1,0x1e,(japan ? 0x80 : 0x00)); /* no local loop */
 					t1out(tor,i + 1,0x0a,0x40); /* remote loop */
-					tor->spans[i].maintstat = ZT_MAINT_REMOTELOOP;
+					tor->spans[i].maintstat = DAHDI_MAINT_REMOTELOOP;
 				   }
 			   } else tor->loopupcnt[i] = 0;
 			  /* detect the code, only if we are not sending one */
@@ -1336,55 +1336,55 @@ ZAP_IRQ_HANDLER(tor2_intr)
 			   {
 				  /* if in remote loop, get out of it */
 				if ((tor->loopdowncnt[i]++ > 80) &&
-					(tor->spans[i].maintstat == ZT_MAINT_REMOTELOOP))
+					(tor->spans[i].maintstat == DAHDI_MAINT_REMOTELOOP))
 				   {
 					t1out(tor,i + 1,0x1e,(japan ? 0x80 : 0x00)); /* no local loop */
 					t1out(tor,i + 1,0x0a,0); /* no remote loop */
-					tor->spans[i].maintstat = ZT_MAINT_NONE;
+					tor->spans[i].maintstat = DAHDI_MAINT_NONE;
 				   }
 			   } else tor->loopdowncnt[i] = 0;
 			if (c & 3) /* if red alarm */
 			   {
-				j |= ZT_ALARM_RED;
+				j |= DAHDI_ALARM_RED;
 			   }
 			if (c & 8) /* if blue alarm */
 			   {
-				j |= ZT_ALARM_BLUE;
+				j |= DAHDI_ALARM_BLUE;
 			   }
 		} else { /* its an E1 card */
 			t1out(tor,i + 1,6,0xff); 
 			c = t1in(tor,i + 1,6);  /* get the status */
 			if (c & 9) /* if red alarm */
 			   {
-				j |= ZT_ALARM_RED;
+				j |= DAHDI_ALARM_RED;
 			   }
 			if (c & 2) /* if blue alarm */
 			   {
-				j |= ZT_ALARM_BLUE;
+				j |= DAHDI_ALARM_BLUE;
 			   }
 		}
 		  /* only consider previous carrier alarm state */
-		tor->spans[i].alarms &= (ZT_ALARM_RED | ZT_ALARM_BLUE | ZT_ALARM_NOTOPEN);
+		tor->spans[i].alarms &= (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | DAHDI_ALARM_NOTOPEN);
 		n = 1; /* set to 1 so will not be in yellow alarm if we dont
 			care about open channels */
 		  /* if to have yellow alarm if nothing open */
-		if (tor->spans[i].lineconfig & ZT_CONFIG_NOTOPEN)
+		if (tor->spans[i].lineconfig & DAHDI_CONFIG_NOTOPEN)
 		   {
 			  /* go thru all chans, and count # open */
 			for (n = 0,k = 0; k < tor->spans[i].channels; k++) 
 			   {
-				if (((tor->chans[i] + k)->flags & ZT_FLAG_OPEN) ||
-				    ((tor->chans[i] + k)->flags & ZT_FLAG_NETDEV)) n++;
+				if (((tor->chans[i] + k)->flags & DAHDI_FLAG_OPEN) ||
+				    ((tor->chans[i] + k)->flags & DAHDI_FLAG_NETDEV)) n++;
 			   }
 			  /* if none open, set alarm condition */
-			if (!n) j |= ZT_ALARM_NOTOPEN; 
+			if (!n) j |= DAHDI_ALARM_NOTOPEN; 
 		   }
 		  /* if no more alarms, and we had some */
 		if ((!j) && tor->spans[i].alarms)
 		   {
-			tor->alarmtimer[i] = ZT_ALARMSETTLE_TIME; 
+			tor->alarmtimer[i] = DAHDI_ALARMSETTLE_TIME; 
 		   }
-		if (tor->alarmtimer[i]) j |= ZT_ALARM_RECOVER;
+		if (tor->alarmtimer[i]) j |= DAHDI_ALARM_RECOVER;
 		  /* if going into alarm state, set yellow alarm */
 		if ((j) && (!tor->spans[i].alarms)) {
 			if (tor->cardtype == TYPE_E1)
@@ -1393,19 +1393,19 @@ ZAP_IRQ_HANDLER(tor2_intr)
 				t1out(tor,i + 1,0x35,0x11);
 		}
 		if (c & 4) /* if yellow alarm */
-			j |= ZT_ALARM_YELLOW;
-		if (tor->spans[i].maintstat || tor->spans[i].mainttimer) j |= ZT_ALARM_LOOPBACK;
+			j |= DAHDI_ALARM_YELLOW;
+		if (tor->spans[i].maintstat || tor->spans[i].mainttimer) j |= DAHDI_ALARM_LOOPBACK;
 		tor->spans[i].alarms = j;
 		c = (LEDRED | LEDGREEN) << (2 * i);
 		tor->leds &= ~c;  /* mask out bits for this span */
 		/* light LED's if span configured and running */
-		if (tor->spans[i].flags & ZT_FLAG_RUNNING) {
-			if (j & ZT_ALARM_RED) tor->leds |= LEDRED << (2 * i);
-			else if (j & ZT_ALARM_YELLOW) tor->leds |= (LEDRED | LEDGREEN) << (2 * i);
+		if (tor->spans[i].flags & DAHDI_FLAG_RUNNING) {
+			if (j & DAHDI_ALARM_RED) tor->leds |= LEDRED << (2 * i);
+			else if (j & DAHDI_ALARM_YELLOW) tor->leds |= (LEDRED | LEDGREEN) << (2 * i);
 			else tor->leds |= LEDGREEN << (2 * i);
 		}
 		tor->mem8[LEDREG] = tor->leds;
-		zt_alarm_notify(&tor->spans[i]);
+		dahdi_alarm_notify(&tor->spans[i]);
 	   }
 	if (!(tor->passno % 1000)) /* even second boundary */
 	   {
@@ -1416,7 +1416,7 @@ ZAP_IRQ_HANDLER(tor2_intr)
 			{
 				   /* add this second's BPV count to total one */
 				tor->spans[i - 1].bpvcount += t1in(tor,i,1) + (t1in(tor,i,0) << 8);
-				if (tor->spans[i - 1].lineconfig & ZT_CONFIG_CRC4)
+				if (tor->spans[i - 1].lineconfig & DAHDI_CONFIG_CRC4)
 				{
 					tor->spans[i - 1].crc4count += t1in(tor,i,3) + ((t1in(tor,i,2) & 3) << 8);
 					tor->spans[i - 1].ebitcount += t1in(tor,i,5) + ((t1in(tor,i,4) & 3) << 8);
@@ -1438,8 +1438,8 @@ ZAP_IRQ_HANDLER(tor2_intr)
 		if (tor->psyncs[0])
 		   {
 			  /* if no alarms, use it */
-			if (!(tor->spans[tor->psyncs[0] - 1].alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE | 
-				ZT_ALARM_LOOPBACK))) {
+			if (!(tor->spans[tor->psyncs[0] - 1].alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | 
+				DAHDI_ALARM_LOOPBACK))) {
 					tor->syncsrc = tor->psyncs[0];
 					syncsrc = tor->syncs[0];
 					}
@@ -1449,8 +1449,8 @@ ZAP_IRQ_HANDLER(tor2_intr)
 			   /* if we dont have one yet, and there is one specified at this level, see if we can use it */
 			if ((!tor->syncsrc) && (tor->psyncs[i])) {
 				  /* if no alarms, use it */
-				if (!(tor->spans[tor->psyncs[i] - 1].alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE | 
-					ZT_ALARM_LOOPBACK))) {
+				if (!(tor->spans[tor->psyncs[i] - 1].alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | 
+					DAHDI_ALARM_LOOPBACK))) {
 						tor->syncsrc = tor->psyncs[i];
 						syncsrc = tor->syncs[i];
 						}
@@ -1490,7 +1490,7 @@ ZAP_IRQ_HANDLER(tor2_intr)
 }
 
 
-static int tor2_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
+static int tor2_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data)
 {
 	switch(cmd) {
 	default:
diff --git a/drivers/dahdi/wcfxo.c b/drivers/dahdi/wcfxo.c
index a8e0313..d9b23a6 100644
--- a/drivers/dahdi/wcfxo.c
+++ b/drivers/dahdi/wcfxo.c
@@ -141,8 +141,8 @@ static int wecareregs[] =
 struct wcfxo {
 	struct pci_dev *dev;
 	char *variety;
-	struct zt_span span;
-	struct zt_chan chan;
+	struct dahdi_span span;
+	struct dahdi_chan chan;
 	int usecount;
 	int dead;
 	int pos;
@@ -169,9 +169,9 @@ struct wcfxo {
 	int ignoreread;
 	int reset;
 	/* Up to 6 register can be written at a time */
-	struct reg regs[ZT_CHUNKSIZE];
-	struct reg oldregs[ZT_CHUNKSIZE];
-	unsigned char lasttx[ZT_CHUNKSIZE];
+	struct reg regs[DAHDI_CHUNKSIZE];
+	struct reg oldregs[DAHDI_CHUNKSIZE];
+	unsigned char lasttx[DAHDI_CHUNKSIZE];
 	/* Up to 32 registers of whatever we most recently read */
 	unsigned char readregs[32];
 	unsigned long ioaddr;
@@ -252,34 +252,34 @@ static inline void wcfxo_transmitprep(struct wcfxo *wc, unsigned char ints)
 	int written=0;
 	unsigned short cmd;
 
-	/* if nothing to transmit, have to do the zt_transmit() anyway */
+	/* if nothing to transmit, have to do the dahdi_transmit() anyway */
 	if (!(ints & 3)) {
 		/* Calculate Transmission */
-		zt_transmit(&wc->span);
+		dahdi_transmit(&wc->span);
 		return;
 	}
 
 	/* Remember what it was we just sent */
-	memcpy(wc->lasttx, wc->chan.writechunk, ZT_CHUNKSIZE);
+	memcpy(wc->lasttx, wc->chan.writechunk, DAHDI_CHUNKSIZE);
 
 	if (ints & 0x01)  {
 		/* Write is at interrupt address.  Start writing from normal offset */
 		writechunk = wc->writechunk;
 	} else {
-		writechunk = wc->writechunk + ZT_CHUNKSIZE * 2;
+		writechunk = wc->writechunk + DAHDI_CHUNKSIZE * 2;
 	}
 
-	zt_transmit(&wc->span);
+	dahdi_transmit(&wc->span);
 
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		/* Send a sample, as a 32-bit word, and be sure to indicate that a command follows */
 		if (wc->flags & FLAG_INVERTSER)
 			writechunk[x << 1] = cpu_to_le32(
-				~((unsigned short)(ZT_XLAW(wc->chan.writechunk[x], (&wc->chan)))| 0x1) << 16
+				~((unsigned short)(DAHDI_XLAW(wc->chan.writechunk[x], (&wc->chan)))| 0x1) << 16
 				);
 		else
 			writechunk[x << 1] = cpu_to_le32(
-				((unsigned short)(ZT_XLAW(wc->chan.writechunk[x], (&wc->chan)))| 0x1) << 16
+				((unsigned short)(DAHDI_XLAW(wc->chan.writechunk[x], (&wc->chan)))| 0x1) << 16
 				);
 
 		/* We always have a command to follow our signal */
@@ -320,7 +320,7 @@ static inline void wcfxo_transmitprep(struct wcfxo *wc, unsigned char ints)
 		wc->readpos = 0;
 	wc->wregcount = 0;
 
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		/* Rotate through registers */
 		wc->oldregs[x] = wc->regs[x];
 		wc->regs[x].flags = FLAG_EMPTY;
@@ -339,11 +339,11 @@ static inline void wcfxo_receiveprep(struct wcfxo *wc, unsigned char ints)
 		/* Read is at interrupt address.  Valid data is available at normal offset */
 		readchunk = wc->readchunk;
 	else
-		readchunk = wc->readchunk + ZT_CHUNKSIZE * 2;
+		readchunk = wc->readchunk + DAHDI_CHUNKSIZE * 2;
 
 	/* Keep track of how quickly our peg alternates */
-	wc->pegtimer+=ZT_CHUNKSIZE;
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	wc->pegtimer+=DAHDI_CHUNKSIZE;
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 
 		/* We always have a command to follow our signal.  */
 		if (wc->oldregs[x].flags == FLAG_READ && !wc->ignoreread) {
@@ -377,7 +377,7 @@ static inline void wcfxo_receiveprep(struct wcfxo *wc, unsigned char ints)
 			wc->pegtimer = 0;
 			wc->peg = -1;
 		}
-		wc->chan.readchunk[x] = ZT_LIN2X((sample), (&wc->chan));
+		wc->chan.readchunk[x] = DAHDI_LIN2X((sample), (&wc->chan));
 	}
 	if (wc->pegtimer > PEGTIME) {
 		/* Reset pegcount if our timer expires */
@@ -391,14 +391,14 @@ static inline void wcfxo_receiveprep(struct wcfxo *wc, unsigned char ints)
 			/* It's ringing */
 			if (debug)
 				printk("RING!\n");
-			zt_hooksig(&wc->chan, ZT_RXSIG_RING);
+			dahdi_hooksig(&wc->chan, DAHDI_RXSIG_RING);
 			wc->ring = 1;
 		}
 		if (wc->ring && !wc->pegcount) {
 			/* No more ring */
 			if (debug)
 				printk("NO RING!\n");
-			zt_hooksig(&wc->chan, ZT_RXSIG_OFFHOOK);
+			dahdi_hooksig(&wc->chan, DAHDI_RXSIG_OFFHOOK);
 			wc->ring = 0;
 		}
 	}
@@ -407,10 +407,10 @@ static inline void wcfxo_receiveprep(struct wcfxo *wc, unsigned char ints)
 
 	/* Do the echo cancellation...  We are echo cancelling against
 	   what we sent two chunks ago*/
-	zt_ec_chunk(&wc->chan, wc->chan.readchunk, wc->lasttx);
+	dahdi_ec_chunk(&wc->chan, wc->chan.readchunk, wc->lasttx);
 
 	/* Receive the result */
-	zt_receive(&wc->span);
+	dahdi_receive(&wc->span);
 }
 
 #ifdef ENABLE_TASKLETS
@@ -504,7 +504,7 @@ ZAP_IRQ_HANDLER(wcfxo_interrupt)
 				wc->battery =  0;
 #ifdef	JAPAN
 				if ((!wc->ohdebounce) && wc->offhook) {
-					zt_hooksig(&wc->chan, ZT_RXSIG_ONHOOK);
+					dahdi_hooksig(&wc->chan, DAHDI_RXSIG_ONHOOK);
 					if (debug)
 						printk("Signalled On Hook\n");
 #ifdef	ZERO_BATT_RING
@@ -512,7 +512,7 @@ ZAP_IRQ_HANDLER(wcfxo_interrupt)
 #endif
 				}
 #else
-				zt_hooksig(&wc->chan, ZT_RXSIG_ONHOOK);
+				dahdi_hooksig(&wc->chan, DAHDI_RXSIG_ONHOOK);
 #endif
 				wc->battdebounce = BATT_DEBOUNCE;
 			} else if (!wc->battery)
@@ -522,8 +522,8 @@ ZAP_IRQ_HANDLER(wcfxo_interrupt)
 			    !(wc->readregs[WC_DAA_DCTL1] & 0x04) &&
 #endif
 			    (!wc->span.alarms)) {
-				wc->span.alarms = ZT_ALARM_RED;
-				zt_alarm_notify(&wc->span);
+				wc->span.alarms = DAHDI_ALARM_RED;
+				dahdi_alarm_notify(&wc->span);
 			}
 		} else if (b == 0xf) {
 			if (!wc->battery && !wc->battdebounce) {
@@ -532,19 +532,19 @@ ZAP_IRQ_HANDLER(wcfxo_interrupt)
 #ifdef	ZERO_BATT_RING
 				if (wc->onhook) {
 					wc->onhook = 0;
-					zt_hooksig(&wc->chan, ZT_RXSIG_OFFHOOK);
+					dahdi_hooksig(&wc->chan, DAHDI_RXSIG_OFFHOOK);
 					if (debug)
 						printk("Signalled Off Hook\n");
 				}
 #else
-				zt_hooksig(&wc->chan, ZT_RXSIG_OFFHOOK);
+				dahdi_hooksig(&wc->chan, DAHDI_RXSIG_OFFHOOK);
 #endif
 				wc->battery = 1;
 				wc->nobatttimer = 0;
 				wc->battdebounce = BATT_DEBOUNCE;
 				if (wc->span.alarms) {
 					wc->span.alarms = 0;
-					zt_alarm_notify(&wc->span);
+					dahdi_alarm_notify(&wc->span);
 				}
 			} else if (wc->battery)
 				wc->battdebounce = BATT_DEBOUNCE;
@@ -569,7 +569,7 @@ ZAP_IRQ_HANDLER(wcfxo_interrupt)
 static int wcfxo_setreg(struct wcfxo *wc, unsigned char reg, unsigned char value)
 {
 	int x;
-	if (wc->wregcount < ZT_CHUNKSIZE) {
+	if (wc->wregcount < DAHDI_CHUNKSIZE) {
 		x = wc->wregcount;
 		wc->regs[x].reg = reg;
 		wc->regs[x].value = value;
@@ -581,7 +581,7 @@ static int wcfxo_setreg(struct wcfxo *wc, unsigned char reg, unsigned char value
 	return -1;
 }
 
-static int wcfxo_open(struct zt_chan *chan)
+static int wcfxo_open(struct dahdi_chan *chan)
 {
 	struct wcfxo *wc = chan->pvt;
 	if (wc->dead)
@@ -593,14 +593,14 @@ static int wcfxo_open(struct zt_chan *chan)
 	return 0;
 }
 
-static int wcfxo_watchdog(struct zt_span *span, int event)
+static int wcfxo_watchdog(struct dahdi_span *span, int event)
 {
 	printk("FXO: Restarting DMA\n");
 	wcfxo_restart_dma(span->pvt);
 	return 0;
 }
 
-static int wcfxo_close(struct zt_chan *chan)
+static int wcfxo_close(struct dahdi_chan *chan)
 {
 	struct wcfxo *wc = chan->pvt;
 	wc->usecount--;
@@ -613,13 +613,13 @@ static int wcfxo_close(struct zt_chan *chan)
 	return 0;
 }
 
-static int wcfxo_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
+static int wcfxo_hooksig(struct dahdi_chan *chan, dahdi_txsig_t txsig)
 {
 	struct wcfxo *wc = chan->pvt;
 	int reg=0;
 	switch(txsig) {
-	case ZT_TXSIG_START:
-	case ZT_TXSIG_OFFHOOK:
+	case DAHDI_TXSIG_START:
+	case DAHDI_TXSIG_OFFHOOK:
 		/* Take off hook and enable normal mode reception.  This must
 		   be done in two steps because of a hardware bug. */
 		reg = wc->readregs[WC_DAA_DCTL1] & ~0x08;
@@ -634,7 +634,7 @@ static int wcfxo_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
 		wc->ohdebounce = OH_DEBOUNCE;
 #endif
 		break;
-	case ZT_TXSIG_ONHOOK:
+	case DAHDI_TXSIG_ONHOOK:
 		/* Put on hook and enable on hook line monitor */
 		reg =  wc->readregs[WC_DAA_DCTL1] & 0xfe;
 		wcfxo_setreg(wc, WC_DAA_DCTL1, reg);
@@ -666,7 +666,7 @@ static int wcfxo_initialize(struct wcfxo *wc)
 		 "PCI Bus %02d Slot %02d", wc->dev->bus->number, PCI_SLOT(wc->dev->devfn) + 1);
 	wc->span.manufacturer = "Digium";
 	zap_copy_string(wc->span.devicetype, wc->variety, sizeof(wc->span.devicetype));
-	wc->chan.sigcap = ZT_SIG_FXSKS | ZT_SIG_FXSLS | ZT_SIG_SF;
+	wc->chan.sigcap = DAHDI_SIG_FXSKS | DAHDI_SIG_FXSLS | DAHDI_SIG_SF;
 	wc->chan.chanpos = 1;
 	wc->span.chans = &wc->chan;
 	wc->span.channels = 1;
@@ -674,8 +674,8 @@ static int wcfxo_initialize(struct wcfxo *wc)
 	wc->span.irq = wc->dev->irq;
 	wc->span.open = wcfxo_open;
 	wc->span.close = wcfxo_close;
-	wc->span.flags = ZT_FLAG_RBS;
-	wc->span.deflaw = ZT_LAW_MULAW;
+	wc->span.flags = DAHDI_FLAG_RBS;
+	wc->span.deflaw = DAHDI_LAW_MULAW;
 	wc->span.watchdog = wcfxo_watchdog;
 #ifdef ENABLE_TASKLETS
 	tasklet_init(&wc->wcfxo_tlet, wcfxo_tasklet, (unsigned long)wc);
@@ -684,7 +684,7 @@ static int wcfxo_initialize(struct wcfxo *wc)
 
 	wc->span.pvt = wc;
 	wc->chan.pvt = wc;
-	if (zt_register(&wc->span, 0)) {
+	if (dahdi_register(&wc->span, 0)) {
 		printk("Unable to register span with zaptel\n");
 		return -1;
 	}
@@ -729,12 +729,12 @@ static int wcfxo_hardware_init(struct wcfxo *wc)
 
 	/* Setup DMA Addresses */
 	outl(wc->writedma,                    wc->ioaddr + WC_DMAWS);		/* Write start */
-	outl(wc->writedma + ZT_CHUNKSIZE * 8 - 4, wc->ioaddr + WC_DMAWI);		/* Middle (interrupt) */
-	outl(wc->writedma + ZT_CHUNKSIZE * 16 - 4, wc->ioaddr + WC_DMAWE);			/* End */
+	outl(wc->writedma + DAHDI_CHUNKSIZE * 8 - 4, wc->ioaddr + WC_DMAWI);		/* Middle (interrupt) */
+	outl(wc->writedma + DAHDI_CHUNKSIZE * 16 - 4, wc->ioaddr + WC_DMAWE);			/* End */
 	
 	outl(wc->readdma,                    	 wc->ioaddr + WC_DMARS);	/* Read start */
-	outl(wc->readdma + ZT_CHUNKSIZE * 8 - 4, 	 wc->ioaddr + WC_DMARI);	/* Middle (interrupt) */
-	outl(wc->readdma + ZT_CHUNKSIZE * 16 - 4, wc->ioaddr + WC_DMARE);	/* End */
+	outl(wc->readdma + DAHDI_CHUNKSIZE * 8 - 4, 	 wc->ioaddr + WC_DMARI);	/* Middle (interrupt) */
+	outl(wc->readdma + DAHDI_CHUNKSIZE * 16 - 4, wc->ioaddr + WC_DMARE);	/* End */
 	
 	/* Clear interrupts */
 	outb(0xff, wc->ioaddr + WC_INTSTAT);
@@ -807,7 +807,7 @@ static void wcfxo_set_daa_mode(struct wcfxo *wc)
 
 	/* Wait a couple of jiffies for our writes to finish */
 	set_current_state(TASK_INTERRUPTIBLE);
-	schedule_timeout(1 + (ZT_CHUNKSIZE * HZ) / 800);
+	schedule_timeout(1 + (DAHDI_CHUNKSIZE * HZ) / 800);
 
 	printk("wcfxo: DAA mode is '%s'\n", fxo_modes[opermode].name);
 }
@@ -826,7 +826,7 @@ static int wcfxo_init_daa(struct wcfxo *wc)
 
 	/* Let the reset go */
 	set_current_state(TASK_UNINTERRUPTIBLE);
-	schedule_timeout(1 + (ZT_CHUNKSIZE * HZ) / 800);
+	schedule_timeout(1 + (DAHDI_CHUNKSIZE * HZ) / 800);
 
 	/* We have a clock at 18.432 Mhz, so N1=1, M1=2, CGM=0 */
 	wcfxo_setreg(wc, WC_DAA_PLL1_N1, 0x0);	/* This value is N1 - 1 */
@@ -836,7 +836,7 @@ static int wcfxo_init_daa(struct wcfxo *wc)
 	
 	/* Wait until the PLL's are locked. Time is between 100 uSec and 1 mSec */
 	set_current_state(TASK_INTERRUPTIBLE);
-	schedule_timeout(1 + HZ/1000 + (ZT_CHUNKSIZE * HZ) / 800);
+	schedule_timeout(1 + HZ/1000 + (DAHDI_CHUNKSIZE * HZ) / 800);
 
 	/* No additional ration is applied to the PLL and faster lock times
 	 * are possible */
@@ -853,7 +853,7 @@ static int wcfxo_init_daa(struct wcfxo *wc)
 
 	/* Wait a couple of jiffies for our writes to finish */
 	set_current_state(TASK_INTERRUPTIBLE);
-	schedule_timeout(1 + (ZT_CHUNKSIZE * HZ) / 800);
+	schedule_timeout(1 + (DAHDI_CHUNKSIZE * HZ) / 800);
 	reg15 = 0x0;
 	/* Go ahead and attenuate transmit signal by 6 db */
 	if (quiet) {
@@ -936,7 +936,7 @@ static int __devinit wcfxo_init_one(struct pci_dev *pdev, const struct pci_devic
 
 	/* Allocate enough memory for two zt chunks, receive and transmit.  Each sample uses
 	   32 bits.  Allocate an extra set just for control too */
-	wc->writechunk = (int *)pci_alloc_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, &wc->writedma);
+	wc->writechunk = (int *)pci_alloc_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, &wc->writedma);
 	if (!wc->writechunk) {
 		printk("wcfxo: Unable to allocate DMA-able memory\n");
 		if (wc->freeregion)
@@ -944,8 +944,8 @@ static int __devinit wcfxo_init_one(struct pci_dev *pdev, const struct pci_devic
 		return -ENOMEM;
 	}
 
-	wc->readchunk = wc->writechunk + ZT_MAX_CHUNKSIZE * 4;	/* in doublewords */
-	wc->readdma = wc->writedma + ZT_MAX_CHUNKSIZE * 16;		/* in bytes */
+	wc->readchunk = wc->writechunk + DAHDI_MAX_CHUNKSIZE * 4;	/* in doublewords */
+	wc->readdma = wc->writedma + DAHDI_MAX_CHUNKSIZE * 16;		/* in bytes */
 
 	if (wcfxo_initialize(wc)) {
 		printk("wcfxo: Unable to intialize modem\n");
@@ -974,7 +974,7 @@ static int __devinit wcfxo_init_one(struct pci_dev *pdev, const struct pci_devic
 	/* Enable interrupts */
 	wcfxo_enable_interrupts(wc);
 	/* Initialize Write/Buffers to all blank data */
-	memset((void *)wc->writechunk,0,ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4);
+	memset((void *)wc->writechunk,0,DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4);
 	/* Start DMA */
 	wcfxo_start_dma(wc);
 
@@ -983,7 +983,7 @@ static int __devinit wcfxo_init_one(struct pci_dev *pdev, const struct pci_devic
 		printk("Failed to initailize DAA, giving up...\n");
 		wcfxo_stop_dma(wc);
 		wcfxo_disable_interrupts(wc);
-		zt_unregister(&wc->span);
+		dahdi_unregister(&wc->span);
 		free_irq(pdev->irq, wc);
 
 		/* Reset PCI chip and registers */
@@ -1002,7 +1002,7 @@ static int __devinit wcfxo_init_one(struct pci_dev *pdev, const struct pci_devic
 
 static void wcfxo_release(struct wcfxo *wc)
 {
-	zt_unregister(&wc->span);
+	dahdi_unregister(&wc->span);
 	if (wc->freeregion)
 		release_region(wc->ioaddr, 0xff);
 	kfree(wc);
@@ -1022,7 +1022,7 @@ static void __devexit wcfxo_remove_one(struct pci_dev *pdev)
 		wcfxo_disable_interrupts(wc);
 		
 		/* Immediately free resources */
-		pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
+		pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
 		free_irq(pdev->irq, wc);
 
 		/* Reset PCI chip and registers */
diff --git a/drivers/dahdi/wct1xxp.c b/drivers/dahdi/wct1xxp.c
index b636743..fdd2f3f 100644
--- a/drivers/dahdi/wct1xxp.c
+++ b/drivers/dahdi/wct1xxp.c
@@ -159,11 +159,11 @@ struct t1xxp {
 	dma_addr_t	writedma;
 	volatile unsigned char *writechunk;					/* Double-word aligned write memory */
 	volatile unsigned char *readchunk;					/* Double-word aligned read memory */
-	unsigned char ec_chunk1[31][ZT_CHUNKSIZE];
-	unsigned char ec_chunk2[31][ZT_CHUNKSIZE];
+	unsigned char ec_chunk1[31][DAHDI_CHUNKSIZE];
+	unsigned char ec_chunk2[31][DAHDI_CHUNKSIZE];
 	unsigned char tempo[32];
-	struct zt_span span;						/* Span */
-	struct zt_chan chans[31];					/* Channels */
+	struct dahdi_span span;						/* Span */
+	struct dahdi_chan chans[31];					/* Channels */
 };
 
 #define CANARY 0xca1e
@@ -205,7 +205,7 @@ static inline void __select_control(struct t1xxp *wc)
 	}
 }
 
-static int t1xxp_open(struct zt_chan *chan)
+static int t1xxp_open(struct dahdi_chan *chan)
 {
 	struct t1xxp *wc = chan->pvt;
 	if (wc->dead)
@@ -277,12 +277,12 @@ static int control_get_reg(struct t1xxp *wc, int reg)
 
 static void t1xxp_release(struct t1xxp *wc)
 {
-	zt_unregister(&wc->span);
+	dahdi_unregister(&wc->span);
 	kfree(wc);
 	printk("Freed a Wildcard\n");
 }
 
-static int t1xxp_close(struct zt_chan *chan)
+static int t1xxp_close(struct dahdi_chan *chan)
 {
 	struct t1xxp *wc = chan->pvt;
 	wc->usecount--;
@@ -342,7 +342,7 @@ static void __t1xxp_set_clear(struct t1xxp *wc)
 	for (x=0;x<3;x++) {
 		b = 0;
 		for (y=0;y<8;y++)
-			if (wc->chans[x * 8 + y].sig & ZT_SIG_CLEAR)
+			if (wc->chans[x * 8 + y].sig & DAHDI_SIG_CLEAR)
 				b |= (1 << y);
 		__t1_set_reg(wc, 0x39 + x, b);
 	}
@@ -353,27 +353,27 @@ static void t1xxp_t1_framer_start(struct t1xxp *wc)
 	int i;
 	char *coding, *framing;
 	unsigned long endjiffies;
-	int alreadyrunning = wc->span.flags & ZT_FLAG_RUNNING;
+	int alreadyrunning = wc->span.flags & DAHDI_FLAG_RUNNING;
 	unsigned long flags;
 
 	spin_lock_irqsave(&wc->lock, flags);
 
 	/* Build up config */
 	i = 0x20;
-	if (wc->span.lineconfig & ZT_CONFIG_ESF) {
+	if (wc->span.lineconfig & DAHDI_CONFIG_ESF) {
 		coding = "ESF";
 		i = 0x88;
 	} else {
 		coding = "SF";
 	}
-	if (wc->span.lineconfig & ZT_CONFIG_B8ZS) {
+	if (wc->span.lineconfig & DAHDI_CONFIG_B8ZS) {
 		framing = "B8ZS";
 		i |= 0x44;
 	} else {
 		framing = "AMI";
 	}
 	__t1_set_reg(wc, 0x38, i);
-	if (!(wc->span.lineconfig & ZT_CONFIG_ESF)) {
+	if (!(wc->span.lineconfig & DAHDI_CONFIG_ESF)) {
 		/* 1c in FDL bit */
 		__t1_set_reg(wc, 0x7e, 0x1c);
 	} else {
@@ -401,7 +401,7 @@ static void t1xxp_t1_framer_start(struct t1xxp *wc)
 		/* Reset LIRST bit and reset elastic stores */
 		__t1_set_reg(wc, 0xa, 0x30);
 
-		wc->span.flags |= ZT_FLAG_RUNNING;
+		wc->span.flags |= DAHDI_FLAG_RUNNING;
 	}
 	spin_unlock_irqrestore(&wc->lock, flags);
 }
@@ -411,7 +411,7 @@ static void t1xxp_e1_framer_start(struct t1xxp *wc)
 	int i;
 	char *coding, *framing;
 	unsigned long endjiffies;
-	int alreadyrunning = wc->span.flags & ZT_FLAG_RUNNING;
+	int alreadyrunning = wc->span.flags & DAHDI_FLAG_RUNNING;
 	unsigned long flags;
 	char *crcing = "";
 	unsigned char ccr1, tcr1, tcr2;
@@ -422,20 +422,20 @@ static void t1xxp_e1_framer_start(struct t1xxp *wc)
 	ccr1 = 0;
 	tcr1 = 8;
 	tcr2 = 0;
-	if (wc->span.lineconfig & ZT_CONFIG_CCS) {
+	if (wc->span.lineconfig & DAHDI_CONFIG_CCS) {
 		coding = "CCS"; /* Receive CCS */
 		ccr1 |= 8;
 	} else {
 		tcr1 |= 0x20;
 		coding = "CAS";
 	}
-	if (wc->span.lineconfig & ZT_CONFIG_HDB3) {
+	if (wc->span.lineconfig & DAHDI_CONFIG_HDB3) {
 		ccr1 |= 0x44;		/* TX/RX HDB3 */
 		framing = "HDB3";
 	} else {
 		framing = "AMI";
 	}
-	if (wc->span.lineconfig & ZT_CONFIG_CRC4) {
+	if (wc->span.lineconfig & DAHDI_CONFIG_CRC4) {
 		ccr1 |= 0x11;
 		tcr2 |= 0x02;
 		crcing = " with CRC4";
@@ -473,7 +473,7 @@ static void t1xxp_e1_framer_start(struct t1xxp *wc)
 
 		/* Reset LIRST bit and reset elastic stores */
 
-		wc->span.flags |= ZT_FLAG_RUNNING;
+		wc->span.flags |= DAHDI_FLAG_RUNNING;
 	}
 	spin_unlock_irqrestore(&wc->lock, flags);
 }
@@ -552,7 +552,7 @@ static int t1xxp_framer_hard_reset(struct t1xxp *wc)
 	return 0;
 }
 
-static int t1xxp_rbsbits(struct zt_chan *chan, int bits)
+static int t1xxp_rbsbits(struct dahdi_chan *chan, int bits)
 {
 	struct t1xxp *wc = chan->pvt;
 	unsigned long flags;
@@ -577,14 +577,14 @@ static int t1xxp_rbsbits(struct zt_chan *chan, int bits)
 
 		mask = (1 << o);
 
-		if (bits & ZT_ABIT) {
+		if (bits & DAHDI_ABIT) {
 			/* Set A-bit */
 			wc->txsiga[b] |= mask;
 		} else {
 			/* Clear A-bit */
 			wc->txsiga[b] &= ~mask;
 		}
-		if (bits & ZT_BBIT) {
+		if (bits & DAHDI_BBIT) {
 			/* Set B-bit */
 			wc->txsigb[b] |= mask;
 		} else {
@@ -600,7 +600,7 @@ static int t1xxp_rbsbits(struct zt_chan *chan, int bits)
 	return 0;
 }
 
-static int t1xxp_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
+static int t1xxp_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data)
 {
 	switch(cmd) {
 	default:
@@ -608,19 +608,19 @@ static int t1xxp_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 	}
 }
 
-static int t1xxp_startup(struct zt_span *span)
+static int t1xxp_startup(struct dahdi_span *span)
 {
 	struct t1xxp *wc = span->pvt;
 
-	int i,alreadyrunning = span->flags & ZT_FLAG_RUNNING;
+	int i,alreadyrunning = span->flags & DAHDI_FLAG_RUNNING;
 
 	/* initialize the start value for the entire chunk of last ec buffer */
 	for(i = 0; i < span->channels; i++)
 	{
 		memset(wc->ec_chunk1[i],
-			ZT_LIN2X(0,&span->chans[i]),ZT_CHUNKSIZE);
+			DAHDI_LIN2X(0,&span->chans[i]),DAHDI_CHUNKSIZE);
 		memset(wc->ec_chunk2[i],
-			ZT_LIN2X(0,&span->chans[i]),ZT_CHUNKSIZE);
+			DAHDI_LIN2X(0,&span->chans[i]),DAHDI_CHUNKSIZE);
 	}
 
 	/* Reset framer with proper parameters and start */
@@ -634,12 +634,12 @@ static int t1xxp_startup(struct zt_span *span)
 		/* Only if we're not already going */
 		t1xxp_enable_interrupts(wc);
 		t1xxp_start_dma(wc);
-		span->flags |= ZT_FLAG_RUNNING;
+		span->flags |= DAHDI_FLAG_RUNNING;
 	}
 	return 0;
 }
 
-static int t1xxp_shutdown(struct zt_span *span)
+static int t1xxp_shutdown(struct dahdi_span *span)
 {
 	struct t1xxp *wc = span->pvt;
 	unsigned long flags;
@@ -647,14 +647,14 @@ static int t1xxp_shutdown(struct zt_span *span)
 	spin_lock_irqsave(&wc->lock, flags);
 	__t1xxp_stop_dma(wc);
 	__t1xxp_disable_interrupts(wc);
-	span->flags &= ~ZT_FLAG_RUNNING;
+	span->flags &= ~DAHDI_FLAG_RUNNING;
 	spin_unlock_irqrestore(&wc->lock, flags);
 
 	t1xxp_framer_hard_reset(wc);
 	return 0;
 }
 
-static int t1xxp_maint(struct zt_span *span, int cmd)
+static int t1xxp_maint(struct dahdi_span *span, int cmd)
 {
 	struct t1xxp *wc = span->pvt;
 	int res = 0;
@@ -662,18 +662,18 @@ static int t1xxp_maint(struct zt_span *span, int cmd)
 	spin_lock_irqsave(&wc->lock, flags);
 	if (wc->ise1) {
 		switch(cmd) {
-		case ZT_MAINT_NONE:
+		case DAHDI_MAINT_NONE:
 			__t1_set_reg(wc,0xa8,0); /* no loops */
 			break;
-		case ZT_MAINT_LOCALLOOP:
+		case DAHDI_MAINT_LOCALLOOP:
 			__t1_set_reg(wc,0xa8,0x40); /* local loop */
 			break;
-		case ZT_MAINT_REMOTELOOP:
+		case DAHDI_MAINT_REMOTELOOP:
 			__t1_set_reg(wc,0xa8,0x80); /* remote loop */
 			break;
-		case ZT_MAINT_LOOPUP:
-		case ZT_MAINT_LOOPDOWN:
-		case ZT_MAINT_LOOPSTOP:
+		case DAHDI_MAINT_LOOPUP:
+		case DAHDI_MAINT_LOOPDOWN:
+		case DAHDI_MAINT_LOOPSTOP:
 			res = -ENOSYS;
 			break;
 		default:
@@ -683,29 +683,29 @@ static int t1xxp_maint(struct zt_span *span, int cmd)
 		}
 	} else {
 		switch(cmd) {
-	    case ZT_MAINT_NONE:
+	    case DAHDI_MAINT_NONE:
 			__t1_set_reg(wc,0x19,0); /* no local loop */
 			__t1_set_reg(wc,0x0a,0); /* no remote loop */
 			break;
-	    case ZT_MAINT_LOCALLOOP:
+	    case DAHDI_MAINT_LOCALLOOP:
 			__t1_set_reg(wc,0x19,0x40); /* local loop */
 			__t1_set_reg(wc,0x0a,0); /* no remote loop */
 			break;
-	    case ZT_MAINT_REMOTELOOP:
+	    case DAHDI_MAINT_REMOTELOOP:
 			__t1_set_reg(wc,0x1e,0); /* no local loop */
 			__t1_set_reg(wc,0x0a,0x40); /* remote loop */
 			break;
-	    case ZT_MAINT_LOOPUP:
+	    case DAHDI_MAINT_LOOPUP:
 			__t1_set_reg(wc,0x30,2); /* send loopup code */
 			__t1_set_reg(wc,0x12,0x22); /* send loopup code */
 			__t1_set_reg(wc,0x13,0x80); /* send loopup code */
 			break;
-	    case ZT_MAINT_LOOPDOWN:
+	    case DAHDI_MAINT_LOOPDOWN:
 			__t1_set_reg(wc,0x30,2); /* send loopdown code */
 			__t1_set_reg(wc,0x12,0x62); /* send loopdown code */
 			__t1_set_reg(wc,0x13,0x90); /* send loopdown code */
 			break;
-	    case ZT_MAINT_LOOPSTOP:
+	    case DAHDI_MAINT_LOOPSTOP:
 			__t1_set_reg(wc,0x30,0);	/* stop sending loopup code */
 			break;
 	    default:
@@ -717,11 +717,11 @@ static int t1xxp_maint(struct zt_span *span, int cmd)
 	return res;
 }
 
-static int t1xxp_chanconfig(struct zt_chan *chan, int sigtype)
+static int t1xxp_chanconfig(struct dahdi_chan *chan, int sigtype)
 {
 	struct t1xxp *wc = chan->pvt;
 	unsigned long flags;
-	int alreadyrunning = chan->span->flags & ZT_FLAG_RUNNING;
+	int alreadyrunning = chan->span->flags & DAHDI_FLAG_RUNNING;
 
 	spin_lock_irqsave(&wc->lock, flags);
 
@@ -732,14 +732,14 @@ static int t1xxp_chanconfig(struct zt_chan *chan, int sigtype)
 	return 0;
 }
 
-static int t1xxp_spanconfig(struct zt_span *span, struct zt_lineconfig *lc)
+static int t1xxp_spanconfig(struct dahdi_span *span, struct dahdi_lineconfig *lc)
 {
 	struct t1xxp *wc = span->pvt;
 
 	/* Do we want to SYNC on receive or not */
 	wc->sync = lc->sync;
 	/* If already running, apply changes immediately */
-	if (span->flags & ZT_FLAG_RUNNING)
+	if (span->flags & DAHDI_FLAG_RUNNING)
 		return t1xxp_startup(span);
 
 	return 0;
@@ -773,31 +773,31 @@ static int t1xxp_software_init(struct t1xxp *wc)
 	wc->span.open = t1xxp_open;
 	wc->span.close = t1xxp_close;
 	wc->span.chans = wc->chans;
-	wc->span.flags = ZT_FLAG_RBS;
+	wc->span.flags = DAHDI_FLAG_RBS;
 	wc->span.ioctl = t1xxp_ioctl;
 	wc->span.pvt = wc;
 	if (wc->ise1) {
 		wc->span.channels = 31;
-		wc->span.deflaw = ZT_LAW_ALAW;
-		wc->span.linecompat = ZT_CONFIG_HDB3 | ZT_CONFIG_CCS | ZT_CONFIG_CRC4;
+		wc->span.deflaw = DAHDI_LAW_ALAW;
+		wc->span.linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 		wc->span.spantype = "E1";
 	} else {
 		wc->span.channels = 24;
-		wc->span.deflaw = ZT_LAW_MULAW;
-		wc->span.linecompat = ZT_CONFIG_AMI | ZT_CONFIG_B8ZS | ZT_CONFIG_D4 | ZT_CONFIG_ESF;
+		wc->span.deflaw = DAHDI_LAW_MULAW;
+		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
 		wc->span.spantype = "T1";
 	}
 	init_waitqueue_head(&wc->span.maintq);
 	for (x=0;x<wc->span.channels;x++) {
 		sprintf(wc->chans[x].name, "WCT1/%d/%d", wc->num, x + 1);
-		wc->chans[x].sigcap = ZT_SIG_EM | ZT_SIG_CLEAR | ZT_SIG_EM_E1 | 
-				      ZT_SIG_FXSLS | ZT_SIG_FXSGS | 
-				      ZT_SIG_FXSKS | ZT_SIG_FXOLS | ZT_SIG_DACS_RBS |
-				      ZT_SIG_FXOGS | ZT_SIG_FXOKS | ZT_SIG_CAS | ZT_SIG_SF;
+		wc->chans[x].sigcap = DAHDI_SIG_EM | DAHDI_SIG_CLEAR | DAHDI_SIG_EM_E1 | 
+				      DAHDI_SIG_FXSLS | DAHDI_SIG_FXSGS | 
+				      DAHDI_SIG_FXSKS | DAHDI_SIG_FXOLS | DAHDI_SIG_DACS_RBS |
+				      DAHDI_SIG_FXOGS | DAHDI_SIG_FXOKS | DAHDI_SIG_CAS | DAHDI_SIG_SF;
 		wc->chans[x].pvt = wc;
 		wc->chans[x].chanpos = x + 1;
 	}
-	if (zt_register(&wc->span, 0)) {
+	if (dahdi_register(&wc->span, 0)) {
 		printk("Unable to register span with zaptel\n");
 		return -1;
 	}
@@ -809,7 +809,7 @@ static inline void __handle_leds(struct t1xxp *wc)
 	int oldreg;
 	wc->blinktimer++;
 
-	if (wc->span.alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE)) {
+	if (wc->span.alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE)) {
 		/* Red/Blue alarm */
 #ifdef FANCY_ALARM
 		if (wc->blinktimer == (altab[wc->alarmpos] >> 1)) {
@@ -834,7 +834,7 @@ static inline void __handle_leds(struct t1xxp *wc)
 			wc->blinktimer = 0;
 		}
 #endif
-	} else if (wc->span.alarms & ZT_ALARM_YELLOW) {
+	} else if (wc->span.alarms & DAHDI_ALARM_YELLOW) {
 		/* Yellow Alarm */
 		if (!(wc->blinktimer % 2)) 
 			wc->ledtestreg = (wc->ledtestreg | BIT_LED1) & ~BIT_LED0;
@@ -844,11 +844,11 @@ static inline void __handle_leds(struct t1xxp *wc)
 	} else {
 		/* No Alarm */
 		oldreg = wc->ledtestreg;
-		if (wc->span.maintstat != ZT_MAINT_NONE)
+		if (wc->span.maintstat != DAHDI_MAINT_NONE)
 			wc->ledtestreg |= BIT_TEST;
 		else
 			wc->ledtestreg &= ~BIT_TEST;
-		if (wc->span.flags & ZT_FLAG_RUNNING)
+		if (wc->span.flags & DAHDI_FLAG_RUNNING)
 			wc->ledtestreg = (wc->ledtestreg | BIT_LED0) & ~BIT_LED1;
 		else
 			wc->ledtestreg = wc->ledtestreg & ~(BIT_LED0 | BIT_LED1);
@@ -868,19 +868,19 @@ static void t1xxp_transmitprep(struct t1xxp *wc, int ints)
 		txbuf = wc->writechunk;
 	} else {
 		/* Just finished sending second buffer, fill it now */
-		txbuf = wc->writechunk + 32 * ZT_CHUNKSIZE;
+		txbuf = wc->writechunk + 32 * DAHDI_CHUNKSIZE;
 	}
-	zt_transmit(&wc->span);
+	dahdi_transmit(&wc->span);
 	for (x=0;x<wc->offset;x++)
 		txbuf[x] = wc->tempo[x];
-	for (y=0;y<ZT_CHUNKSIZE;y++) {
+	for (y=0;y<DAHDI_CHUNKSIZE;y++) {
 		for (x=0;x<wc->span.channels;x++) {
 			pos = y * 32 + wc->chanmap[x] + wc->offset;
 			/* Put channel number as outgoing data */
-			if (pos < 32 * ZT_CHUNKSIZE)
+			if (pos < 32 * DAHDI_CHUNKSIZE)
 				txbuf[pos] = wc->chans[x].writechunk[y];
 			else
-				wc->tempo[pos - 32 * ZT_CHUNKSIZE] = wc->chans[x].writechunk[y];
+				wc->tempo[pos - 32 * DAHDI_CHUNKSIZE] = wc->chans[x].writechunk[y];
 		}
 	}
 }
@@ -895,10 +895,10 @@ static void t1xxp_receiveprep(struct t1xxp *wc, int ints)
 	if (ints & 0x04) {
 		/* Just received first buffer */
 		rxbuf = wc->readchunk;
-		canary = (unsigned int *)(wc->readchunk + ZT_CHUNKSIZE * 64 - 4);
+		canary = (unsigned int *)(wc->readchunk + DAHDI_CHUNKSIZE * 64 - 4);
 	} else {
-		rxbuf = wc->readchunk + ZT_CHUNKSIZE * 32;
-		canary = (unsigned int *)(wc->readchunk + ZT_CHUNKSIZE * 32 - 4);
+		rxbuf = wc->readchunk + DAHDI_CHUNKSIZE * 32;
+		canary = (unsigned int *)(wc->readchunk + DAHDI_CHUNKSIZE * 32 - 4);
 	}
 	oldcan = *canary;
 	if (((oldcan & 0xffff0000) >> 16) != CANARY) {
@@ -909,7 +909,7 @@ static void t1xxp_receiveprep(struct t1xxp *wc, int ints)
 		if (debug) printk("Expecting bottom %d, got %d\n", wc->canary - 1, oldcan & 0xffff);
 		wc->span.irqmisses++;
 	}
-	for (y=0;y<ZT_CHUNKSIZE;y++) {
+	for (y=0;y<DAHDI_CHUNKSIZE;y++) {
 		for (x=0;x<wc->span.channels;x++) {
 			/* XXX Optimize, remove * and + XXX */
 			/* Must map received channels into appropriate data */
@@ -949,15 +949,15 @@ static void t1xxp_receiveprep(struct t1xxp *wc, int ints)
 		} 
 	}
 	/* Store the next canary */
-	canary = (unsigned int *)(rxbuf + ZT_CHUNKSIZE * 32 - 4);
+	canary = (unsigned int *)(rxbuf + DAHDI_CHUNKSIZE * 32 - 4);
 	*canary = (wc->canary++) | (CANARY << 16);
 	for (x=0;x<wc->span.channels;x++) {
-		zt_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, 
+		dahdi_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, 
 			wc->ec_chunk2[x]);
-		memcpy(wc->ec_chunk2[x],wc->ec_chunk1[x],ZT_CHUNKSIZE);
-		memcpy(wc->ec_chunk1[x],wc->chans[x].writechunk,ZT_CHUNKSIZE);
+		memcpy(wc->ec_chunk2[x],wc->ec_chunk1[x],DAHDI_CHUNKSIZE);
+		memcpy(wc->ec_chunk1[x],wc->chans[x].writechunk,DAHDI_CHUNKSIZE);
 	}
-	zt_receive(&wc->span);
+	dahdi_receive(&wc->span);
 }
 
 static void t1xxp_check_sigbits(struct t1xxp *wc, int x)
@@ -972,18 +972,18 @@ static void t1xxp_check_sigbits(struct t1xxp *wc, int x)
 			a = __t1_get_reg(wc, 0x31 + i);
 			/* Get high channel in low bits */
 			rxs = (a & 0xf);
-			if (!(wc->chans[i+16].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->chans[i+16].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->chans[i+16].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->chans[i+16], rxs);
+					dahdi_rbsbits(&wc->chans[i+16], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
 			rxs = (a >> 4) & 0xf;
-			if (!(wc->chans[i].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->chans[i].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->chans[i].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->chans[i], rxs);
+					dahdi_rbsbits(&wc->chans[i], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
@@ -995,13 +995,13 @@ static void t1xxp_check_sigbits(struct t1xxp *wc, int x)
 			i = x * 8 + y;
 				rxs = 0;
 			if (a & (1 << y))
-				rxs |= ZT_ABIT;
+				rxs |= DAHDI_ABIT;
 			if (b & (1 << y))
-				rxs |= ZT_BBIT;
-			if (!(wc->chans[i].sig & ZT_SIG_CLEAR)) {
+				rxs |= DAHDI_BBIT;
+			if (!(wc->chans[i].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->chans[i].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->chans[i], rxs);
+					dahdi_rbsbits(&wc->chans[i], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
@@ -1036,7 +1036,7 @@ static void t1xxp_check_alarms(struct t1xxp *wc)
 	alarms = 0;
 
 	/* And consider only carrier alarms */
-	wc->span.alarms &= (ZT_ALARM_RED | ZT_ALARM_BLUE | ZT_ALARM_NOTOPEN);
+	wc->span.alarms &= (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | DAHDI_ALARM_NOTOPEN);
 
 	if (wc->ise1) {
 		/* XXX Implement me XXX */
@@ -1044,10 +1044,10 @@ static void t1xxp_check_alarms(struct t1xxp *wc)
 		/* Detect loopup code if we're not sending one */
 		if ((!wc->span.mainttimer) && (c & 0x80)) {
 			/* Loop-up code detected */
-			if ((wc->loopupcnt++ > 80)  && (wc->span.maintstat != ZT_MAINT_REMOTELOOP)) {
+			if ((wc->loopupcnt++ > 80)  && (wc->span.maintstat != DAHDI_MAINT_REMOTELOOP)) {
 				__t1_set_reg(wc, 0x1e, 0);	/* No local loop */
 				__t1_set_reg(wc, 0x0a, 0x40);	/* Remote Loop */
-				wc->span.maintstat = ZT_MAINT_REMOTELOOP;
+				wc->span.maintstat = DAHDI_MAINT_REMOTELOOP;
 			}
 		} else {
 			wc->loopupcnt = 0;
@@ -1055,39 +1055,39 @@ static void t1xxp_check_alarms(struct t1xxp *wc)
 		/* Same for loopdown code */
 		if ((!wc->span.mainttimer) && (c & 0x40)) {
 			/* Loop-down code detected */
-			if ((wc->loopdowncnt++ > 80)  && (wc->span.maintstat == ZT_MAINT_REMOTELOOP)) {
+			if ((wc->loopdowncnt++ > 80)  && (wc->span.maintstat == DAHDI_MAINT_REMOTELOOP)) {
 				__t1_set_reg(wc, 0x1e, 0);	/* No local loop */
 				__t1_set_reg(wc, 0x0a, 0x0);	/* No remote Loop */
-				wc->span.maintstat = ZT_MAINT_NONE;
+				wc->span.maintstat = DAHDI_MAINT_NONE;
 			}
 		} else
 			wc->loopdowncnt = 0;
 	}
 
-	if (wc->span.lineconfig & ZT_CONFIG_NOTOPEN) {
+	if (wc->span.lineconfig & DAHDI_CONFIG_NOTOPEN) {
 		for (x=0,j=0;x < wc->span.channels;x++)
-			if ((wc->chans[x].flags & ZT_FLAG_OPEN) ||
-			    (wc->chans[x].flags & ZT_FLAG_NETDEV))
+			if ((wc->chans[x].flags & DAHDI_FLAG_OPEN) ||
+			    (wc->chans[x].flags & DAHDI_FLAG_NETDEV))
 				j++;
 		if (!j)
-			alarms |= ZT_ALARM_NOTOPEN;
+			alarms |= DAHDI_ALARM_NOTOPEN;
 	}
 
 	if (wc->ise1) {
 		if (c & 0x9) 
-			alarms |= ZT_ALARM_RED;
+			alarms |= DAHDI_ALARM_RED;
 		if (c & 0x2)
-			alarms |= ZT_ALARM_BLUE;
+			alarms |= DAHDI_ALARM_BLUE;
 	} else {
 		/* Check actual alarm status */
 		if (c & 0x3) 
-			alarms |= ZT_ALARM_RED;
+			alarms |= DAHDI_ALARM_RED;
 		if (c & 0x8)
-			alarms |= ZT_ALARM_BLUE;
+			alarms |= DAHDI_ALARM_BLUE;
 	}
 	/* Keep track of recovering */
 	if ((!alarms) && wc->span.alarms)
-		wc->alarmtimer = ZT_ALARMSETTLE_TIME;
+		wc->alarmtimer = DAHDI_ALARMSETTLE_TIME;
 
 	/* If receiving alarms, go into Yellow alarm state */
 	if (alarms && (!wc->span.alarms)) {
@@ -1103,7 +1103,7 @@ static void t1xxp_check_alarms(struct t1xxp *wc)
 	if (wc->span.alarms != alarms) {
 		d = __control_get_reg(wc, WC_CLOCK); 
 		start_alarm(wc);
-		if (!(alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE | ZT_ALARM_LOOPBACK)) &&
+		if (!(alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | DAHDI_ALARM_LOOPBACK)) &&
 		    wc->sync) {
 			/* Use the recieve signalling */
 			wc->span.syncsrc = wc->span.spanno;
@@ -1115,15 +1115,15 @@ static void t1xxp_check_alarms(struct t1xxp *wc)
 		__control_set_reg(wc, WC_CLOCK, d);  
 	}
 	if (wc->alarmtimer)
-		alarms |= ZT_ALARM_RECOVER;
+		alarms |= DAHDI_ALARM_RECOVER;
 	if (c & 0x4)
-		alarms |= ZT_ALARM_YELLOW;
+		alarms |= DAHDI_ALARM_YELLOW;
 
 	wc->span.alarms = alarms;
 
 	spin_unlock_irqrestore(&wc->lock, flags);
 
-	zt_alarm_notify(&wc->span);
+	dahdi_alarm_notify(&wc->span);
 }
 
 static void t1xxp_do_counters(struct t1xxp *wc)
@@ -1133,7 +1133,7 @@ static void t1xxp_do_counters(struct t1xxp *wc)
 	spin_lock_irqsave(&wc->lock, flags);
 	if (wc->alarmtimer) {
 		if (!--wc->alarmtimer) {
-			wc->span.alarms &= ~(ZT_ALARM_RECOVER);
+			wc->span.alarms &= ~(DAHDI_ALARM_RECOVER);
 			/* Clear yellow alarm */
 #if 0
 			printk("Coming out of alarm\n");
@@ -1143,7 +1143,7 @@ static void t1xxp_do_counters(struct t1xxp *wc)
 			else
 				__t1_set_reg(wc, 0x35, 0x10);
 			spin_unlock_irqrestore(&wc->lock, flags);
-			zt_alarm_notify(&wc->span);
+			dahdi_alarm_notify(&wc->span);
 			spin_lock_irqsave(&wc->lock, flags);
 		}
 	}
@@ -1242,15 +1242,15 @@ static int t1xxp_hardware_init(struct t1xxp *wc)
 	/* Start at writedma */
 	outl(wc->writedma,                    wc->ioaddr + WC_DMAWS);		/* Write start */
 	/* First frame */
-	outl(wc->writedma + ZT_CHUNKSIZE * 32 - 4, wc->ioaddr + WC_DMAWI);		/* Middle (interrupt) */
+	outl(wc->writedma + DAHDI_CHUNKSIZE * 32 - 4, wc->ioaddr + WC_DMAWI);		/* Middle (interrupt) */
 	/* Second frame */
-	outl(wc->writedma + ZT_CHUNKSIZE * 32 * 2 - 4, wc->ioaddr + WC_DMAWE);			/* End */
+	outl(wc->writedma + DAHDI_CHUNKSIZE * 32 * 2 - 4, wc->ioaddr + WC_DMAWE);			/* End */
 	
 	outl(wc->readdma,                    	 wc->ioaddr + WC_DMARS);	/* Read start */
 	/* First frame */
-	outl(wc->readdma + ZT_CHUNKSIZE * 32 - 4, 	 wc->ioaddr + WC_DMARI);	/* Middle (interrupt) */
+	outl(wc->readdma + DAHDI_CHUNKSIZE * 32 - 4, 	 wc->ioaddr + WC_DMARI);	/* Middle (interrupt) */
 	/* Second frame */
-	outl(wc->readdma + ZT_CHUNKSIZE * 32 * 2 - 4, wc->ioaddr + WC_DMARE);	/* End */
+	outl(wc->readdma + DAHDI_CHUNKSIZE * 32 * 2 - 4, wc->ioaddr + WC_DMARE);	/* End */
 	
 	if (debug) printk("Setting up DMA (write/read = %08lx/%08lx)\n", (long)wc->writedma, (long)wc->readdma);
 
@@ -1297,22 +1297,22 @@ static int __devinit t1xxp_init_one(struct pci_dev *pdev, const struct pci_devic
 
 			wc->writechunk = 
 				/* 32 channels, Double-buffer, Read/Write */
-				(unsigned char *)pci_alloc_consistent(pdev, ZT_MAX_CHUNKSIZE * 32 * 2 * 2, &wc->writedma);
+				(unsigned char *)pci_alloc_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 32 * 2 * 2, &wc->writedma);
 			if (!wc->writechunk) {
 				printk("wct1xxp: Unable to allocate DMA-able memory\n");
 				return -ENOMEM;
 			}
 
 			/* Read is after the whole write piece (in bytes) */
-			wc->readchunk = wc->writechunk + ZT_CHUNKSIZE * 32 * 2;
+			wc->readchunk = wc->writechunk + DAHDI_CHUNKSIZE * 32 * 2;
 
 			/* Same thing...  */
-			wc->readdma = wc->writedma + ZT_CHUNKSIZE * 32 * 2;
+			wc->readdma = wc->writedma + DAHDI_CHUNKSIZE * 32 * 2;
 
 			/* Initialize Write/Buffers to all blank data */
-			memset((void *)wc->writechunk,0x00,ZT_MAX_CHUNKSIZE * 2 * 2 * 32);
+			memset((void *)wc->writechunk,0x00,DAHDI_MAX_CHUNKSIZE * 2 * 2 * 32);
 			/* Initialize canary */
-			canary = (unsigned int *)(wc->readchunk + ZT_CHUNKSIZE * 64 - 4);
+			canary = (unsigned int *)(wc->readchunk + DAHDI_CHUNKSIZE * 64 - 4);
 			*canary = (CANARY << 16) | (0xffff);
 
 			/* Enable bus mastering */
@@ -1373,7 +1373,7 @@ static void __devexit t1xxp_remove_one(struct pci_dev *pdev)
 		t1xxp_stop_stuff(wc);
 
 		/* Immediately free resources */
-		pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 32 * 4, (void *)wc->writechunk, wc->writedma);
+		pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 32 * 4, (void *)wc->writechunk, wc->writedma);
 		free_irq(pdev->irq, wc);
 
 		/* Reset PCI chip and registers */
diff --git a/drivers/dahdi/wct4xxp/base.c b/drivers/dahdi/wct4xxp/base.c
index 26b08a9..7608f73 100644
--- a/drivers/dahdi/wct4xxp/base.c
+++ b/drivers/dahdi/wct4xxp/base.c
@@ -258,18 +258,18 @@ struct t4_span {
 #ifdef SUPPORT_GEN1
 	int e1check;			/* E1 check */
 #endif
-	struct zt_span span;
+	struct dahdi_span span;
 	unsigned char txsigs[16];	/* Transmit sigs */
 	int loopupcnt;
 	int loopdowncnt;
 #ifdef SUPPORT_GEN1
-	unsigned char ec_chunk1[31][ZT_CHUNKSIZE]; /* first EC chunk buffer */
-	unsigned char ec_chunk2[31][ZT_CHUNKSIZE]; /* second EC chunk buffer */
+	unsigned char ec_chunk1[31][DAHDI_CHUNKSIZE]; /* first EC chunk buffer */
+	unsigned char ec_chunk2[31][DAHDI_CHUNKSIZE]; /* second EC chunk buffer */
 #endif
 	int irqmisses;
 	
 	/* HDLC controller fields */
-	struct zt_chan *sigchan;
+	struct dahdi_chan *sigchan;
 	unsigned char sigmode;
 	int sigactive;
 	int frames_out;
@@ -285,7 +285,7 @@ struct t4_span {
 #ifdef ENABLE_WORKQUEUES
 	struct work_struct swork;
 #endif	
-	struct zt_chan chans[0];		/* Individual channels */
+	struct dahdi_chan chans[0];		/* Individual channels */
 };
 
 struct t4 {
@@ -355,15 +355,15 @@ static void t4_vpm450_init(struct t4 *wc);
 static void t4_vpm_set_dtmf_threshold(struct t4 *wc, unsigned int threshold);
 #endif
 static void __set_clear(struct t4 *wc, int span);
-static int t4_startup(struct zt_span *span);
-static int t4_shutdown(struct zt_span *span);
-static int t4_rbsbits(struct zt_chan *chan, int bits);
-static int t4_maint(struct zt_span *span, int cmd);
+static int t4_startup(struct dahdi_span *span);
+static int t4_shutdown(struct dahdi_span *span);
+static int t4_rbsbits(struct dahdi_chan *chan, int bits);
+static int t4_maint(struct dahdi_span *span, int cmd);
 #ifdef SUPPORT_GEN1
 static int t4_reset_dma(struct t4 *wc);
 #endif
-static void t4_hdlc_hard_xmit(struct zt_chan *chan);
-static int t4_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data);
+static void t4_hdlc_hard_xmit(struct dahdi_chan *chan);
+static int t4_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data);
 static void t4_tsi_assign(struct t4 *wc, int fromspan, int fromchan, int tospan, int tochan);
 static void t4_tsi_unassign(struct t4 *wc, int tospan, int tochan);
 static void __t4_set_timing_source(struct t4 *wc, int unit, int master, int slave);
@@ -760,20 +760,20 @@ static void t4_check_vpm450(struct t4 *wc)
 					   guessed it.  */
 					if (test_bit(channel, &wc->tspans[span]->dtmfmutemask)) {
 						unsigned long flags;
-						struct zt_chan *chan = &wc->tspans[span]->span.chans[channel];
+						struct dahdi_chan *chan = &wc->tspans[span]->span.chans[channel];
 						int y;
 						spin_lock_irqsave(&chan->lock, flags);
 						for (y=0;y<chan->numbufs;y++) {
 							if ((chan->inreadbuf > -1) && (chan->readidx[y]))
-								memset(chan->readbuf[chan->inreadbuf], ZT_XLAW(0, chan), chan->readidx[y]);
+								memset(chan->readbuf[chan->inreadbuf], DAHDI_XLAW(0, chan), chan->readidx[y]);
 						}
 						spin_unlock_irqrestore(&chan->lock, flags);
 					}
 					set_bit(channel, &wc->tspans[span]->dtmfactive);
-					zt_qevent_lock(&wc->tspans[span]->span.chans[channel], (ZT_EVENT_DTMFDOWN | tone));
+					dahdi_qevent_lock(&wc->tspans[span]->span.chans[channel], (DAHDI_EVENT_DTMFDOWN | tone));
 				} else {
 					clear_bit(channel, &wc->tspans[span]->dtmfactive);
-					zt_qevent_lock(&wc->tspans[span]->span.chans[channel], (ZT_EVENT_DTMFUP | tone));
+					dahdi_qevent_lock(&wc->tspans[span]->span.chans[channel], (DAHDI_EVENT_DTMFUP | tone));
 				}
 			}
 		}
@@ -817,26 +817,26 @@ static void t4_check_vpm400(struct t4 *wc, unsigned int newio)
 				digit = vpm_digits[regbyte];
 				if (!(wc->tspans[0]->spanflags & FLAG_VPM2GEN)) {
 					energy = t4_vpm_in(wc, x, 0x58 + channel);
-					energy = ZT_XLAW(energy, ts->chans);
+					energy = DAHDI_XLAW(energy, ts->chans);
 					ts->dtmfenergy[base] = energy;
 				}
 				set_bit(base, &ts->dtmfactive);
 				if (ts->dtmfdigit[base]) {
 					if (ts->dtmfmask & (1 << base))
-						zt_qevent_lock(&ts->span.chans[base], (ZT_EVENT_DTMFUP | ts->dtmfdigit[base]));
+						dahdi_qevent_lock(&ts->span.chans[base], (DAHDI_EVENT_DTMFUP | ts->dtmfdigit[base]));
 				}
 				ts->dtmfdigit[base] = digit;
 				if (test_bit(base, &ts->dtmfmask))
-					zt_qevent_lock(&ts->span.chans[base], (ZT_EVENT_DTMFDOWN | digit));
+					dahdi_qevent_lock(&ts->span.chans[base], (DAHDI_EVENT_DTMFDOWN | digit));
 				if (test_bit(base, &ts->dtmfmutemask)) {
 					/* Mute active receive buffer*/
 					unsigned long flags;
-					struct zt_chan *chan = &ts->span.chans[base];
+					struct dahdi_chan *chan = &ts->span.chans[base];
 					int y;
 					spin_lock_irqsave(&chan->lock, flags);
 					for (y=0;y<chan->numbufs;y++) {
 						if ((chan->inreadbuf > -1) && (chan->readidx[y]))
-							memset(chan->readbuf[chan->inreadbuf], ZT_XLAW(0, chan), chan->readidx[y]);
+							memset(chan->readbuf[chan->inreadbuf], DAHDI_XLAW(0, chan), chan->readidx[y]);
 					}
 					spin_unlock_irqrestore(&chan->lock, flags);
 				}
@@ -867,7 +867,7 @@ static void t4_check_vpm400(struct t4 *wc, unsigned int newio)
 				clear_bit(base, &ts->dtmfactive);
 				if (ts->dtmfdigit[base]) {
 					if (test_bit(base, &ts->dtmfmask))
-						zt_qevent_lock(&ts->span.chans[base], (ZT_EVENT_DTMFUP | ts->dtmfdigit[base]));
+						dahdi_qevent_lock(&ts->span.chans[base], (DAHDI_EVENT_DTMFUP | ts->dtmfdigit[base]));
 				}
 				digit = ts->dtmfdigit[base];
 				ts->dtmfdigit[base] = 0;
@@ -938,7 +938,7 @@ static inline void t4_framer_cmd_wait(struct t4 *wc, unsigned int span, int cmd)
 	t4_framer_out(wc, span, FRMR_CMDR, cmd);
 }
 
-static int hdlc_start(struct t4 *wc, unsigned int span, struct zt_chan *chan, unsigned char mode)
+static int hdlc_start(struct t4 *wc, unsigned int span, struct dahdi_chan *chan, unsigned char mode)
 {
 	struct t4_span *t = wc->tspans[span];
 	unsigned char imr0, imr1;
@@ -999,7 +999,7 @@ static void __set_clear(struct t4 *wc, int span)
 	if ((ts->spantype == TYPE_T1) || (ts->spantype == TYPE_J1)) {
 		for (i=0;i<24;i++) {
 			j = (i/8);
-			if (ts->span.chans[i].flags & ZT_FLAG_CLEAR) {
+			if (ts->span.chans[i].flags & DAHDI_FLAG_CLEAR) {
 				val |= 1 << (7 - (i % 8));
 				ts->notclear &= ~(1 << i);
 			} else
@@ -1014,7 +1014,7 @@ static void __set_clear(struct t4 *wc, int span)
 		}
 	} else {
 		for (i=0;i<31;i++) {
-			if (ts->span.chans[i].flags & ZT_FLAG_CLEAR)
+			if (ts->span.chans[i].flags & DAHDI_FLAG_CLEAR)
 				ts->notclear &= ~(1 << i);
 			else 
 				ts->notclear |= (1 << i);
@@ -1041,7 +1041,7 @@ static void set_clear(struct t4 *wc, int span)
 }
 #endif
 
-static int t4_dacs(struct zt_chan *dst, struct zt_chan *src)
+static int t4_dacs(struct dahdi_chan *dst, struct dahdi_chan *src)
 {
 	struct t4 *wc;
 	struct t4_span *ts;
@@ -1106,7 +1106,7 @@ static int t4_vpm_unit(int span, int channel)
 	return unit;
 }
 
-static int t4_echocan(struct zt_chan *chan, int eclen)
+static int t4_echocan(struct dahdi_chan *chan, int eclen)
 {
 	struct t4 *wc = chan->pvt;
 	int channel;
@@ -1145,7 +1145,7 @@ static int t4_echocan(struct zt_chan *chan, int eclen)
 }
 #endif
 
-static int t4_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
+static int t4_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data)
 {
 	struct t4_regs regs;
 	int x;
@@ -1175,18 +1175,18 @@ static int t4_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
 			return -EFAULT;
 		break;
 #ifdef VPM_SUPPORT
-	case ZT_TONEDETECT:
+	case DAHDI_TONEDETECT:
 		if (get_user(j, (int *)data))
 			return -EFAULT;
 		if (!wc->vpm)
 			return -ENOSYS;
 		if (j && (vpmdtmfsupport == 0))
 			return -ENOSYS;
-		if (j & ZT_TONEDETECT_ON)
+		if (j & DAHDI_TONEDETECT_ON)
 			set_bit(chan->chanpos - 1, &ts->dtmfmask);
 		else
 			clear_bit(chan->chanpos - 1, &ts->dtmfmask);
-		if (j & ZT_TONEDETECT_MUTE)
+		if (j & DAHDI_TONEDETECT_MUTE)
 			set_bit(chan->chanpos - 1, &ts->dtmfmutemask);
 		else
 			clear_bit(chan->chanpos - 1, &ts->dtmfmutemask);
@@ -1195,7 +1195,7 @@ static int t4_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
 			if (!wc->t1e1)
 				channel += (4 << 2);
 			channel |= chan->span->offset;
-			vpm450m_setdtmf(wc->vpm450m, channel, j & ZT_TONEDETECT_ON, j & ZT_TONEDETECT_MUTE);
+			vpm450m_setdtmf(wc->vpm450m, channel, j & DAHDI_TONEDETECT_ON, j & DAHDI_TONEDETECT_MUTE);
 		}
 		return 0;
 #endif
@@ -1210,7 +1210,7 @@ static void inline t4_hdlc_xmit_fifo(struct t4 *wc, unsigned int span, struct t4
 	int res, i, size = 32;
 	unsigned char buf[32];
 
-	res = zt_hdlc_getbuf(ts->sigchan, buf, &size);
+	res = dahdi_hdlc_getbuf(ts->sigchan, buf, &size);
 	if (debug & DEBUG_FRAMER) printk("Got buffer sized %d and res %d for %d\n", size, res, span);
 	if (size > 0) {
 		ts->sigactive = 1;
@@ -1243,7 +1243,7 @@ static void inline t4_hdlc_xmit_fifo(struct t4 *wc, unsigned int span, struct t4
 		ts->sigactive = 0;
 }
 
-static void t4_hdlc_hard_xmit(struct zt_chan *chan)
+static void t4_hdlc_hard_xmit(struct dahdi_chan *chan)
 {
 	struct t4 *wc = chan->pvt;
 	int span = chan->span->offset;
@@ -1264,29 +1264,29 @@ static void t4_hdlc_hard_xmit(struct zt_chan *chan)
 		t4_hdlc_xmit_fifo(wc, span, ts);
 }
 
-static int t4_maint(struct zt_span *span, int cmd)
+static int t4_maint(struct dahdi_span *span, int cmd)
 {
 	struct t4_span *ts = span->pvt;
 	struct t4 *wc = ts->owner;
 
 	if (ts->spantype == TYPE_E1) {
 		switch(cmd) {
-		case ZT_MAINT_NONE:
+		case DAHDI_MAINT_NONE:
 			printk("XXX Turn off local and remote loops E1 XXX\n");
 			break;
-		case ZT_MAINT_LOCALLOOP:
+		case DAHDI_MAINT_LOCALLOOP:
 			printk("XXX Turn on local loopback E1 XXX\n");
 			break;
-		case ZT_MAINT_REMOTELOOP:
+		case DAHDI_MAINT_REMOTELOOP:
 			printk("XXX Turn on remote loopback E1 XXX\n");
 			break;
-		case ZT_MAINT_LOOPUP:
+		case DAHDI_MAINT_LOOPUP:
 			printk("XXX Send loopup code E1 XXX\n");
 			break;
-		case ZT_MAINT_LOOPDOWN:
+		case DAHDI_MAINT_LOOPDOWN:
 			printk("XXX Send loopdown code E1 XXX\n");
 			break;
-		case ZT_MAINT_LOOPSTOP:
+		case DAHDI_MAINT_LOOPSTOP:
 			printk("XXX Stop sending loop codes E1 XXX\n");
 			break;
 		default:
@@ -1295,22 +1295,22 @@ static int t4_maint(struct zt_span *span, int cmd)
 		}
 	} else {
 		switch(cmd) {
-	    case ZT_MAINT_NONE:
+	    case DAHDI_MAINT_NONE:
 			printk("XXX Turn off local and remote loops T1 XXX\n");
 			break;
-	    case ZT_MAINT_LOCALLOOP:
+	    case DAHDI_MAINT_LOCALLOOP:
 			printk("XXX Turn on local loop and no remote loop XXX\n");
 			break;
-	    case ZT_MAINT_REMOTELOOP:
+	    case DAHDI_MAINT_REMOTELOOP:
 			printk("XXX Turn on remote loopup XXX\n");
 			break;
-	    case ZT_MAINT_LOOPUP:
+	    case DAHDI_MAINT_LOOPUP:
 			t4_framer_out(wc, span->offset, 0x21, 0x50);	/* FMR5: Nothing but RBS mode */
 			break;
-	    case ZT_MAINT_LOOPDOWN:
+	    case DAHDI_MAINT_LOOPDOWN:
 			t4_framer_out(wc, span->offset, 0x21, 0x60);	/* FMR5: Nothing but RBS mode */
 			break;
-	    case ZT_MAINT_LOOPSTOP:
+	    case DAHDI_MAINT_LOOPSTOP:
 			t4_framer_out(wc, span->offset, 0x21, 0x40);	/* FMR5: Nothing but RBS mode */
 			break;
 	    default:
@@ -1321,7 +1321,7 @@ static int t4_maint(struct zt_span *span, int cmd)
 	return 0;
 }
 
-static int t4_rbsbits(struct zt_chan *chan, int bits)
+static int t4_rbsbits(struct dahdi_chan *chan, int bits)
 {
 	u_char m,c;
 	int k,n,b;
@@ -1347,7 +1347,7 @@ static int t4_rbsbits(struct zt_chan *chan, int bits)
 		ts->txsigs[b] = c;
 		  /* output them to the chip */
 		__t4_framer_out(wc,k,0x71 + b,c); 
-	} else if (ts->span.lineconfig & ZT_CONFIG_D4) {
+	} else if (ts->span.lineconfig & DAHDI_CONFIG_D4) {
 		n = chan->chanpos - 1;
 		b = (n/4);
 		c = ts->txsigs[b];
@@ -1358,7 +1358,7 @@ static int t4_rbsbits(struct zt_chan *chan, int bits)
 		  /* output them to the chip */
 		__t4_framer_out(wc,k,0x70 + b,c); 
 		__t4_framer_out(wc,k,0x70 + b + 6,c); 
-	} else if (ts->span.lineconfig & ZT_CONFIG_ESF) {
+	} else if (ts->span.lineconfig & DAHDI_CONFIG_ESF) {
 		n = chan->chanpos - 1;
 		b = (n/2);
 		c = ts->txsigs[b];
@@ -1375,7 +1375,7 @@ static int t4_rbsbits(struct zt_chan *chan, int bits)
 	return 0;
 }
 
-static int t4_shutdown(struct zt_span *span)
+static int t4_shutdown(struct dahdi_span *span)
 {
 	int tspan;
 	int wasrunning;
@@ -1396,19 +1396,19 @@ static int t4_shutdown(struct zt_span *span)
 		hdlc_stop(wc, span->offset);
 	
 	spin_lock_irqsave(&wc->reglock, flags);
-	wasrunning = span->flags & ZT_FLAG_RUNNING;
+	wasrunning = span->flags & DAHDI_FLAG_RUNNING;
 
-	span->flags &= ~ZT_FLAG_RUNNING;
+	span->flags &= ~DAHDI_FLAG_RUNNING;
 	__t4_set_led(wc, span->offset, WC_OFF);
 	if (((wc->numspans == 4) && 
-	    (!(wc->tspans[0]->span.flags & ZT_FLAG_RUNNING)) &&
-	    (!(wc->tspans[1]->span.flags & ZT_FLAG_RUNNING)) &&
-	    (!(wc->tspans[2]->span.flags & ZT_FLAG_RUNNING)) &&
-	    (!(wc->tspans[3]->span.flags & ZT_FLAG_RUNNING)))
+	    (!(wc->tspans[0]->span.flags & DAHDI_FLAG_RUNNING)) &&
+	    (!(wc->tspans[1]->span.flags & DAHDI_FLAG_RUNNING)) &&
+	    (!(wc->tspans[2]->span.flags & DAHDI_FLAG_RUNNING)) &&
+	    (!(wc->tspans[3]->span.flags & DAHDI_FLAG_RUNNING)))
 	    			|| 
 	    ((wc->numspans == 2) && 
-	    (!(wc->tspans[0]->span.flags & ZT_FLAG_RUNNING)) &&
-	    (!(wc->tspans[1]->span.flags & ZT_FLAG_RUNNING)))) {
+	    (!(wc->tspans[0]->span.flags & DAHDI_FLAG_RUNNING)) &&
+	    (!(wc->tspans[1]->span.flags & DAHDI_FLAG_RUNNING)))) {
 		/* No longer in use, disable interrupts */
 		printk("TE%dXXP: Disabling interrupts since there are no active spans\n", wc->numspans);
 		set_bit(T4_STOP_DMA, &wc->checkflag);
@@ -1427,7 +1427,7 @@ static int t4_shutdown(struct zt_span *span)
 	return 0;
 }
 
-static int t4_spanconfig(struct zt_span *span, struct zt_lineconfig *lc)
+static int t4_spanconfig(struct dahdi_span *span, struct dahdi_lineconfig *lc)
 {
 	int i;
 	struct t4_span *ts = span->pvt;
@@ -1462,20 +1462,20 @@ static int t4_spanconfig(struct zt_span *span, struct zt_lineconfig *lc)
 	clear_bit(T4_STOP_DMA, &wc->checkflag);
 	
 	/* If we're already running, then go ahead and apply the changes */
-	if (span->flags & ZT_FLAG_RUNNING)
+	if (span->flags & DAHDI_FLAG_RUNNING)
 		return t4_startup(span);
 	printk("Done with spanconfig!\n");
 	return 0;
 }
 
-static int t4_chanconfig(struct zt_chan *chan, int sigtype)
+static int t4_chanconfig(struct dahdi_chan *chan, int sigtype)
 {
 	int alreadyrunning;
 	unsigned long flags;
 	struct t4 *wc = chan->pvt;
 	struct t4_span *ts = wc->tspans[chan->span->offset];
 
-	alreadyrunning = ts->span.flags & ZT_FLAG_RUNNING;
+	alreadyrunning = ts->span.flags & DAHDI_FLAG_RUNNING;
 	if (debug & DEBUG_MAIN) {
 		if (alreadyrunning)
 			printk("TE%dXXP: Reconfigured channel %d (%s) sigtype %d\n", wc->numspans, chan->channo, chan->name, sigtype);
@@ -1491,13 +1491,13 @@ static int t4_chanconfig(struct zt_chan *chan, int sigtype)
 	spin_unlock_irqrestore(&wc->reglock, flags);	
 
 	/* (re)configure signalling channel */
-	if ((sigtype == ZT_SIG_HARDHDLC) || (ts->sigchan == chan)) {
+	if ((sigtype == DAHDI_SIG_HARDHDLC) || (ts->sigchan == chan)) {
 		if (debug & DEBUG_FRAMER)
-				printk("%sonfiguring hardware HDLC on %s\n", ((sigtype == ZT_SIG_HARDHDLC) ? "C" : "Unc"), chan->name);
+				printk("%sonfiguring hardware HDLC on %s\n", ((sigtype == DAHDI_SIG_HARDHDLC) ? "C" : "Unc"), chan->name);
 		if (alreadyrunning) {
 			if (ts->sigchan)
 				hdlc_stop(wc, ts->sigchan->span->offset);
-			if (sigtype == ZT_SIG_HARDHDLC) {
+			if (sigtype == DAHDI_SIG_HARDHDLC) {
 				if (hdlc_start(wc, chan->span->offset, chan, ts->sigmode)) {
 					printk("Error initializing signalling controller\n");
 					return -1;
@@ -1511,7 +1511,7 @@ static int t4_chanconfig(struct zt_chan *chan, int sigtype)
 		}
 		else {
 			spin_lock_irqsave(&wc->reglock, flags);
-			ts->sigchan = (sigtype == ZT_SIG_HARDHDLC) ? chan : NULL;
+			ts->sigchan = (sigtype == DAHDI_SIG_HARDHDLC) ? chan : NULL;
 			spin_unlock_irqrestore(&wc->reglock, flags);
 			ts->sigactive = 0;
 		}
@@ -1519,7 +1519,7 @@ static int t4_chanconfig(struct zt_chan *chan, int sigtype)
 	return 0;
 }
 
-static int t4_open(struct zt_chan *chan)
+static int t4_open(struct dahdi_chan *chan)
 {
 #ifndef LINUX26
 	MOD_INC_USE_COUNT;
@@ -1530,7 +1530,7 @@ static int t4_open(struct zt_chan *chan)
 	return 0;
 }
 
-static int t4_close(struct zt_chan *chan)
+static int t4_close(struct dahdi_chan *chan)
 {
 #ifndef LINUX26
 	MOD_DEC_USE_COUNT;
@@ -1603,15 +1603,15 @@ static void init_spans(struct t4 *wc)
 		
 		if (ts->spantype == TYPE_T1 || ts->spantype == TYPE_J1) {
 			ts->span.channels = 24;
-			ts->span.deflaw = ZT_LAW_MULAW;
-			ts->span.linecompat = ZT_CONFIG_AMI | ZT_CONFIG_B8ZS | ZT_CONFIG_D4 | ZT_CONFIG_ESF;
+			ts->span.deflaw = DAHDI_LAW_MULAW;
+			ts->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
 		} else {
 			ts->span.channels = 31;
-			ts->span.deflaw = ZT_LAW_ALAW;
-			ts->span.linecompat = ZT_CONFIG_HDB3 | ZT_CONFIG_CCS | ZT_CONFIG_CRC4;
+			ts->span.deflaw = DAHDI_LAW_ALAW;
+			ts->span.linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 		}
 		ts->span.chans = ts->chans;
-		ts->span.flags = ZT_FLAG_RBS;
+		ts->span.flags = DAHDI_FLAG_RBS;
 		ts->span.ioctl = t4_ioctl;
 		ts->span.hdlc_hard_xmit = t4_hdlc_hard_xmit;
 		if (gen2) {
@@ -1627,10 +1627,10 @@ static void init_spans(struct t4 *wc)
 		ts->readchunk = (void *)(wc->readchunk + x * 32 * 2);
 		init_waitqueue_head(&ts->span.maintq);
 		for (y=0;y<wc->tspans[x]->span.channels;y++) {
-			struct zt_chan *mychans = ts->chans + y;
+			struct dahdi_chan *mychans = ts->chans + y;
 			sprintf(mychans->name, "TE%d/%d/%d/%d", wc->numspans, wc->num, x + 1, y + 1);
-			mychans->sigcap = ZT_SIG_EM | ZT_SIG_CLEAR | ZT_SIG_FXSLS | ZT_SIG_FXSGS | ZT_SIG_FXSKS | ZT_SIG_HARDHDLC | ZT_SIG_MTP2 |
-									 ZT_SIG_FXOLS | ZT_SIG_FXOGS | ZT_SIG_FXOKS | ZT_SIG_CAS | ZT_SIG_EM_E1 | ZT_SIG_DACS_RBS;
+			mychans->sigcap = DAHDI_SIG_EM | DAHDI_SIG_CLEAR | DAHDI_SIG_FXSLS | DAHDI_SIG_FXSGS | DAHDI_SIG_FXSKS | DAHDI_SIG_HARDHDLC | DAHDI_SIG_MTP2 |
+									 DAHDI_SIG_FXOLS | DAHDI_SIG_FXOGS | DAHDI_SIG_FXOKS | DAHDI_SIG_CAS | DAHDI_SIG_EM_E1 | DAHDI_SIG_DACS_RBS;
 			mychans->pvt = wc;
 			mychans->chanpos = y + 1;
 			if (gen2) {
@@ -1790,8 +1790,8 @@ static int __t4_findsync(struct t4 *wc)
 					if (cards[x]->tspans[i]->syncpos) {
 						nonzero = 1;
 						if ((cards[x]->tspans[i]->syncpos == p) &&
-						    !(cards[x]->tspans[i]->span.alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE | ZT_ALARM_LOOPBACK)) &&
-							(cards[x]->tspans[i]->span.flags & ZT_FLAG_RUNNING)) {
+						    !(cards[x]->tspans[i]->span.alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | DAHDI_ALARM_LOOPBACK)) &&
+							(cards[x]->tspans[i]->span.flags & DAHDI_FLAG_RUNNING)) {
 								/* This makes a good sync source */
 								newsyncsrc = cards[x]->tspans[i]->span.spanno;
 								newsyncnum = x;
@@ -1834,8 +1834,8 @@ static void __t4_set_timing_source_auto(struct t4 *wc)
 	} else {
 		for (x=0;x<wc->numspans;x++) {
 			if (wc->tspans[x]->sync) {
-				if ((wc->tspans[wc->tspans[x]->psync - 1]->span.flags & ZT_FLAG_RUNNING) && 
-					!(wc->tspans[wc->tspans[x]->psync - 1]->span.alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE) )) {
+				if ((wc->tspans[wc->tspans[x]->psync - 1]->span.flags & DAHDI_FLAG_RUNNING) && 
+					!(wc->tspans[wc->tspans[x]->psync - 1]->span.alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE) )) {
 						/* Valid timing source */
 						__t4_set_timing_source(wc, wc->tspans[x]->psync - 1, 0, 0);
 						return;
@@ -1866,14 +1866,14 @@ static void __t4_configure_t1(struct t4 *wc, int unit, int lineconfig, int txlev
 	__t4_framer_out(wc, unit, 0x1e, fmr2);
 
 	/* Configure line interface */
-	if (lineconfig & ZT_CONFIG_AMI) {
+	if (lineconfig & DAHDI_CONFIG_AMI) {
 		line = "AMI";
 		fmr0 = 0xa0;
 	} else {
 		line = "B8ZS";
 		fmr0 = 0xf0;
 	}
-	if (lineconfig & ZT_CONFIG_D4) {
+	if (lineconfig & DAHDI_CONFIG_D4) {
 		framing = "D4";
 	} else {
 		framing = "ESF";
@@ -1940,7 +1940,7 @@ static void __t4_configure_e1(struct t4 *wc, int unit, int lineconfig)
 	fmr2 = 0x03; /* FMR2: Auto transmit remote alarm, auto loss of multiframe recovery, no payload loopback */
 	if (loopback)
 		fmr2 |= 0x4;
-	if (lineconfig & ZT_CONFIG_CRC4) {
+	if (lineconfig & DAHDI_CONFIG_CRC4) {
 		fmr1 |= 0x08;	/* CRC4 transmit */
 		fmr2 |= 0xc0;	/* CRC4 receive */
 		crc4 = "/CRC4";
@@ -1949,14 +1949,14 @@ static void __t4_configure_e1(struct t4 *wc, int unit, int lineconfig)
 	__t4_framer_out(wc, unit, 0x1e, fmr2);
 
 	/* Configure line interface */
-	if (lineconfig & ZT_CONFIG_AMI) {
+	if (lineconfig & DAHDI_CONFIG_AMI) {
 		line = "AMI";
 		fmr0 = 0xa0;
 	} else {
 		line = "HDB3";
 		fmr0 = 0xf0;
 	}
-	if (lineconfig & ZT_CONFIG_CCS) {
+	if (lineconfig & DAHDI_CONFIG_CCS) {
 		framing = "CCS";
 		imr3extra = 0x28;
 	} else {
@@ -2008,7 +2008,7 @@ static void __t4_configure_e1(struct t4 *wc, int unit, int lineconfig)
 	printk("TE%dXXP: Span %d configured for %s/%s%s\n", wc->numspans, unit + 1, framing, line, crc4);
 }
 
-static int t4_startup(struct zt_span *span)
+static int t4_startup(struct dahdi_span *span)
 {
 #ifdef SUPPORT_GEN1
 	int i;
@@ -2028,16 +2028,16 @@ static int t4_startup(struct zt_span *span)
 
 	spin_lock_irqsave(&wc->reglock, flags);
 
-	alreadyrunning = span->flags & ZT_FLAG_RUNNING;
+	alreadyrunning = span->flags & DAHDI_FLAG_RUNNING;
 
 #ifdef SUPPORT_GEN1
 	/* initialize the start value for the entire chunk of last ec buffer */
 	for(i = 0; i < span->channels; i++)
 	{
 		memset(ts->ec_chunk1[i],
-			ZT_LIN2X(0,&span->chans[i]),ZT_CHUNKSIZE);
+			DAHDI_LIN2X(0,&span->chans[i]),DAHDI_CHUNKSIZE);
 		memset(ts->ec_chunk2[i],
-			ZT_LIN2X(0,&span->chans[i]),ZT_CHUNKSIZE);
+			DAHDI_LIN2X(0,&span->chans[i]),DAHDI_CHUNKSIZE);
 	}
 #endif
 	/* Force re-evaluation fo timing source */
@@ -2055,7 +2055,7 @@ static int t4_startup(struct zt_span *span)
 	__set_clear(wc, span->offset);
 	
 	if (!alreadyrunning) {
-		span->flags |= ZT_FLAG_RUNNING;
+		span->flags |= DAHDI_FLAG_RUNNING;
 		wc->spansstarted++;
 		/* enable interrupts */
 		/* Start DMA, enabling DMA interrupts on read only */
@@ -2078,7 +2078,7 @@ static int t4_startup(struct zt_span *span)
 	}
 
 	if (ts->sigchan) {
-		struct zt_chan *sigchan = ts->sigchan;
+		struct dahdi_chan *sigchan = ts->sigchan;
 
 		spin_unlock_irqrestore(&wc->reglock, flags);
 		if (hdlc_start(wc, span->offset, sigchan, ts->sigmode)) {
@@ -2118,7 +2118,7 @@ static inline void e1_check(struct t4 *wc, int span, int val)
 {
 	struct t4_span *ts = wc->tspans[span];
 	if ((ts->span.channels > 24) &&
-	    (ts->span.flags & ZT_FLAG_RUNNING) &&
+	    (ts->span.flags & DAHDI_FLAG_RUNNING) &&
 	    !(ts->span.alarms) &&
 	    (!wc->e1recover))   {
 		if (val != 0x1b) {
@@ -2154,7 +2154,7 @@ static void t4_receiveprep(struct t4 *wc, int irq)
 			dbl = 1;
 		wc->last0 = 0;
 	} else {
-		readchunk = wc->readchunk + ZT_CHUNKSIZE * 32;
+		readchunk = wc->readchunk + DAHDI_CHUNKSIZE * 32;
 		if (wc->last0) 
 			dbl = 1;
 		wc->last0 = 1;
@@ -2165,7 +2165,7 @@ static void t4_receiveprep(struct t4 *wc, int irq)
 		if (debug & DEBUG_MAIN)
 			printk("TE%dXXP: Double/missed interrupt detected\n", wc->numspans);
 	}
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		for (z=0;z<24;z++) {
 			/* All T1/E1 channels */
 			tmp = readchunk[z+1+offset];
@@ -2205,25 +2205,25 @@ static void t4_receiveprep(struct t4 *wc, int irq)
 		readchunk += 32;
 	}
 	for (x=0;x<wc->numspans;x++) {
-		if (wc->tspans[x]->span.flags & ZT_FLAG_RUNNING) {
+		if (wc->tspans[x]->span.flags & DAHDI_FLAG_RUNNING) {
 			for (y=0;y<wc->tspans[x]->span.channels;y++) {
 				/* Echo cancel double buffered data */
-				zt_ec_chunk(&wc->tspans[x]->span.chans[y], 
+				dahdi_ec_chunk(&wc->tspans[x]->span.chans[y], 
 				    wc->tspans[x]->span.chans[y].readchunk, 
 					wc->tspans[x]->ec_chunk2[y]);
 				memcpy(wc->tspans[x]->ec_chunk2[y],wc->tspans[x]->ec_chunk1[y],
-					ZT_CHUNKSIZE);
+					DAHDI_CHUNKSIZE);
 				memcpy(wc->tspans[x]->ec_chunk1[y],
 					wc->tspans[x]->span.chans[y].writechunk,
-						ZT_CHUNKSIZE);
+						DAHDI_CHUNKSIZE);
 			}
-			zt_receive(&wc->tspans[x]->span);
+			dahdi_receive(&wc->tspans[x]->span);
 		}
 	}
 }
 #endif
 
-#if (ZT_CHUNKSIZE != 8)
+#if (DAHDI_CHUNKSIZE != 8)
 #error Sorry, nextgen does not support chunksize != 8
 #endif
 
@@ -2237,7 +2237,7 @@ static inline void __receive_span(struct t4_span *ts)
 		for (y=0;y<ts->span.channels;y++) {
 			/* Mute any DTMFs which are supposed to be muted */
 			if (test_bit(y, &merged)) {
-				memset(ts->span.chans[y].readchunk, ZT_XLAW(0, (ts->span.chans + y)), ZT_CHUNKSIZE);
+				memset(ts->span.chans[y].readchunk, DAHDI_XLAW(0, (ts->span.chans + y)), DAHDI_CHUNKSIZE);
 			}
 		}
 	}
@@ -2262,13 +2262,13 @@ static inline void __receive_span(struct t4_span *ts)
 	prefetch((void *)(ts->writechunk + 56));
 #endif
 
-	zt_ec_span(&ts->span);
-	zt_receive(&ts->span);
+	dahdi_ec_span(&ts->span);
+	dahdi_receive(&ts->span);
 }
 
 static inline void __transmit_span(struct t4_span *ts)
 {
-	zt_transmit(&ts->span);
+	dahdi_transmit(&ts->span);
 }
 
 #ifdef ENABLE_WORKQUEUES
@@ -2288,7 +2288,7 @@ static void t4_prep_gen2(struct t4 *wc)
 {
 	int x;
 	for (x=0;x<wc->numspans;x++) {
-		if (wc->tspans[x]->span.flags & ZT_FLAG_RUNNING) {
+		if (wc->tspans[x]->span.flags & DAHDI_FLAG_RUNNING) {
 			__receive_span(wc->tspans[x]);
 			__transmit_span(wc->tspans[x]);
 		}
@@ -2309,14 +2309,14 @@ static void t4_transmitprep(struct t4 *wc, int irq)
 		/* First part */
 		writechunk = wc->writechunk + 1;
 	} else {
-		writechunk = wc->writechunk + ZT_CHUNKSIZE * 32  + 1;
+		writechunk = wc->writechunk + DAHDI_CHUNKSIZE * 32  + 1;
 	}
 	for (y=0;y<wc->numspans;y++) {
-		if (wc->tspans[y]->span.flags & ZT_FLAG_RUNNING) 
-			zt_transmit(&wc->tspans[y]->span);
+		if (wc->tspans[y]->span.flags & DAHDI_FLAG_RUNNING) 
+			dahdi_transmit(&wc->tspans[y]->span);
 	}
 
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		/* Once per chunk */
 		for (z=0;z<24;z++) {
 			/* All T1/E1 channels */
@@ -2358,46 +2358,46 @@ static void t4_check_sigbits(struct t4 *wc, int span)
 	if (debug & DEBUG_RBS)
 		printk("Checking sigbits on span %d\n", span + 1);
 
-	if (!(ts->span.flags & ZT_FLAG_RUNNING))
+	if (!(ts->span.flags & DAHDI_FLAG_RUNNING))
 		return;
 	if (ts->spantype == TYPE_E1) {
 		for (i = 0; i < 15; i++) {
 			a = t4_framer_in(wc, span, 0x71 + i);
 			/* Get high channel in low bits */
 			rxs = (a & 0xf);
-			if (!(ts->span.chans[i+16].sig & ZT_SIG_CLEAR)) {
+			if (!(ts->span.chans[i+16].sig & DAHDI_SIG_CLEAR)) {
 				if (ts->span.chans[i+16].rxsig != rxs)
-					zt_rbsbits(&ts->span.chans[i+16], rxs);
+					dahdi_rbsbits(&ts->span.chans[i+16], rxs);
 			}
 			rxs = (a >> 4) & 0xf;
-			if (!(ts->span.chans[i].sig & ZT_SIG_CLEAR)) {
+			if (!(ts->span.chans[i].sig & DAHDI_SIG_CLEAR)) {
 				if (ts->span.chans[i].rxsig != rxs)
-					zt_rbsbits(&ts->span.chans[i], rxs);
+					dahdi_rbsbits(&ts->span.chans[i], rxs);
 			}
 		}
-	} else if (ts->span.lineconfig & ZT_CONFIG_D4) {
+	} else if (ts->span.lineconfig & DAHDI_CONFIG_D4) {
 		for (i = 0; i < 24; i+=4) {
 			a = t4_framer_in(wc, span, 0x70 + (i>>2));
 			/* Get high channel in low bits */
 			rxs = (a & 0x3) << 2;
-			if (!(ts->span.chans[i+3].sig & ZT_SIG_CLEAR)) {
+			if (!(ts->span.chans[i+3].sig & DAHDI_SIG_CLEAR)) {
 				if (ts->span.chans[i+3].rxsig != rxs)
-					zt_rbsbits(&ts->span.chans[i+3], rxs);
+					dahdi_rbsbits(&ts->span.chans[i+3], rxs);
 			}
 			rxs = (a & 0xc);
-			if (!(ts->span.chans[i+2].sig & ZT_SIG_CLEAR)) {
+			if (!(ts->span.chans[i+2].sig & DAHDI_SIG_CLEAR)) {
 				if (ts->span.chans[i+2].rxsig != rxs)
-					zt_rbsbits(&ts->span.chans[i+2], rxs);
+					dahdi_rbsbits(&ts->span.chans[i+2], rxs);
 			}
 			rxs = (a >> 2) & 0xc;
-			if (!(ts->span.chans[i+1].sig & ZT_SIG_CLEAR)) {
+			if (!(ts->span.chans[i+1].sig & DAHDI_SIG_CLEAR)) {
 				if (ts->span.chans[i+1].rxsig != rxs)
-					zt_rbsbits(&ts->span.chans[i+1], rxs);
+					dahdi_rbsbits(&ts->span.chans[i+1], rxs);
 			}
 			rxs = (a >> 4) & 0xc;
-			if (!(ts->span.chans[i].sig & ZT_SIG_CLEAR)) {
+			if (!(ts->span.chans[i].sig & DAHDI_SIG_CLEAR)) {
 				if (ts->span.chans[i].rxsig != rxs)
-					zt_rbsbits(&ts->span.chans[i], rxs);
+					dahdi_rbsbits(&ts->span.chans[i], rxs);
 			}
 		}
 	} else {
@@ -2405,17 +2405,17 @@ static void t4_check_sigbits(struct t4 *wc, int span)
 			a = t4_framer_in(wc, span, 0x70 + (i>>1));
 			/* Get high channel in low bits */
 			rxs = (a & 0xf);
-			if (!(ts->span.chans[i+1].sig & ZT_SIG_CLEAR)) {
+			if (!(ts->span.chans[i+1].sig & DAHDI_SIG_CLEAR)) {
 				/* XXX Not really reset on every trans! XXX */
 				if (ts->span.chans[i+1].rxsig != rxs) {
-					zt_rbsbits(&ts->span.chans[i+1], rxs);
+					dahdi_rbsbits(&ts->span.chans[i+1], rxs);
 				}
 			}
 			rxs = (a >> 4) & 0xf;
-			if (!(ts->span.chans[i].sig & ZT_SIG_CLEAR)) {
+			if (!(ts->span.chans[i].sig & DAHDI_SIG_CLEAR)) {
 				/* XXX Not really reset on every trans! XXX */
 				if (ts->span.chans[i].rxsig != rxs) {
-					zt_rbsbits(&ts->span.chans[i], rxs);
+					dahdi_rbsbits(&ts->span.chans[i], rxs);
 				}
 			}
 		}
@@ -2430,7 +2430,7 @@ static void t4_check_alarms(struct t4 *wc, int span)
 	struct t4_span *ts = wc->tspans[span];
 	unsigned long flags;
 
-	if (!(ts->span.flags & ZT_FLAG_RUNNING))
+	if (!(ts->span.flags & DAHDI_FLAG_RUNNING))
 		return;
 
 	spin_lock_irqsave(&wc->reglock, flags);
@@ -2442,7 +2442,7 @@ static void t4_check_alarms(struct t4 *wc, int span)
 	alarms = 0;
 
 	/* And consider only carrier alarms */
-	ts->span.alarms &= (ZT_ALARM_RED | ZT_ALARM_BLUE | ZT_ALARM_NOTOPEN);
+	ts->span.alarms &= (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | DAHDI_ALARM_NOTOPEN);
 
 	if (ts->spantype == TYPE_E1) {
 		if (c & 0x04) {
@@ -2468,43 +2468,43 @@ static void t4_check_alarms(struct t4 *wc, int span)
 		/* Detect loopup code if we're not sending one */
 		if ((!ts->span.mainttimer) && (d & 0x08)) {
 			/* Loop-up code detected */
-			if ((ts->loopupcnt++ > 80)  && (ts->span.maintstat != ZT_MAINT_REMOTELOOP)) {
+			if ((ts->loopupcnt++ > 80)  && (ts->span.maintstat != DAHDI_MAINT_REMOTELOOP)) {
 				__t4_framer_out(wc, span, 0x36, 0x08);	/* LIM0: Disable any local loop */
 				__t4_framer_out(wc, span, 0x37, 0xf6 );	/* LIM1: Enable remote loop */
-				ts->span.maintstat = ZT_MAINT_REMOTELOOP;
+				ts->span.maintstat = DAHDI_MAINT_REMOTELOOP;
 			}
 		} else
 			ts->loopupcnt = 0;
 		/* Same for loopdown code */
 		if ((!ts->span.mainttimer) && (d & 0x10)) {
 			/* Loop-down code detected */
-			if ((ts->loopdowncnt++ > 80)  && (ts->span.maintstat == ZT_MAINT_REMOTELOOP)) {
+			if ((ts->loopdowncnt++ > 80)  && (ts->span.maintstat == DAHDI_MAINT_REMOTELOOP)) {
 				__t4_framer_out(wc, span, 0x36, 0x08);	/* LIM0: Disable any local loop */
 				__t4_framer_out(wc, span, 0x37, 0xf0 );	/* LIM1: Disable remote loop */
-				ts->span.maintstat = ZT_MAINT_NONE;
+				ts->span.maintstat = DAHDI_MAINT_NONE;
 			}
 		} else
 			ts->loopdowncnt = 0;
 	}
 
-	if (ts->span.lineconfig & ZT_CONFIG_NOTOPEN) {
+	if (ts->span.lineconfig & DAHDI_CONFIG_NOTOPEN) {
 		for (x=0,j=0;x < ts->span.channels;x++)
-			if ((ts->span.chans[x].flags & ZT_FLAG_OPEN) ||
-			    (ts->span.chans[x].flags & ZT_FLAG_NETDEV))
+			if ((ts->span.chans[x].flags & DAHDI_FLAG_OPEN) ||
+			    (ts->span.chans[x].flags & DAHDI_FLAG_NETDEV))
 				j++;
 		if (!j)
-			alarms |= ZT_ALARM_NOTOPEN;
+			alarms |= DAHDI_ALARM_NOTOPEN;
 	}
 
 	if (c & 0xa0) {
 		if (ts->alarmcount >= alarmdebounce) 
-			alarms |= ZT_ALARM_RED;
+			alarms |= DAHDI_ALARM_RED;
 		else
 			ts->alarmcount++;
 	} else
 		ts->alarmcount = 0;
 	if (c & 0x4)
-		alarms |= ZT_ALARM_BLUE;
+		alarms |= DAHDI_ALARM_BLUE;
 
 	if (((!ts->span.alarms) && alarms) || 
 	    (ts->span.alarms && (!alarms))) 
@@ -2512,9 +2512,9 @@ static void t4_check_alarms(struct t4 *wc, int span)
 
 	/* Keep track of recovering */
 	if ((!alarms) && ts->span.alarms) 
-		ts->alarmtimer = ZT_ALARMSETTLE_TIME;
+		ts->alarmtimer = DAHDI_ALARMSETTLE_TIME;
 	if (ts->alarmtimer)
-		alarms |= ZT_ALARM_RECOVER;
+		alarms |= DAHDI_ALARM_RECOVER;
 
 	/* If receiving alarms, go into Yellow alarm state */
 	if (alarms && !(ts->spanflags & FLAG_SENDINGYELLOW)) {
@@ -2540,12 +2540,12 @@ static void t4_check_alarms(struct t4 *wc, int span)
 	/* Re-check the timing source when we enter/leave alarm, not withstanding
 	   yellow alarm */
 	if (c & 0x10)
-		alarms |= ZT_ALARM_YELLOW;
+		alarms |= DAHDI_ALARM_YELLOW;
 	if (ts->span.mainttimer || ts->span.maintstat) 
-		alarms |= ZT_ALARM_LOOPBACK;
+		alarms |= DAHDI_ALARM_LOOPBACK;
 	ts->span.alarms = alarms;
 	spin_unlock_irqrestore(&wc->reglock, flags);
-	zt_alarm_notify(&ts->span);
+	dahdi_alarm_notify(&ts->span);
 }
 
 static void t4_do_counters(struct t4 *wc)
@@ -2561,13 +2561,13 @@ static void t4_do_counters(struct t4 *wc)
 		if (ts->alarmtimer) {
 			if (!--ts->alarmtimer) {
 				docheck++;
-				ts->span.alarms &= ~(ZT_ALARM_RECOVER);
+				ts->span.alarms &= ~(DAHDI_ALARM_RECOVER);
 			}
 		}
 		spin_unlock(&wc->reglock);
 		if (docheck) {
 			t4_check_alarms(wc, span);
-			zt_alarm_notify(&ts->span);
+			dahdi_alarm_notify(&ts->span);
 		}
 	}
 }
@@ -2579,8 +2579,8 @@ static inline void __handle_leds(struct t4 *wc)
 	wc->blinktimer++;
 	for (x=0;x<wc->numspans;x++) {
 		struct t4_span *ts = wc->tspans[x];
-		if (ts->span.flags & ZT_FLAG_RUNNING) {
-			if (ts->span.alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE)) {
+		if (ts->span.flags & DAHDI_FLAG_RUNNING) {
+			if (ts->span.alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE)) {
 #ifdef FANCY_ALARM
 				if (wc->blinktimer == (altab[wc->alarmpos] >> 1)) {
 					__t4_set_led(wc, x, WC_RED);
@@ -2595,7 +2595,7 @@ static inline void __handle_leds(struct t4 *wc)
 					__t4_set_led(wc, x, WC_OFF);
 				}
 #endif
-			} else if (ts->span.alarms & ZT_ALARM_YELLOW) {
+			} else if (ts->span.alarms & DAHDI_ALARM_YELLOW) {
 				/* Yellow Alarm */
 				__t4_set_led(wc, x, WC_YELLOW);
 			} else if (ts->span.mainttimer || ts->span.maintstat) {
@@ -2640,7 +2640,7 @@ static inline void t4_framer_interrupt(struct t4 *wc, int span)
 	unsigned char gis, isr0, isr1, isr2, isr3, isr4;
 	int readsize = -1;
 	struct t4_span *ts = wc->tspans[span];
-	struct zt_chan *sigchan;
+	struct dahdi_chan *sigchan;
 	unsigned long flags;
 
 	if (debug & DEBUG_FRAMER)	
@@ -2743,26 +2743,26 @@ static inline void t4_framer_interrupt(struct t4 *wc, int span)
 			if (debug & DEBUG_FRAMER) printk("Received HDLC frame %d.  RSIS = 0x%x (%x)\n", ts->frames_in, rsis, rsis_reg);
 			if (!(rsis & FRMR_RSIS_CRC16)) {
 				if (debug & DEBUG_FRAMER) printk("CRC check failed %d\n", span);
-				zt_hdlc_abort(sigchan, ZT_EVENT_BADFCS);
+				dahdi_hdlc_abort(sigchan, DAHDI_EVENT_BADFCS);
 			} else if (rsis & FRMR_RSIS_RAB) {
 				if (debug & DEBUG_FRAMER) printk("ABORT of current frame due to overflow %d\n", span);
-				zt_hdlc_abort(sigchan, ZT_EVENT_ABORT);
+				dahdi_hdlc_abort(sigchan, DAHDI_EVENT_ABORT);
 			} else if (rsis & FRMR_RSIS_RDO) {
 				if (debug & DEBUG_FRAMER) printk("HDLC overflow occured %d\n", span);
-				zt_hdlc_abort(sigchan, ZT_EVENT_OVERRUN);
+				dahdi_hdlc_abort(sigchan, DAHDI_EVENT_OVERRUN);
 			} else if (!(rsis & FRMR_RSIS_VFR)) {
 				if (debug & DEBUG_FRAMER) printk("Valid Frame check failed on span %d\n", span);
-				zt_hdlc_abort(sigchan, ZT_EVENT_ABORT);
+				dahdi_hdlc_abort(sigchan, DAHDI_EVENT_ABORT);
 			} else {
-				zt_hdlc_putbuf(sigchan, readbuf, readsize - 1);
-				zt_hdlc_finish(sigchan);
+				dahdi_hdlc_putbuf(sigchan, readbuf, readsize - 1);
+				dahdi_hdlc_finish(sigchan);
 				if (debug & DEBUG_FRAMER) printk("Received valid HDLC frame on span %d\n", span);
 			}
 #if 0
 			debug = olddebug;
 #endif
 		} else if (isr0 & FRMR_ISR0_RPF)
-			zt_hdlc_putbuf(sigchan, readbuf, readsize);
+			dahdi_hdlc_putbuf(sigchan, readbuf, readsize);
 	}
 
 	/* Transmit side */
@@ -2954,20 +2954,20 @@ ZAP_IRQ_HANDLER(t4_interrupt_gen2)
 #ifdef ENABLE_WORKQUEUES
 		int cpus = num_online_cpus();
 		atomic_set(&wc->worklist, wc->numspans);
-		if (wc->tspans[0]->span.flags & ZT_FLAG_RUNNING)
+		if (wc->tspans[0]->span.flags & DAHDI_FLAG_RUNNING)
 			t4_queue_work(wc->workq, &wc->tspans[0]->swork, 0);
 		else
 			atomic_dec(&wc->worklist);
-		if (wc->tspans[1]->span.flags & ZT_FLAG_RUNNING)
+		if (wc->tspans[1]->span.flags & DAHDI_FLAG_RUNNING)
 			t4_queue_work(wc->workq, &wc->tspans[1]->swork, 1 % cpus);
 		else
 			atomic_dec(&wc->worklist);
 		if (wc->numspans == 4) {
-			if (wc->tspans[2]->span.flags & ZT_FLAG_RUNNING)
+			if (wc->tspans[2]->span.flags & DAHDI_FLAG_RUNNING)
 				t4_queue_work(wc->workq, &wc->tspans[2]->swork, 2 % cpus);
 			else
 				atomic_dec(&wc->worklist);
-			if (wc->tspans[3]->span.flags & ZT_FLAG_RUNNING)
+			if (wc->tspans[3]->span.flags & DAHDI_FLAG_RUNNING)
 				t4_queue_work(wc->workq, &wc->tspans[3]->swork, 3 % cpus);
 			else
 				atomic_dec(&wc->worklist);
@@ -3042,7 +3042,7 @@ static int t4_reset_dma(struct t4 *wc)
 	/* Turn it all back on */
 	t4_pci_out(wc, WC_RDADDR, wc->readdma);
 	t4_pci_out(wc, WC_WRADDR, wc->writedma);
-	t4_pci_out(wc, WC_COUNT, ((ZT_MAX_CHUNKSIZE * 2 * 32 - 1) << 18) | ((ZT_MAX_CHUNKSIZE * 2 * 32 - 1) << 2));
+	t4_pci_out(wc, WC_COUNT, ((DAHDI_MAX_CHUNKSIZE * 2 * 32 - 1) << 18) | ((DAHDI_MAX_CHUNKSIZE * 2 * 32 - 1) << 2));
 	t4_pci_out(wc, WC_INTR, 0);
 #ifdef VPM_SUPPORT
 	wc->dmactrl = 0xc0000000 | (1 << 29) | wc->vpm;
@@ -3442,7 +3442,7 @@ static int t4_hardware_init_1(struct t4 *wc, unsigned int cardflags)
 	if (cardflags & FLAG_2NDGEN) {
 		t4_tsi_reset(wc);
 	} else {
-		t4_pci_out(wc, WC_COUNT, ((ZT_MAX_CHUNKSIZE * 2 * 32 - 1) << 18) | ((ZT_MAX_CHUNKSIZE * 2 * 32 - 1) << 2));
+		t4_pci_out(wc, WC_COUNT, ((DAHDI_MAX_CHUNKSIZE * 2 * 32 - 1) << 18) | ((DAHDI_MAX_CHUNKSIZE * 2 * 32 - 1) << 2));
 	}
 	
 	/* Reset pending interrupts */
@@ -3484,7 +3484,7 @@ static int __devinit t4_launch(struct t4 *wc)
 {
 	int x;
 	unsigned long flags;
-	if (wc->tspans[0]->span.flags & ZT_FLAG_REGISTERED)
+	if (wc->tspans[0]->span.flags & DAHDI_FLAG_REGISTERED)
 		return 0;
 	printk("TE%dXXP: Launching card: %d\n", wc->numspans, wc->order);
 
@@ -3492,28 +3492,28 @@ static int __devinit t4_launch(struct t4 *wc)
 	for (x=0;x<4;x++)
 		t4_serial_setup(wc, x);
 
-	if (zt_register(&wc->tspans[0]->span, 0)) {
+	if (dahdi_register(&wc->tspans[0]->span, 0)) {
 		printk(KERN_ERR "Unable to register span %s\n", wc->tspans[0]->span.name);
 		return -1;
 	}
-	if (zt_register(&wc->tspans[1]->span, 0)) {
+	if (dahdi_register(&wc->tspans[1]->span, 0)) {
 		printk(KERN_ERR "Unable to register span %s\n", wc->tspans[1]->span.name);
-		zt_unregister(&wc->tspans[0]->span);
+		dahdi_unregister(&wc->tspans[0]->span);
 		return -1;
 	}
 
 	if (wc->numspans == 4) {
-		if (zt_register(&wc->tspans[2]->span, 0)) {
+		if (dahdi_register(&wc->tspans[2]->span, 0)) {
 			printk(KERN_ERR "Unable to register span %s\n", wc->tspans[2]->span.name);
-			zt_unregister(&wc->tspans[0]->span);
-			zt_unregister(&wc->tspans[1]->span);
+			dahdi_unregister(&wc->tspans[0]->span);
+			dahdi_unregister(&wc->tspans[1]->span);
 			return -1;
 		}
-		if (zt_register(&wc->tspans[3]->span, 0)) {
+		if (dahdi_register(&wc->tspans[3]->span, 0)) {
 			printk(KERN_ERR "Unable to register span %s\n", wc->tspans[3]->span.name);
-			zt_unregister(&wc->tspans[0]->span);
-			zt_unregister(&wc->tspans[1]->span);
-			zt_unregister(&wc->tspans[2]->span);
+			dahdi_unregister(&wc->tspans[0]->span);
+			dahdi_unregister(&wc->tspans[1]->span);
+			dahdi_unregister(&wc->tspans[2]->span);
 			return -1;
 		}
 	}
@@ -3547,9 +3547,9 @@ static int __devinit t4_init_one(struct pci_dev *pdev, const struct pci_device_i
 			spin_lock_init(&wc->reglock);
 			dt = (struct devtype *)(ent->driver_data);
 			if (dt->flags & FLAG_2NDGEN)
-				basesize = ZT_MAX_CHUNKSIZE * 32 * 4;
+				basesize = DAHDI_MAX_CHUNKSIZE * 32 * 4;
 			else
-				basesize = ZT_MAX_CHUNKSIZE * 32 * 2 * 4;
+				basesize = DAHDI_MAX_CHUNKSIZE * 32 * 2 * 4;
 
 			if (dt->flags & FLAG_2PORT) 
 				wc->numspans = 2;
@@ -3592,9 +3592,9 @@ static int __devinit t4_init_one(struct pci_dev *pdev, const struct pci_device_i
 			memset((void *)wc->writechunk,0x00, basesize);
 			memset((void *)wc->readchunk,0xff, basesize);
 #if 0
-			memset((void *)wc->readchunk,0xff,ZT_MAX_CHUNKSIZE * 2 * 32 * 4);
+			memset((void *)wc->readchunk,0xff,DAHDI_MAX_CHUNKSIZE * 2 * 32 * 4);
 			/* Initialize canary */
-			canary = (unsigned int *)(wc->readchunk + ZT_CHUNKSIZE * 64 * 4 - 4);
+			canary = (unsigned int *)(wc->readchunk + DAHDI_CHUNKSIZE * 64 * 4 - 4);
 			*canary = (CANARY << 16) | (0xffff);
 #endif			
 
@@ -3631,15 +3631,15 @@ static int __devinit t4_init_one(struct pci_dev *pdev, const struct pci_device_i
 			/* Allocate pieces we need here */
 			for (x=0;x<4;x++) {
 				if (wc->t1e1 & (1 << x)) {
-					wc->tspans[x] = kmalloc(sizeof(struct t4_span) + sizeof(struct zt_chan) * 31, GFP_KERNEL);
+					wc->tspans[x] = kmalloc(sizeof(struct t4_span) + sizeof(struct dahdi_chan) * 31, GFP_KERNEL);
 					if (wc->tspans[x]) {
-						memset(wc->tspans[x], 0, sizeof(struct t4_span) + sizeof(struct zt_chan) * 31);
+						memset(wc->tspans[x], 0, sizeof(struct t4_span) + sizeof(struct dahdi_chan) * 31);
 						wc->tspans[x]->spantype = TYPE_E1;
 					}
 				} else {
-					wc->tspans[x] = kmalloc(sizeof(struct t4_span) + sizeof(struct zt_chan) * 24, GFP_KERNEL);
+					wc->tspans[x] = kmalloc(sizeof(struct t4_span) + sizeof(struct dahdi_chan) * 24, GFP_KERNEL);
 					if (wc->tspans[x]) {
-						memset(wc->tspans[x], 0, sizeof(struct t4_span) + sizeof(struct zt_chan) * 24);
+						memset(wc->tspans[x], 0, sizeof(struct t4_span) + sizeof(struct dahdi_chan) * 24);
 						if (j1mode)
 							wc->tspans[x]->spantype = TYPE_J1;
 						else
@@ -3756,15 +3756,15 @@ static void __devexit t4_remove_one(struct pci_dev *pdev)
 			release_vpm450m(wc->vpm450m);
 		wc->vpm450m = NULL;
 		/* Unregister spans */
-		if (wc->tspans[0]->span.flags & ZT_FLAG_REGISTERED)
-			zt_unregister(&wc->tspans[0]->span);
-		if (wc->tspans[1]->span.flags & ZT_FLAG_REGISTERED)
-			zt_unregister(&wc->tspans[1]->span);
+		if (wc->tspans[0]->span.flags & DAHDI_FLAG_REGISTERED)
+			dahdi_unregister(&wc->tspans[0]->span);
+		if (wc->tspans[1]->span.flags & DAHDI_FLAG_REGISTERED)
+			dahdi_unregister(&wc->tspans[1]->span);
 		if (wc->numspans == 4) {
-			if (wc->tspans[2]->span.flags & ZT_FLAG_REGISTERED)
-				zt_unregister(&wc->tspans[2]->span);
-			if (wc->tspans[3]->span.flags & ZT_FLAG_REGISTERED)
-				zt_unregister(&wc->tspans[3]->span);
+			if (wc->tspans[2]->span.flags & DAHDI_FLAG_REGISTERED)
+				dahdi_unregister(&wc->tspans[2]->span);
+			if (wc->tspans[3]->span.flags & DAHDI_FLAG_REGISTERED)
+				dahdi_unregister(&wc->tspans[3]->span);
 		}
 #ifdef ENABLE_WORKQUEUES
 		if (wc->workq) {
@@ -3781,7 +3781,7 @@ static void __devexit t4_remove_one(struct pci_dev *pdev)
 		pci_release_regions(pdev);		
 
 		/* Immediately free resources */
-		pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 32 * 4, (void *)wc->writechunk, wc->writedma);
+		pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 32 * 4, (void *)wc->writechunk, wc->writedma);
 
 		order_index[wc->order]--;
 
diff --git a/drivers/dahdi/wct4xxp/wct4xxp.h b/drivers/dahdi/wct4xxp/wct4xxp.h
index 7d14b85..60b8154 100644
--- a/drivers/dahdi/wct4xxp/wct4xxp.h
+++ b/drivers/dahdi/wct4xxp/wct4xxp.h
@@ -110,5 +110,5 @@ struct t4_regs {
 #define T4_STOP_DMA		2
 #define T4_CHECK_TIMING		3
 
-#define WCT4_GET_REGS	_IOW (ZT_CODE, 60, struct t4_regs)
+#define WCT4_GET_REGS	_IOW (DAHDI_CODE, 60, struct t4_regs)
 
diff --git a/drivers/dahdi/wctc4xxp/base.c b/drivers/dahdi/wctc4xxp/base.c
index 16043d1..8ad84f2 100644
--- a/drivers/dahdi/wctc4xxp/base.c
+++ b/drivers/dahdi/wctc4xxp/base.c
@@ -274,7 +274,7 @@
 	0x00,0x01, s&0x0F, 0x01, 0xFF,0xFF, 0x0A, 0x00, 0x00,0x06,0x09,0x04, 0x00,0x00, \
 	0x24,0x00, 0x00,0x00 }
 
-#define zt_send_cmd(wc, command, length, hex) \
+#define dahdi_send_cmd(wc, command, length, hex) \
 	({ \
 		int ret = 0; \
 		do { \
@@ -368,8 +368,8 @@ struct wcdte {
 	struct workqueue_struct *dte_wq;
 	struct work_struct dte_work;
 
-	struct zt_transcoder *uencode;
-	struct zt_transcoder *udecode;
+	struct dahdi_transcoder *uencode;
+	struct dahdi_transcoder *udecode;
 };
 
 struct wcdte_desc {
@@ -418,8 +418,8 @@ struct dte_state {
 };
 
 
-static struct zt_transcoder *uencode;
-static struct zt_transcoder *udecode;
+static struct dahdi_transcoder *uencode;
+static struct dahdi_transcoder *udecode;
 static struct dte_state *encoders;
 static struct dte_state *decoders;
 static int debug = 0;
@@ -490,7 +490,7 @@ static int __dump_descriptors(struct wcdte *wc)
 }
 
 /* Sanity check values */
-static inline int zt_tc_sanitycheck(struct zt_transcode_header *zth, unsigned int outbytes)
+static inline int dahdi_tc_sanitycheck(struct dahdi_transcode_header *zth, unsigned int outbytes)
 {
 	if (zth->dstoffset >= sizeof(zth->dstdata))
 		return 0;
@@ -544,16 +544,16 @@ static unsigned int wcdte_zapfmt_to_dtefmt(unsigned int fmt)
 	
 	switch(fmt)
 	{
-		case ZT_FORMAT_G723_1:
+		case DAHDI_FORMAT_G723_1:
 			pt = DTE_FORMAT_G723_1;
 			break;
-		case ZT_FORMAT_ULAW:
+		case DAHDI_FORMAT_ULAW:
 			pt = DTE_FORMAT_ULAW;
 			break;
-		case ZT_FORMAT_ALAW:
+		case DAHDI_FORMAT_ALAW:
 			pt = DTE_FORMAT_ALAW;
 			break;
-		case ZT_FORMAT_G729A:
+		case DAHDI_FORMAT_G729A:
 			pt = DTE_FORMAT_G729A;
 			break;
 		default:
@@ -673,11 +673,11 @@ static inline int transmit_demand(struct wcdte *wc)
 	return val;
 }
 
-static int dte_operation(struct zt_transcoder_channel *ztc, int op)
+static int dte_operation(struct dahdi_transcoder_channel *ztc, int op)
 {
-	struct zt_transcoder_channel *compl_ztc;
+	struct dahdi_transcoder_channel *compl_ztc;
 	struct dte_state *st = ztc->pvt, *compl_st;
-	struct zt_transcode_header *zth = ztc->tch;
+	struct dahdi_transcode_header *zth = ztc->tch;
 	struct wcdte *wc = st->wc;
 	unsigned char *chars;
 	unsigned int inbytes = 0;
@@ -686,7 +686,7 @@ static int dte_operation(struct zt_transcoder_channel *ztc, int op)
 	int res = 0;
 	unsigned int ipchksum, ndx;
 	switch(op) {
-	case ZT_TCOP_ALLOCATE:
+	case DAHDI_TCOP_ALLOCATE:
 		down(&wc->chansem);
 		if (ztc->chan_built == 0)
 		{
@@ -714,7 +714,7 @@ static int dte_operation(struct zt_transcoder_channel *ztc, int op)
 		}
 		up(&wc->chansem);
 		break;
-	case ZT_TCOP_RELEASE:
+	case DAHDI_TCOP_RELEASE:
 		down(&wc->chansem);
 		ndx = st->timeslot_in_num/2;
 
@@ -724,7 +724,7 @@ static int dte_operation(struct zt_transcoder_channel *ztc, int op)
 			compl_ztc = &(wc->uencode->channels[ndx]);
 
 		/* If the channel complement (other half of the encoder/decoder pair) is not being used... */
-		if ((compl_ztc->flags & ZT_TC_FLAG_BUSY) == 0)
+		if ((compl_ztc->flags & DAHDI_TC_FLAG_BUSY) == 0)
 		{
 			if (st->encoder == 1)
 				wcdte_destroy_channel(wc, st->chan_in_num, st->chan_out_num);
@@ -747,27 +747,27 @@ static int dte_operation(struct zt_transcoder_channel *ztc, int op)
 		st->dte_seqno_rcv = 0;
 		up(&wc->chansem);
 		break;
-	case ZT_TCOP_TRANSCODE:
-		if ( (((zth->srcfmt == ZT_FORMAT_ULAW) || (zth->srcfmt == ZT_FORMAT_ALAW)) && ((zth->dstfmt == ZT_FORMAT_G729A  && zth->srclen >= G729_SAMPLES) ||(zth->dstfmt == ZT_FORMAT_G723_1  && zth->srclen >= G723_SAMPLES)) )
-			|| ((zth->srcfmt == ZT_FORMAT_G729A) && (zth->srclen >= G729_BYTES))
-			|| ((zth->srcfmt == ZT_FORMAT_G723_1) && (zth->srclen >= G723_SID_BYTES)) )
+	case DAHDI_TCOP_TRANSCODE:
+		if ( (((zth->srcfmt == DAHDI_FORMAT_ULAW) || (zth->srcfmt == DAHDI_FORMAT_ALAW)) && ((zth->dstfmt == DAHDI_FORMAT_G729A  && zth->srclen >= G729_SAMPLES) ||(zth->dstfmt == DAHDI_FORMAT_G723_1  && zth->srclen >= G723_SAMPLES)) )
+			|| ((zth->srcfmt == DAHDI_FORMAT_G729A) && (zth->srclen >= G729_BYTES))
+			|| ((zth->srcfmt == DAHDI_FORMAT_G723_1) && (zth->srclen >= G723_SID_BYTES)) )
 		{
 			do
 			{
 				chars = (unsigned char *)(zth->srcdata + zth->srcoffset);
 					
-				if ((zth->srcfmt == ZT_FORMAT_ULAW) || (zth->srcfmt == ZT_FORMAT_ALAW)) {
-					if (zth->dstfmt == ZT_FORMAT_G729A) {
+				if ((zth->srcfmt == DAHDI_FORMAT_ULAW) || (zth->srcfmt == DAHDI_FORMAT_ALAW)) {
+					if (zth->dstfmt == DAHDI_FORMAT_G729A) {
 						inbytes = G729_SAMPLES; 
 						timestamp_inc = G729_SAMPLES; 
-					} else if (zth->dstfmt == ZT_FORMAT_G723_1) {
+					} else if (zth->dstfmt == DAHDI_FORMAT_G723_1) {
 						inbytes = G723_SAMPLES; 
 						timestamp_inc = G723_SAMPLES; 
 					}
-				} else if (zth->srcfmt == ZT_FORMAT_G729A) {
+				} else if (zth->srcfmt == DAHDI_FORMAT_G729A) {
 					inbytes = G729_BYTES;
 					timestamp_inc = G729_SAMPLES;
-				} else if (zth->srcfmt == ZT_FORMAT_G723_1) {
+				} else if (zth->srcfmt == DAHDI_FORMAT_G723_1) {
 					/* determine the size of the frame */
 					switch (chars[0] & 0x03) {
 					case 0x00:
@@ -851,12 +851,12 @@ static int dte_operation(struct zt_transcoder_channel *ztc, int op)
 				zth->srcoffset += inbytes;
 
 
-			} while ((((zth->srcfmt == ZT_FORMAT_ULAW) || (zth->srcfmt == ZT_FORMAT_ALAW)) && ((zth->dstfmt == ZT_FORMAT_G729A  && zth->srclen >= G729_SAMPLES) ||(zth->dstfmt == ZT_FORMAT_G723_1  && zth->srclen >= G723_SAMPLES)) )
-				|| ((zth->srcfmt == ZT_FORMAT_G729A) && (zth->srclen >= G729_BYTES))
-				|| ((zth->srcfmt == ZT_FORMAT_G723_1) && (zth->srclen >= G723_SID_BYTES)) );
+			} while ((((zth->srcfmt == DAHDI_FORMAT_ULAW) || (zth->srcfmt == DAHDI_FORMAT_ALAW)) && ((zth->dstfmt == DAHDI_FORMAT_G729A  && zth->srclen >= G729_SAMPLES) ||(zth->dstfmt == DAHDI_FORMAT_G723_1  && zth->srclen >= G723_SAMPLES)) )
+				|| ((zth->srcfmt == DAHDI_FORMAT_G729A) && (zth->srclen >= G729_BYTES))
+				|| ((zth->srcfmt == DAHDI_FORMAT_G723_1) && (zth->srclen >= G723_SID_BYTES)) );
 
 		} else {
-			zt_transcoder_alert(ztc);
+			dahdi_transcoder_alert(ztc);
 		}
 
 		res = 0;
@@ -870,8 +870,8 @@ static void wcdte_stop_dma(struct wcdte *wc);
 static inline void wcdte_receiveprep(struct wcdte *wc, int dbl)
 {
 	volatile unsigned char *readchunk;
-	struct zt_transcoder_channel *ztc = NULL;
-	struct zt_transcode_header *zth = NULL;
+	struct dahdi_transcoder_channel *ztc = NULL;
+	struct dahdi_transcode_header *zth = NULL;
 	struct dte_state *st = NULL;
 	int o2,i;
 	unsigned char rseq, rcodec;
@@ -1036,7 +1036,7 @@ static inline void wcdte_receiveprep(struct wcdte *wc, int dbl)
 
 		if (rcodec == 0x00)	/* ulaw */
 		{
-			if (zt_tc_sanitycheck(zth, rlen) && ((zth->srcfmt == ZT_FORMAT_G729A && rlen == G729_SAMPLES) || (zth->srcfmt == ZT_FORMAT_G723_1 && rlen == G723_SAMPLES))) {
+			if (dahdi_tc_sanitycheck(zth, rlen) && ((zth->srcfmt == DAHDI_FORMAT_G729A && rlen == G729_SAMPLES) || (zth->srcfmt == DAHDI_FORMAT_G723_1 && rlen == G723_SAMPLES))) {
 				for (i = 0; i < rlen; i++)
 					chars[i] = readchunk[i+54];
 
@@ -1046,11 +1046,11 @@ static inline void wcdte_receiveprep(struct wcdte *wc, int dbl)
 			} else {
 				ztc->errorstatus = -EOVERFLOW;
 			}
-			zt_transcoder_alert(ztc);
+			dahdi_transcoder_alert(ztc);
 		}
 		else if (rcodec == 0x08)	/* alaw */
 		{
-			if (zt_tc_sanitycheck(zth, rlen) && ((zth->srcfmt == ZT_FORMAT_G729A && rlen == G729_SAMPLES) || (zth->srcfmt == ZT_FORMAT_G723_1 && rlen == G723_SAMPLES))) {
+			if (dahdi_tc_sanitycheck(zth, rlen) && ((zth->srcfmt == DAHDI_FORMAT_G729A && rlen == G729_SAMPLES) || (zth->srcfmt == DAHDI_FORMAT_G723_1 && rlen == G723_SAMPLES))) {
 
 				for (i = 0; i < rlen; i++)
 					chars[i] = readchunk[i+54];
@@ -1061,11 +1061,11 @@ static inline void wcdte_receiveprep(struct wcdte *wc, int dbl)
 			} else {
 				ztc->errorstatus = -EOVERFLOW;
 			}
-			zt_transcoder_alert(ztc);
+			dahdi_transcoder_alert(ztc);
 		}
 		else if (rcodec == 0x04)	/* G.723.1 */
 		{
-			if (zt_tc_sanitycheck(zth, rlen) &&
+			if (dahdi_tc_sanitycheck(zth, rlen) &&
 			    ((rlen == G723_6K_BYTES) || (rlen == G723_5K_BYTES) || (rlen == G723_SID_BYTES)))
 			{
 				for (i = 0; i < rlen; i++)
@@ -1080,12 +1080,12 @@ static inline void wcdte_receiveprep(struct wcdte *wc, int dbl)
 
 			if (!(zth->dstsamples % G723_SAMPLES))
 			{
-				zt_transcoder_alert(ztc);
+				dahdi_transcoder_alert(ztc);
 			} 
 		}
 		else if (rcodec == 0x12)	/* G.729a */
 		{
-			if (zt_tc_sanitycheck(zth, rlen) && (rlen == G729_BYTES))
+			if (dahdi_tc_sanitycheck(zth, rlen) && (rlen == G729_BYTES))
 			{
 				for (i = 0; i < rlen; i++)
 					chars[i] = readchunk[i+54];
@@ -1099,7 +1099,7 @@ static inline void wcdte_receiveprep(struct wcdte *wc, int dbl)
 
 			if (!(zth->dstsamples % G729_SAMPLES))
 			{
-				zt_transcoder_alert(ztc);
+				dahdi_transcoder_alert(ztc);
 			} 
 		}
 	}
@@ -1528,7 +1528,7 @@ static int wcdte_create_channel(struct wcdte *wc, int simple, int complicated, i
 {
 	int length = 0;
 	unsigned char chan1, chan2;
-	struct zt_transcoder_channel *ztc1, *ztc2;
+	struct dahdi_transcoder_channel *ztc1, *ztc2;
 	struct dte_state *st1, *st2;
 	if(complicated == DTE_FORMAT_G729A)
 		length = G729_LENGTH;
@@ -1536,13 +1536,13 @@ static int wcdte_create_channel(struct wcdte *wc, int simple, int complicated, i
 		length = G723_LENGTH;
 
 	/* Create complex channel */
-	zt_send_cmd(wc, CMD_MSG_CREATE_CHANNEL(wc->seq_num++, part1_id), CMD_MSG_CREATE_CHANNEL_LEN, 0x0010);
-	zt_send_cmd(wc, CMD_MSG_QUERY_CHANNEL(wc->seq_num++, part1_id), CMD_MSG_QUERY_CHANNEL_LEN, 0x0010);
+	dahdi_send_cmd(wc, CMD_MSG_CREATE_CHANNEL(wc->seq_num++, part1_id), CMD_MSG_CREATE_CHANNEL_LEN, 0x0010);
+	dahdi_send_cmd(wc, CMD_MSG_QUERY_CHANNEL(wc->seq_num++, part1_id), CMD_MSG_QUERY_CHANNEL_LEN, 0x0010);
 	chan1 = wc->last_rparm1;
 
 	/* Create simple channel */
-	zt_send_cmd(wc, CMD_MSG_CREATE_CHANNEL(wc->seq_num++, part2_id), CMD_MSG_CREATE_CHANNEL_LEN, 0x0010);
-	zt_send_cmd(wc, CMD_MSG_QUERY_CHANNEL(wc->seq_num++, part2_id), CMD_MSG_QUERY_CHANNEL_LEN, 0x0010);
+	dahdi_send_cmd(wc, CMD_MSG_CREATE_CHANNEL(wc->seq_num++, part2_id), CMD_MSG_CREATE_CHANNEL_LEN, 0x0010);
+	dahdi_send_cmd(wc, CMD_MSG_QUERY_CHANNEL(wc->seq_num++, part2_id), CMD_MSG_QUERY_CHANNEL_LEN, 0x0010);
 	chan2 = wc->last_rparm1;
 
 	ztc1 = &(wc->uencode->channels[part1_id/2]);
@@ -1551,25 +1551,25 @@ static int wcdte_create_channel(struct wcdte *wc, int simple, int complicated, i
 	st2 = ztc2->pvt;
 
 	/* Configure complex channel */
-	zt_send_cmd(wc, CMD_MSG_SET_IP_HDR_CHANNEL(st1->cmd_seqno++, chan1, part2_id, part1_id), CMD_MSG_SET_IP_HDR_CHANNEL_LEN, 0x9000);
-	zt_send_cmd(wc, CMD_MSG_VOIP_VCEOPT(st1->cmd_seqno++, chan1, length, 0), CMD_MSG_VOIP_VCEOPT_LEN, 0x8001);
+	dahdi_send_cmd(wc, CMD_MSG_SET_IP_HDR_CHANNEL(st1->cmd_seqno++, chan1, part2_id, part1_id), CMD_MSG_SET_IP_HDR_CHANNEL_LEN, 0x9000);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_VCEOPT(st1->cmd_seqno++, chan1, length, 0), CMD_MSG_VOIP_VCEOPT_LEN, 0x8001);
 
 	/* Configure simple channel */
-	zt_send_cmd(wc, CMD_MSG_SET_IP_HDR_CHANNEL(st2->cmd_seqno++, chan2, part1_id, part2_id), CMD_MSG_SET_IP_HDR_CHANNEL_LEN, 0x9000);
-	zt_send_cmd(wc, CMD_MSG_VOIP_VCEOPT(st2->cmd_seqno++, chan2, length, 0), CMD_MSG_VOIP_VCEOPT_LEN, 0x8001);
+	dahdi_send_cmd(wc, CMD_MSG_SET_IP_HDR_CHANNEL(st2->cmd_seqno++, chan2, part1_id, part2_id), CMD_MSG_SET_IP_HDR_CHANNEL_LEN, 0x9000);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_VCEOPT(st2->cmd_seqno++, chan2, length, 0), CMD_MSG_VOIP_VCEOPT_LEN, 0x8001);
 
 #ifdef QUIET_DSP
-	zt_send_cmd(wc, CMD_MSG_VOIP_TONECTL(st1->cmd_seqno++, chan1), CMD_MSG_VOIP_TONECTL_LEN, 0x805B);
-	zt_send_cmd(wc, CMD_MSG_VOIP_DTMFOPT(st1->cmd_seqno++, chan1), CMD_MSG_VOIP_DTMFOPT_LEN, 0x8002);
-	zt_send_cmd(wc, CMD_MSG_VOIP_TONECTL(st2->cmd_seqno++, chan2), CMD_MSG_VOIP_TONECTL_LEN, 0x805B);
-	zt_send_cmd(wc, CMD_MSG_VOIP_DTMFOPT(st2->cmd_seqno++, chan2), CMD_MSG_VOIP_DTMFOPT_LEN, 0x8002);
-	zt_send_cmd(wc, CMD_MSG_VOIP_INDCTRL(st1->cmd_seqno++, chan1), CMD_MSG_VOIP_INDCTRL_LEN, 0x8084);
-	zt_send_cmd(wc, CMD_MSG_VOIP_INDCTRL(st2->cmd_seqno++, chan2), CMD_MSG_VOIP_INDCTRL_LEN, 0x8084);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_TONECTL(st1->cmd_seqno++, chan1), CMD_MSG_VOIP_TONECTL_LEN, 0x805B);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_DTMFOPT(st1->cmd_seqno++, chan1), CMD_MSG_VOIP_DTMFOPT_LEN, 0x8002);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_TONECTL(st2->cmd_seqno++, chan2), CMD_MSG_VOIP_TONECTL_LEN, 0x805B);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_DTMFOPT(st2->cmd_seqno++, chan2), CMD_MSG_VOIP_DTMFOPT_LEN, 0x8002);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_INDCTRL(st1->cmd_seqno++, chan1), CMD_MSG_VOIP_INDCTRL_LEN, 0x8084);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_INDCTRL(st2->cmd_seqno++, chan2), CMD_MSG_VOIP_INDCTRL_LEN, 0x8084);
 #endif
 
-	zt_send_cmd(wc, CMD_MSG_TRANS_CONNECT(wc->seq_num++, 1, chan1, chan2, complicated, simple), CMD_MSG_TRANS_CONNECT_LEN, 0x9322);
-	zt_send_cmd(wc, CMD_MSG_VOIP_VOPENA(st1->cmd_seqno++, chan1, complicated), CMD_MSG_VOIP_VOPENA_LEN, 0x8000);
-	zt_send_cmd(wc, CMD_MSG_VOIP_VOPENA(st2->cmd_seqno++, chan2, simple), CMD_MSG_VOIP_VOPENA_LEN, 0x8000);
+	dahdi_send_cmd(wc, CMD_MSG_TRANS_CONNECT(wc->seq_num++, 1, chan1, chan2, complicated, simple), CMD_MSG_TRANS_CONNECT_LEN, 0x9322);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_VOPENA(st1->cmd_seqno++, chan1, complicated), CMD_MSG_VOIP_VOPENA_LEN, 0x8000);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_VOPENA(st2->cmd_seqno++, chan2, simple), CMD_MSG_VOIP_VOPENA_LEN, 0x8000);
 
 	*dte_chan1 = chan1;
 	*dte_chan2 = chan2;
@@ -1579,7 +1579,7 @@ static int wcdte_create_channel(struct wcdte *wc, int simple, int complicated, i
 
 static int wcdte_destroy_channel(struct wcdte *wc, unsigned int chan1, unsigned int chan2)
 {
-	struct zt_transcoder_channel *ztc1, *ztc2;
+	struct dahdi_transcoder_channel *ztc1, *ztc2;
 	struct dte_state *st1, *st2;
 
 	ztc1 = &(wc->uencode->channels[chan1/2]);
@@ -1588,15 +1588,15 @@ static int wcdte_destroy_channel(struct wcdte *wc, unsigned int chan1, unsigned
 	st2 = ztc2->pvt;
 
 	/* Turn off both channels */
-	zt_send_cmd(wc, CMD_MSG_VOIP_VOPENA_CLOSE(st1->cmd_seqno++, chan1), CMD_MSG_VOIP_VOPENA_CLOSE_LEN, 0x8000);
-	zt_send_cmd(wc, CMD_MSG_VOIP_VOPENA_CLOSE(st2->cmd_seqno++, chan2), CMD_MSG_VOIP_VOPENA_CLOSE_LEN, 0x8000);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_VOPENA_CLOSE(st1->cmd_seqno++, chan1), CMD_MSG_VOIP_VOPENA_CLOSE_LEN, 0x8000);
+	dahdi_send_cmd(wc, CMD_MSG_VOIP_VOPENA_CLOSE(st2->cmd_seqno++, chan2), CMD_MSG_VOIP_VOPENA_CLOSE_LEN, 0x8000);
 	
 	/* Disconnect the channels */
-	zt_send_cmd(wc, CMD_MSG_TRANS_CONNECT(wc->seq_num++, 0, chan1, chan2, 0, 0), CMD_MSG_TRANS_CONNECT_LEN, 0x9322);
+	dahdi_send_cmd(wc, CMD_MSG_TRANS_CONNECT(wc->seq_num++, 0, chan1, chan2, 0, 0), CMD_MSG_TRANS_CONNECT_LEN, 0x9322);
 
 	/* Remove the channels */
-	zt_send_cmd(wc, CMD_MSG_DESTROY_CHANNEL(wc->seq_num++, chan1), CMD_MSG_DESTROY_CHANNEL_LEN, 0x0011);
-	zt_send_cmd(wc, CMD_MSG_DESTROY_CHANNEL(wc->seq_num++, chan2), CMD_MSG_DESTROY_CHANNEL_LEN, 0x0011);
+	dahdi_send_cmd(wc, CMD_MSG_DESTROY_CHANNEL(wc->seq_num++, chan1), CMD_MSG_DESTROY_CHANNEL_LEN, 0x0011);
+	dahdi_send_cmd(wc, CMD_MSG_DESTROY_CHANNEL(wc->seq_num++, chan2), CMD_MSG_DESTROY_CHANNEL_LEN, 0x0011);
 
 	return 1;
 }
@@ -1607,34 +1607,34 @@ static int __wcdte_setup_channels(struct wcdte *wc)
 	wc->seq_num = 6;
 
 #ifndef USE_TEST_HW
-	zt_send_cmd(wc, CMD_MSG_SET_ARM_CLK(wc->seq_num++), CMD_MSG_SET_ARM_CLK_LEN, 0x0411);
-	zt_send_cmd(wc, CMD_MSG_SET_SPU_CLK(wc->seq_num++), CMD_MSG_SET_SPU_CLK_LEN, 0x0412);
+	dahdi_send_cmd(wc, CMD_MSG_SET_ARM_CLK(wc->seq_num++), CMD_MSG_SET_ARM_CLK_LEN, 0x0411);
+	dahdi_send_cmd(wc, CMD_MSG_SET_SPU_CLK(wc->seq_num++), CMD_MSG_SET_SPU_CLK_LEN, 0x0412);
 #endif
 
 #ifdef USE_TDM_CONFIG
-	zt_send_cmd(wc, CMD_MSG_TDM_SELECT_BUS_MODE(wc->seq_num++), CMD_MSG_TDM_SELECT_BUS_MODE_LEN, 0x0417);
-	zt_send_cmd(wc, CMD_MSG_TDM_ENABLE_BUS(wc->seq_num++), CMD_MSG_TDM_ENABLE_BUS_LEN, 0x0405);
-	zt_send_cmd(wc, CMD_MSG_SUPVSR_SETUP_TDM_PARMS(wc->seq_num++, 0x03, 0x20, 0x00), CMD_MSG_SUPVSR_SETUP_TDM_PARMS_LEN, 0x0407);
-	zt_send_cmd(wc, CMD_MSG_SUPVSR_SETUP_TDM_PARMS(wc->seq_num++, 0x04, 0x80, 0x04), CMD_MSG_SUPVSR_SETUP_TDM_PARMS_LEN, 0x0407);
-	zt_send_cmd(wc, CMD_MSG_SUPVSR_SETUP_TDM_PARMS(wc->seq_num++, 0x05, 0x20, 0x08), CMD_MSG_SUPVSR_SETUP_TDM_PARMS_LEN, 0x0407);
-	zt_send_cmd(wc, CMD_MSG_SUPVSR_SETUP_TDM_PARMS(wc->seq_num++, 0x06, 0x80, 0x0C), CMD_MSG_SUPVSR_SETUP_TDM_PARMS_LEN, 0x0407);
+	dahdi_send_cmd(wc, CMD_MSG_TDM_SELECT_BUS_MODE(wc->seq_num++), CMD_MSG_TDM_SELECT_BUS_MODE_LEN, 0x0417);
+	dahdi_send_cmd(wc, CMD_MSG_TDM_ENABLE_BUS(wc->seq_num++), CMD_MSG_TDM_ENABLE_BUS_LEN, 0x0405);
+	dahdi_send_cmd(wc, CMD_MSG_SUPVSR_SETUP_TDM_PARMS(wc->seq_num++, 0x03, 0x20, 0x00), CMD_MSG_SUPVSR_SETUP_TDM_PARMS_LEN, 0x0407);
+	dahdi_send_cmd(wc, CMD_MSG_SUPVSR_SETUP_TDM_PARMS(wc->seq_num++, 0x04, 0x80, 0x04), CMD_MSG_SUPVSR_SETUP_TDM_PARMS_LEN, 0x0407);
+	dahdi_send_cmd(wc, CMD_MSG_SUPVSR_SETUP_TDM_PARMS(wc->seq_num++, 0x05, 0x20, 0x08), CMD_MSG_SUPVSR_SETUP_TDM_PARMS_LEN, 0x0407);
+	dahdi_send_cmd(wc, CMD_MSG_SUPVSR_SETUP_TDM_PARMS(wc->seq_num++, 0x06, 0x80, 0x0C), CMD_MSG_SUPVSR_SETUP_TDM_PARMS_LEN, 0x0407);
 #endif
 
-	zt_send_cmd(wc, CMD_MSG_SET_ETH_HEADER(wc->seq_num++), CMD_MSG_SET_ETH_HEADER_LEN, 0x0100);
-	zt_send_cmd(wc, CMD_MSG_IP_SERVICE_CONFIG(wc->seq_num++), CMD_MSG_IP_SERVICE_CONFIG_LEN, 0x0302);
-	zt_send_cmd(wc, CMD_MSG_ARP_SERVICE_CONFIG(wc->seq_num++), CMD_MSG_ARP_SERVICE_CONFIG_LEN, 0x0105);
-	zt_send_cmd(wc, CMD_MSG_ICMP_SERVICE_CONFIG(wc->seq_num++), CMD_MSG_ICMP_SERVICE_CONFIG_LEN, 0x0304);
+	dahdi_send_cmd(wc, CMD_MSG_SET_ETH_HEADER(wc->seq_num++), CMD_MSG_SET_ETH_HEADER_LEN, 0x0100);
+	dahdi_send_cmd(wc, CMD_MSG_IP_SERVICE_CONFIG(wc->seq_num++), CMD_MSG_IP_SERVICE_CONFIG_LEN, 0x0302);
+	dahdi_send_cmd(wc, CMD_MSG_ARP_SERVICE_CONFIG(wc->seq_num++), CMD_MSG_ARP_SERVICE_CONFIG_LEN, 0x0105);
+	dahdi_send_cmd(wc, CMD_MSG_ICMP_SERVICE_CONFIG(wc->seq_num++), CMD_MSG_ICMP_SERVICE_CONFIG_LEN, 0x0304);
 
 #ifdef USE_TDM_CONFIG
-	zt_send_cmd(wc, CMD_MSG_DEVICE_SET_COUNTRY_CODE(wc->seq_num++), CMD_MSG_DEVICE_SET_COUNTRY_CODE_LEN, 0x041B);
+	dahdi_send_cmd(wc, CMD_MSG_DEVICE_SET_COUNTRY_CODE(wc->seq_num++), CMD_MSG_DEVICE_SET_COUNTRY_CODE_LEN, 0x041B);
 #endif
 
-	zt_send_cmd(wc, CMD_MSG_SPU_FEATURES_CONTROL(wc->seq_num++, 0x02), CMD_MSG_SPU_FEATURES_CONTROL_LEN, 0x0013);
-	zt_send_cmd(wc, CMD_MSG_IP_OPTIONS(wc->seq_num++), CMD_MSG_IP_OPTIONS_LEN, 0x0306);
-	zt_send_cmd(wc, CMD_MSG_SPU_FEATURES_CONTROL(wc->seq_num++, 0x04), CMD_MSG_SPU_FEATURES_CONTROL_LEN, 0x0013);
+	dahdi_send_cmd(wc, CMD_MSG_SPU_FEATURES_CONTROL(wc->seq_num++, 0x02), CMD_MSG_SPU_FEATURES_CONTROL_LEN, 0x0013);
+	dahdi_send_cmd(wc, CMD_MSG_IP_OPTIONS(wc->seq_num++), CMD_MSG_IP_OPTIONS_LEN, 0x0306);
+	dahdi_send_cmd(wc, CMD_MSG_SPU_FEATURES_CONTROL(wc->seq_num++, 0x04), CMD_MSG_SPU_FEATURES_CONTROL_LEN, 0x0013);
 
 #ifdef USE_TDM_CONFIG
-	zt_send_cmd(wc, CMD_MSG_TDM_OPT(wc->seq_num++), CMD_MSG_TDM_OPT_LEN, 0x0435);
+	dahdi_send_cmd(wc, CMD_MSG_TDM_OPT(wc->seq_num++), CMD_MSG_TDM_OPT_LEN, 0x0435);
 #endif
 
 	wc->timeout = HZ/10 + 1; 	/* 100msec */
@@ -1772,33 +1772,33 @@ static int __devinit wcdte_init_one(struct pci_dev *pdev, const struct pci_devic
 
 			if (!mode || strlen(mode) < 4) {
 				sprintf(wc->complexname, "G.729a / G.723.1");
- 				complexfmts = ZT_FORMAT_G729A | ZT_FORMAT_G723_1;
+ 				complexfmts = DAHDI_FORMAT_G729A | DAHDI_FORMAT_G723_1;
 				wc->numchannels = min_numchannels;
 			} else if (mode[3] == '9') {	/* "G.729" */
 				sprintf(wc->complexname, "G.729a");
-				complexfmts = ZT_FORMAT_G729A;
+				complexfmts = DAHDI_FORMAT_G729A;
 				wc->numchannels = g729_numchannels;
 			} else if (mode[3] == '3') {	/* "G.723.1" */
 				sprintf(wc->complexname, "G.723.1");
-				complexfmts = ZT_FORMAT_G723_1;
+				complexfmts = DAHDI_FORMAT_G723_1;
 				wc->numchannels = g723_numchannels;
 			} else {
 				sprintf(wc->complexname, "G.729a / G.723.1");
-				complexfmts = ZT_FORMAT_G729A | ZT_FORMAT_G723_1;
+				complexfmts = DAHDI_FORMAT_G729A | DAHDI_FORMAT_G723_1;
 				wc->numchannels = min_numchannels;
 			}
 			
-			uencode = zt_transcoder_alloc(wc->numchannels);
-			udecode = zt_transcoder_alloc(wc->numchannels);
+			uencode = dahdi_transcoder_alloc(wc->numchannels);
+			udecode = dahdi_transcoder_alloc(wc->numchannels);
 			encoders = vmalloc(sizeof(struct dte_state) * wc->numchannels);
 			decoders = vmalloc(sizeof(struct dte_state) * wc->numchannels);
 			memset(encoders, 0, sizeof(struct dte_state) * wc->numchannels);
 			memset(decoders, 0, sizeof(struct dte_state) * wc->numchannels);
 			if (!uencode || !udecode || !encoders || !decoders) {
 				if (uencode)
-					zt_transcoder_free(uencode);
+					dahdi_transcoder_free(uencode);
 				if (udecode)
-					zt_transcoder_free(udecode);
+					dahdi_transcoder_free(udecode);
 				if (encoders)
 					vfree(encoders);
 				if (decoders)
@@ -1809,7 +1809,7 @@ static int __devinit wcdte_init_one(struct pci_dev *pdev, const struct pci_devic
 			sprintf(uencode->name, "DTE Encoder");
 	
 			udecode->srcfmts = uencode->dstfmts = complexfmts;
-			udecode->dstfmts = uencode->srcfmts = ZT_FORMAT_ULAW | ZT_FORMAT_ALAW;
+			udecode->dstfmts = uencode->srcfmts = DAHDI_FORMAT_ULAW | DAHDI_FORMAT_ALAW;
 			
 			udecode->operation = uencode->operation = dte_operation;
 
@@ -1825,8 +1825,8 @@ static int __devinit wcdte_init_one(struct pci_dev *pdev, const struct pci_devic
 			wc->uencode = uencode;
 			wc->udecode = udecode;
 		
-			zt_transcoder_register(uencode);
-			zt_transcoder_register(udecode);
+			dahdi_transcoder_register(uencode);
+			dahdi_transcoder_register(udecode);
 
 			printk("Zaptel DTE (%s) Transcoder support LOADED (firm ver = %d.%d)\n", wc->complexname, dte_firmware_ver, dte_firmware_ver_minor);
 
@@ -1927,7 +1927,7 @@ static void __devexit wcdte_remove_one(struct pci_dev *pdev)
 {
 	int i;
 	struct wcdte *wc = pci_get_drvdata(pdev);
-	struct zt_transcoder_channel *ztc_en, *ztc_de;
+	struct dahdi_transcoder_channel *ztc_en, *ztc_de;
 	struct dte_state *st_en, *st_de;
 
 	if (wc) {
@@ -1949,10 +1949,10 @@ static void __devexit wcdte_remove_one(struct pci_dev *pdev)
 			}
 		}
 
-		zt_transcoder_unregister(wc->udecode);
-		zt_transcoder_unregister(wc->uencode);
-		zt_transcoder_free(wc->uencode);
-		zt_transcoder_free(wc->udecode);
+		dahdi_transcoder_unregister(wc->udecode);
+		dahdi_transcoder_unregister(wc->uencode);
+		dahdi_transcoder_free(wc->uencode);
+		dahdi_transcoder_free(wc->udecode);
 		vfree(wc->uencode->channels[0].pvt);
 		vfree(wc->udecode->channels[0].pvt);
 	
diff --git a/drivers/dahdi/wctc4xxp/codec_test.c b/drivers/dahdi/wctc4xxp/codec_test.c
index 85a1d41..0afcebf 100644
--- a/drivers/dahdi/wctc4xxp/codec_test.c
+++ b/drivers/dahdi/wctc4xxp/codec_test.c
@@ -77,7 +77,7 @@ struct tcpvt {
 	int fd;
 	int fake;
 	int inuse;
-	struct zt_transcode_header *hdr;
+	struct dahdi_transcode_header *hdr;
 // 	struct ast_frame f;
 };
 
@@ -96,7 +96,7 @@ struct tctest_info {
 
 static int find_transcoders(struct tctest_info *tctest_info)
 {
-	struct zt_transcode_info info = { 0, };
+	struct dahdi_transcode_info info = { 0, };
 	int fd, res;
 
 	if ((fd = open("/dev/zap/transcode", O_RDWR)) < 0) {
@@ -105,8 +105,8 @@ static int find_transcoders(struct tctest_info *tctest_info)
 	}
 
 	tctest_info->total_chans = 0;
-	info.op = ZT_TCOP_GETINFO;
-	for (info.tcnum = 0; !(res = ioctl(fd, ZT_TRANSCODE_OP, &info)); info.tcnum++) {
+	info.op = DAHDI_TCOP_GETINFO;
+	for (info.tcnum = 0; !(res = ioctl(fd, DAHDI_TRANSCODE_OP, &info)); info.tcnum++) {
 		if (debug)
 			printf("Found transcoder %d, '%s' with %d channels.\n", info.tcnum, info.name, info.numchannels);
 		if ((info.tcnum % 2) == 0)
@@ -127,8 +127,8 @@ static int find_transcoders(struct tctest_info *tctest_info)
 static int open_transcoder(struct tcpvt *ztp, int dest, int source)
 {
 	int fd;
-	unsigned int x = ZT_TCOP_ALLOCATE;
-	struct zt_transcode_header *hdr;
+	unsigned int x = DAHDI_TCOP_ALLOCATE;
+	struct dahdi_transcode_header *hdr;
 	int flags;
 
 	if ((fd = open("/dev/zap/transcode", O_RDWR)) < 0)
@@ -146,7 +146,7 @@ static int open_transcoder(struct tcpvt *ztp, int dest, int source)
 		return -1;
 	}
 
-	if (hdr->magic != ZT_TRANSCODE_MAGIC) {
+	if (hdr->magic != DAHDI_TRANSCODE_MAGIC) {
 		printf("Transcoder header (%08x) wasn't magic.  Abandoning\n", hdr->magic);
 		munmap(hdr, sizeof(*hdr));
 		close(fd);
@@ -157,7 +157,7 @@ static int open_transcoder(struct tcpvt *ztp, int dest, int source)
 	hdr->srcfmt = source;
 	hdr->dstfmt = dest;
 
-	if (ioctl(fd, ZT_TRANSCODE_OP, &x)) {
+	if (ioctl(fd, DAHDI_TRANSCODE_OP, &x)) {
 		printf("Unable to attach transcoder: %s\n", strerror(errno));
 		munmap(hdr, sizeof(*hdr));
 		close(fd);
@@ -176,8 +176,8 @@ static void close_transcoder(struct tcpvt *ztp)
 {
 	unsigned int x;
 
-	x = ZT_TCOP_RELEASE;
-	if (ioctl(ztp->fd, ZT_TRANSCODE_OP, &x))
+	x = DAHDI_TCOP_RELEASE;
+	if (ioctl(ztp->fd, DAHDI_TRANSCODE_OP, &x))
 		printf("Failed to release transcoder channel: %s\n", strerror(errno));
 				
 	munmap(ztp->hdr, sizeof(*ztp->hdr));
@@ -187,7 +187,7 @@ static void close_transcoder(struct tcpvt *ztp)
 
 static int encode_packet(struct tcpvt *ztp, unsigned char *packet_in, unsigned char *packet_out)
 {
-	struct zt_transcode_header *hdr = ztp->hdr;
+	struct dahdi_transcode_header *hdr = ztp->hdr;
 	unsigned int x;
 
 	hdr->srcoffset = 0;
@@ -197,8 +197,8 @@ static int encode_packet(struct tcpvt *ztp, unsigned char *packet_in, unsigned c
 
 
 	hdr->dstoffset = AST_FRIENDLY_OFFSET;
-	x = ZT_TCOP_TRANSCODE;
-	if (ioctl(ztp->fd, ZT_TRANSCODE_OP, &x))
+	x = DAHDI_TCOP_TRANSCODE;
+	if (ioctl(ztp->fd, DAHDI_TRANSCODE_OP, &x))
 		printf("Failed to transcode: %s\n", strerror(errno));
 
 	usleep(20000);
diff --git a/drivers/dahdi/wctdm.c b/drivers/dahdi/wctdm.c
index 56db4b3..aa38945 100644
--- a/drivers/dahdi/wctdm.c
+++ b/drivers/dahdi/wctdm.c
@@ -198,7 +198,7 @@ enum battery_state {
 struct wctdm {
 	struct pci_dev *dev;
 	char *variety;
-	struct zt_span span;
+	struct dahdi_span span;
 	unsigned char ios;
 	int usecount;
 	unsigned int intcount;
@@ -255,7 +255,7 @@ struct wctdm {
 	dma_addr_t	writedma;
 	volatile unsigned int *writechunk;				/* Double-word aligned write memory */
 	volatile unsigned int *readchunk;				/* Double-word aligned read memory */
-	struct zt_chan chans[NUM_CARDS];
+	struct dahdi_chan chans[NUM_CARDS];
 };
 
 
@@ -305,11 +305,11 @@ static inline void wctdm_transmitprep(struct wctdm *wc, unsigned char ints)
 		/* Write is at interrupt address.  Start writing from normal offset */
 		writechunk = wc->writechunk;
 	else 
-		writechunk = wc->writechunk + ZT_CHUNKSIZE;
+		writechunk = wc->writechunk + DAHDI_CHUNKSIZE;
 	/* Calculate Transmission */
-	zt_transmit(&wc->span);
+	dahdi_transmit(&wc->span);
 
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		/* Send a sample, as a 32-bit word */
 		writechunk[x] = 0;
 #ifdef __BIG_ENDIAN
@@ -342,10 +342,10 @@ static inline void ring_check(struct wctdm *wc, int card)
 	short sample;
 	if (wc->modtype[card] != MOD_TYPE_FXO)
 		return;
-	wc->mod[card].fxo.pegtimer += ZT_CHUNKSIZE;
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	wc->mod[card].fxo.pegtimer += DAHDI_CHUNKSIZE;
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		/* Look for pegging to indicate ringing */
-		sample = ZT_XLAW(wc->chans[card].readchunk[x], (&(wc->chans[card])));
+		sample = DAHDI_XLAW(wc->chans[card].readchunk[x], (&(wc->chans[card])));
 		if ((sample > 10000) && (wc->mod[card].fxo.peg != 1)) {
 			if (debug > 1) printk("High peg!\n");
 			if ((wc->mod[card].fxo.pegtimer < PEGTIME) && (wc->mod[card].fxo.pegtimer > MINPEGTIME))
@@ -373,14 +373,14 @@ static inline void ring_check(struct wctdm *wc, int card)
 			if (debug)
 				printk("RING on %d/%d!\n", wc->span.spanno, card + 1);
 			if (!wc->mod[card].fxo.offhook)
-				zt_hooksig(&wc->chans[card], ZT_RXSIG_RING);
+				dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_RING);
 			wc->mod[card].fxo.ring = 1;
 		}
 		if (wc->mod[card].fxo.ring && !wc->mod[card].fxo.pegcount) {
 			/* No more ring */
 			if (debug)
 				printk("NO RING on %d/%d!\n", wc->span.spanno, card + 1);
-			zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+			dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 			wc->mod[card].fxo.ring = 0;
 		}
 	}
@@ -392,11 +392,11 @@ static inline void wctdm_receiveprep(struct wctdm *wc, unsigned char ints)
 	int x;
 
 	if (ints & 0x08)
-		readchunk = wc->readchunk + ZT_CHUNKSIZE;
+		readchunk = wc->readchunk + DAHDI_CHUNKSIZE;
 	else
 		/* Read is at interrupt address.  Valid data is available at normal offset */
 		readchunk = wc->readchunk;
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 #ifdef __BIG_ENDIAN
 		if (wc->cardflag & (1 << 3))
 			wc->chans[3].readchunk[x] = (readchunk[x]) & 0xff;
@@ -424,9 +424,9 @@ static inline void wctdm_receiveprep(struct wctdm *wc, unsigned char ints)
 	/* XXX We're wasting 8 taps.  We should get closer :( */
 	for (x = 0; x < NUM_CARDS; x++) {
 		if (wc->cardflag & (1 << x))
-			zt_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, wc->chans[x].writechunk);
+			dahdi_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, wc->chans[x].writechunk);
 	}
-	zt_receive(&wc->span);
+	dahdi_receive(&wc->span);
 }
 
 static void wctdm_stop_dma(struct wctdm *wc);
@@ -782,7 +782,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 						fxo->wasringing = 1;
 						if (debug)
 							printk("RING on %d/%d!\n", wc->span.spanno, card + 1);
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_RING);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_RING);
 					}
 					fxo->lastrdtx = res;
 					fxo->ringdebounce = 10;
@@ -791,7 +791,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 						fxo->wasringing = 0;
 						if (debug)
 							printk("NO RING on %d/%d!\n", wc->span.spanno, card + 1);
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 					}
 				}
 			} else if (res && (fxo->battery == BATTERY_PRESENT)) {
@@ -801,22 +801,22 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 		} else {
 			res = wc->reg0shadow[card];
 			if ((res & 0x60) && (fxo->battery == BATTERY_PRESENT)) {
-				fxo->ringdebounce += (ZT_CHUNKSIZE * 16);
-				if (fxo->ringdebounce >= ZT_CHUNKSIZE * ringdebounce) {
+				fxo->ringdebounce += (DAHDI_CHUNKSIZE * 16);
+				if (fxo->ringdebounce >= DAHDI_CHUNKSIZE * ringdebounce) {
 					if (!fxo->wasringing) {
 						fxo->wasringing = 1;
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_RING);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_RING);
 						if (debug)
 							printk("RING on %d/%d!\n", wc->span.spanno, card + 1);
 					}
-					fxo->ringdebounce = ZT_CHUNKSIZE * ringdebounce;
+					fxo->ringdebounce = DAHDI_CHUNKSIZE * ringdebounce;
 				}
 			} else {
-				fxo->ringdebounce -= ZT_CHUNKSIZE * 4;
+				fxo->ringdebounce -= DAHDI_CHUNKSIZE * 4;
 				if (fxo->ringdebounce <= 0) {
 					if (fxo->wasringing) {
 						fxo->wasringing = 0;
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 						if (debug)
 							printk("NO RING on %d/%d!\n", wc->span.spanno, card + 1);
 					}
@@ -851,7 +851,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 						printk("NO BATTERY on %d/%d!\n", wc->span.spanno, card + 1);
 #ifdef	JAPAN
 					if (!wc->ohdebounce && wc->offhook) {
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_ONHOOK);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_ONHOOK);
 						if (debug)
 							printk("Signalled On Hook\n");
 #ifdef	ZERO_BATT_RING
@@ -859,7 +859,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 #endif
 					}
 #else
-					zt_hooksig(&wc->chans[card], ZT_RXSIG_ONHOOK);
+					dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_ONHOOK);
 					/* set the alarm timer, taking into account that part of its time
 					   period has already passed while debouncing occurred */
 					fxo->battalarm = (battalarm - battdebounce) / MS_PER_CHECK_HOOK;
@@ -895,12 +895,12 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 #ifdef	ZERO_BATT_RING
 					if (wc->onhook) {
 						wc->onhook = 0;
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 						if (debug)
 							printk("Signalled Off Hook\n");
 					}
 #else
-					zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+					dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 #endif
 					/* set the alarm timer, taking into account that part of its time
 					   period has already passed while debouncing occurred */
@@ -930,7 +930,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 		if (--fxo->battalarm == 0) {
 			/* the alarm timer has expired, so update the battery alarm state
 			   for this channel */
-			zt_alarm_channel(&wc->chans[card], fxo->battery ? ZT_ALARM_NONE : ZT_ALARM_RED);
+			dahdi_alarm_channel(&wc->chans[card], fxo->battery ? DAHDI_ALARM_NONE : DAHDI_ALARM_RED);
 		}
 	}
 
@@ -942,7 +942,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 				       fxo->polarity, 
 				       fxo->lastpol);
 				if (fxo->polarity)
-					zt_qevent_lock(&wc->chans[card], ZT_EVENT_POLARITY);
+					dahdi_qevent_lock(&wc->chans[card], DAHDI_EVENT_POLARITY);
 				fxo->polarity = fxo->lastpol;
 		    }
 		}
@@ -968,7 +968,7 @@ static inline void wctdm_proslic_check_hook(struct wctdm *wc, int card)
 #endif
 	} else {
 		if (wc->mod[card].fxs.debounce > 0) {
-			wc->mod[card].fxs.debounce-= 16 * ZT_CHUNKSIZE;
+			wc->mod[card].fxs.debounce-= 16 * DAHDI_CHUNKSIZE;
 #if 0
 			printk("Sustaining hook %d, %d\n", hook, wc->mod[card].fxs.debounce);
 #endif
@@ -984,7 +984,7 @@ static inline void wctdm_proslic_check_hook(struct wctdm *wc, int card)
 				if (debug)
 #endif				
 					printk("wctdm: Card %d Going off hook\n", card);
-				zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+				dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 				if (robust)
 					wctdm_init_proslic(wc, card, 1, 0, 1);
 				wc->mod[card].fxs.oldrxhook = 1;
@@ -995,7 +995,7 @@ static inline void wctdm_proslic_check_hook(struct wctdm *wc, int card)
 				if (debug)
 #endif				
 					printk("wctdm: Card %d Going on hook\n", card);
-				zt_hooksig(&wc->chans[card], ZT_RXSIG_ONHOOK);
+				dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_ONHOOK);
 				wc->mod[card].fxs.oldrxhook = 0;
 			}
 		}
@@ -1053,7 +1053,7 @@ ZAP_IRQ_HANDLER(wctdm_interrupt)
 					wc->mod[x].fxs.idletxhookstate = 0x2; 
 			} else {
 				if (wc->mod[x].fxs.ohttimer) {
-					wc->mod[x].fxs.ohttimer-= ZT_CHUNKSIZE;
+					wc->mod[x].fxs.ohttimer-= DAHDI_CHUNKSIZE;
 					if (!wc->mod[x].fxs.ohttimer) {
 						if (reversepolarity)
 							wc->mod[x].fxs.idletxhookstate = 0x5;	/* Switch to active */
@@ -1795,17 +1795,17 @@ static int wctdm_init_proslic(struct wctdm *wc, int card, int fast, int manual,
 }
 
 
-static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
+static int wctdm_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data)
 {
 	struct wctdm_stats stats;
 	struct wctdm_regs regs;
 	struct wctdm_regop regop;
 	struct wctdm_echo_coefs echoregs;
-	struct zt_hwgain hwgain;
+	struct dahdi_hwgain hwgain;
 	struct wctdm *wc = chan->pvt;
 	int x;
 	switch (cmd) {
-	case ZT_ONHOOKTRANSFER:
+	case DAHDI_ONHOOKTRANSFER:
 		if (wc->modtype[chan->chanpos - 1] != MOD_TYPE_FXS)
 			return -EINVAL;
 		if (get_user(x, (int *)data))
@@ -1824,7 +1824,7 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 				wctdm_setreg(wc, chan->chanpos - 1, 64, wc->mod[chan->chanpos - 1].fxs.lasttxhook);
 		}
 		break;
-	case ZT_SETPOLARITY:
+	case DAHDI_SETPOLARITY:
 		if (get_user(x, (int *)data))
 			return -EFAULT;
 		if (wc->modtype[chan->chanpos - 1] != MOD_TYPE_FXS)
@@ -1909,8 +1909,8 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 
 		}
 		break;
-	case ZT_SET_HWGAIN:
-		if (copy_from_user(&hwgain, (struct zt_hwgain*) data, sizeof(hwgain)))
+	case DAHDI_SET_HWGAIN:
+		if (copy_from_user(&hwgain, (struct dahdi_hwgain*) data, sizeof(hwgain)))
 			return -EFAULT;
 
 		wctdm_set_hwgain(wc, chan->chanpos-1, hwgain.newgain, hwgain.tx);
@@ -1926,7 +1926,7 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 
 }
 
-static int wctdm_open(struct zt_chan *chan)
+static int wctdm_open(struct dahdi_chan *chan)
 {
 	struct wctdm *wc = chan->pvt;
 	if (!(wc->cardflag & (1 << (chan->chanpos - 1))))
@@ -1942,14 +1942,14 @@ static int wctdm_open(struct zt_chan *chan)
 	return 0;
 }
 
-static int wctdm_watchdog(struct zt_span *span, int event)
+static int wctdm_watchdog(struct dahdi_span *span, int event)
 {
 	printk("TDM: Restarting DMA\n");
 	wctdm_restart_dma(span->pvt);
 	return 0;
 }
 
-static int wctdm_close(struct zt_chan *chan)
+static int wctdm_close(struct dahdi_chan *chan)
 {
 	struct wctdm *wc = chan->pvt;
 	wc->usecount--;
@@ -1970,19 +1970,19 @@ static int wctdm_close(struct zt_chan *chan)
 	return 0;
 }
 
-static int wctdm_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
+static int wctdm_hooksig(struct dahdi_chan *chan, dahdi_txsig_t txsig)
 {
 	struct wctdm *wc = chan->pvt;
 	int reg=0;
 	if (wc->modtype[chan->chanpos - 1] == MOD_TYPE_FXO) {
 		/* XXX Enable hooksig for FXO XXX */
 		switch(txsig) {
-		case ZT_TXSIG_START:
-		case ZT_TXSIG_OFFHOOK:
+		case DAHDI_TXSIG_START:
+		case DAHDI_TXSIG_OFFHOOK:
 			wc->mod[chan->chanpos - 1].fxo.offhook = 1;
 			wctdm_setreg(wc, chan->chanpos - 1, 5, 0x9);
 			break;
-		case ZT_TXSIG_ONHOOK:
+		case DAHDI_TXSIG_ONHOOK:
 			wc->mod[chan->chanpos - 1].fxo.offhook = 0;
 			wctdm_setreg(wc, chan->chanpos - 1, 5, 0x8);
 			break;
@@ -1991,21 +1991,21 @@ static int wctdm_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
 		}
 	} else {
 		switch(txsig) {
-		case ZT_TXSIG_ONHOOK:
+		case DAHDI_TXSIG_ONHOOK:
 			switch(chan->sig) {
-			case ZT_SIG_EM:
-			case ZT_SIG_FXOKS:
-			case ZT_SIG_FXOLS:
+			case DAHDI_SIG_EM:
+			case DAHDI_SIG_FXOKS:
+			case DAHDI_SIG_FXOLS:
 				wc->mod[chan->chanpos-1].fxs.lasttxhook = wc->mod[chan->chanpos-1].fxs.idletxhookstate;
 				break;
-			case ZT_SIG_FXOGS:
+			case DAHDI_SIG_FXOGS:
 				wc->mod[chan->chanpos-1].fxs.lasttxhook = 3;
 				break;
 			}
 			break;
-		case ZT_TXSIG_OFFHOOK:
+		case DAHDI_TXSIG_OFFHOOK:
 			switch(chan->sig) {
-			case ZT_SIG_EM:
+			case DAHDI_SIG_EM:
 				wc->mod[chan->chanpos-1].fxs.lasttxhook = 5;
 				break;
 			default:
@@ -2013,10 +2013,10 @@ static int wctdm_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
 				break;
 			}
 			break;
-		case ZT_TXSIG_START:
+		case DAHDI_TXSIG_START:
 			wc->mod[chan->chanpos-1].fxs.lasttxhook = 4;
 			break;
-		case ZT_TXSIG_KEWL:
+		case DAHDI_TXSIG_KEWL:
 			wc->mod[chan->chanpos-1].fxs.lasttxhook = 0;
 			break;
 		default:
@@ -2045,13 +2045,13 @@ static int wctdm_initialize(struct wctdm *wc)
 	zap_copy_string(wc->span.devicetype, wc->variety, sizeof(wc->span.devicetype));
 	if (alawoverride) {
 		printk("ALAW override parameter detected.  Device will be operating in ALAW\n");
-		wc->span.deflaw = ZT_LAW_ALAW;
+		wc->span.deflaw = DAHDI_LAW_ALAW;
 	} else
-		wc->span.deflaw = ZT_LAW_MULAW;
+		wc->span.deflaw = DAHDI_LAW_MULAW;
 	for (x = 0; x < NUM_CARDS; x++) {
 		sprintf(wc->chans[x].name, "WCTDM/%d/%d", wc->pos, x);
-		wc->chans[x].sigcap = ZT_SIG_FXOKS | ZT_SIG_FXOLS | ZT_SIG_FXOGS | ZT_SIG_SF | ZT_SIG_EM | ZT_SIG_CLEAR;
-		wc->chans[x].sigcap |= ZT_SIG_FXSKS | ZT_SIG_FXSLS | ZT_SIG_SF | ZT_SIG_CLEAR;
+		wc->chans[x].sigcap = DAHDI_SIG_FXOKS | DAHDI_SIG_FXOLS | DAHDI_SIG_FXOGS | DAHDI_SIG_SF | DAHDI_SIG_EM | DAHDI_SIG_CLEAR;
+		wc->chans[x].sigcap |= DAHDI_SIG_FXSKS | DAHDI_SIG_FXSLS | DAHDI_SIG_SF | DAHDI_SIG_CLEAR;
 		wc->chans[x].chanpos = x+1;
 		wc->chans[x].pvt = wc;
 	}
@@ -2061,13 +2061,13 @@ static int wctdm_initialize(struct wctdm *wc)
 	wc->span.irq = wc->dev->irq;
 	wc->span.open = wctdm_open;
 	wc->span.close = wctdm_close;
-	wc->span.flags = ZT_FLAG_RBS;
+	wc->span.flags = DAHDI_FLAG_RBS;
 	wc->span.ioctl = wctdm_ioctl;
 	wc->span.watchdog = wctdm_watchdog;
 	init_waitqueue_head(&wc->span.maintq);
 
 	wc->span.pvt = wc;
-	if (zt_register(&wc->span, 0)) {
+	if (dahdi_register(&wc->span, 0)) {
 		printk("Unable to register span with zaptel\n");
 		return -1;
 	}
@@ -2082,10 +2082,10 @@ static void wctdm_post_initialize(struct wctdm *wc)
 	for (x = 0; x < NUM_CARDS; x++) {
 		if (wc->cardflag & (1 << x)) {
 			if (wc->modtype[x] == MOD_TYPE_FXO)
-				wc->chans[x].sigcap = ZT_SIG_FXSKS | ZT_SIG_FXSLS | ZT_SIG_SF | ZT_SIG_CLEAR;
+				wc->chans[x].sigcap = DAHDI_SIG_FXSKS | DAHDI_SIG_FXSLS | DAHDI_SIG_SF | DAHDI_SIG_CLEAR;
 			else
-				wc->chans[x].sigcap = ZT_SIG_FXOKS | ZT_SIG_FXOLS | ZT_SIG_FXOGS | ZT_SIG_SF | ZT_SIG_EM | ZT_SIG_CLEAR;
-		} else if (!(wc->chans[x].sigcap & ZT_SIG_BROKEN)) {
+				wc->chans[x].sigcap = DAHDI_SIG_FXOKS | DAHDI_SIG_FXOLS | DAHDI_SIG_FXOGS | DAHDI_SIG_SF | DAHDI_SIG_EM | DAHDI_SIG_CLEAR;
+		} else if (!(wc->chans[x].sigcap & DAHDI_SIG_BROKEN)) {
 			wc->chans[x].sigcap = 0;
 		}
 	}
@@ -2164,12 +2164,12 @@ static int wctdm_hardware_init(struct wctdm *wc)
 
 	/* Setup DMA Addresses */
 	outl(wc->writedma,                    wc->ioaddr + WC_DMAWS);		/* Write start */
-	outl(wc->writedma + ZT_CHUNKSIZE * 4 - 4, wc->ioaddr + WC_DMAWI);		/* Middle (interrupt) */
-	outl(wc->writedma + ZT_CHUNKSIZE * 8 - 4, wc->ioaddr + WC_DMAWE);			/* End */
+	outl(wc->writedma + DAHDI_CHUNKSIZE * 4 - 4, wc->ioaddr + WC_DMAWI);		/* Middle (interrupt) */
+	outl(wc->writedma + DAHDI_CHUNKSIZE * 8 - 4, wc->ioaddr + WC_DMAWE);			/* End */
 	
 	outl(wc->readdma,                    	 wc->ioaddr + WC_DMARS);	/* Read start */
-	outl(wc->readdma + ZT_CHUNKSIZE * 4 - 4, 	 wc->ioaddr + WC_DMARI);	/* Middle (interrupt) */
-	outl(wc->readdma + ZT_CHUNKSIZE * 8 - 4, wc->ioaddr + WC_DMARE);	/* End */
+	outl(wc->readdma + DAHDI_CHUNKSIZE * 4 - 4, 	 wc->ioaddr + WC_DMARI);	/* Middle (interrupt) */
+	outl(wc->readdma + DAHDI_CHUNKSIZE * 8 - 4, wc->ioaddr + WC_DMARE);	/* End */
 	
 	/* Clear interrupts */
 	outb(0xff, wc->ioaddr + WC_INTSTAT);
@@ -2203,7 +2203,7 @@ static int wctdm_hardware_init(struct wctdm *wc)
 					printk("Module %d: Installed -- MANUAL FXS\n",x);
 				} else {
 					printk("Module %d: FAILED FXS (%s)\n", x, fxshonormode ? fxo_modes[_opermode].name : "FCC");
-					wc->chans[x].sigcap = __ZT_SIG_FXO | ZT_SIG_BROKEN;
+					wc->chans[x].sigcap = __DAHDI_SIG_FXO | DAHDI_SIG_BROKEN;
 				} 
 			} else if (!(ret = wctdm_init_voicedaa(wc, x, 0, 0, sane))) {
 				wc->cardflag |= (1 << x);
@@ -2301,7 +2301,7 @@ static int __devinit wctdm_init_one(struct pci_dev *pdev, const struct pci_devic
 
 			/* Allocate enough memory for two zt chunks, receive and transmit.  Each sample uses
 			   32 bits.  Allocate an extra set just for control too */
-			wc->writechunk = pci_alloc_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, &wc->writedma);
+			wc->writechunk = pci_alloc_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, &wc->writedma);
 			if (!wc->writechunk) {
 				printk("wctdm: Unable to allocate DMA-able memory\n");
 				if (wc->freeregion)
@@ -2309,8 +2309,8 @@ static int __devinit wctdm_init_one(struct pci_dev *pdev, const struct pci_devic
 				return -ENOMEM;
 			}
 
-			wc->readchunk = wc->writechunk + ZT_MAX_CHUNKSIZE * 2;	/* in doublewords */
-			wc->readdma = wc->writedma + ZT_MAX_CHUNKSIZE * 8;		/* in bytes */
+			wc->readchunk = wc->writechunk + DAHDI_MAX_CHUNKSIZE * 2;	/* in doublewords */
+			wc->readdma = wc->writedma + DAHDI_MAX_CHUNKSIZE * 8;		/* in bytes */
 
 			if (wctdm_initialize(wc)) {
 				printk("wctdm: Unable to intialize FXS\n");
@@ -2321,7 +2321,7 @@ static int __devinit wctdm_init_one(struct pci_dev *pdev, const struct pci_devic
 				free_irq(pdev->irq, wc);
 				if (wc->freeregion)
 					release_region(wc->ioaddr, 0xff);
-				pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
+				pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
 				kfree(wc);
 				return -EIO;
 			}
@@ -2336,7 +2336,7 @@ static int __devinit wctdm_init_one(struct pci_dev *pdev, const struct pci_devic
 				printk("wctdm: Unable to request IRQ %d\n", pdev->irq);
 				if (wc->freeregion)
 					release_region(wc->ioaddr, 0xff);
-				pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
+				pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
 				pci_set_drvdata(pdev, NULL);
 				kfree(wc);
 				return -EIO;
@@ -2353,9 +2353,9 @@ static int __devinit wctdm_init_one(struct pci_dev *pdev, const struct pci_devic
 				free_irq(pdev->irq, wc);
 				if (wc->freeregion)
 					release_region(wc->ioaddr, 0xff);
-				pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
+				pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
 				pci_set_drvdata(pdev, NULL);
-				zt_unregister(&wc->span);
+				dahdi_unregister(&wc->span);
 				kfree(wc);
 				return -EIO;
 
@@ -2366,7 +2366,7 @@ static int __devinit wctdm_init_one(struct pci_dev *pdev, const struct pci_devic
 			/* Enable interrupts */
 			wctdm_enable_interrupts(wc);
 			/* Initialize Write/Buffers to all blank data */
-			memset((void *)wc->writechunk,0,ZT_MAX_CHUNKSIZE * 2 * 2 * 4);
+			memset((void *)wc->writechunk,0,DAHDI_MAX_CHUNKSIZE * 2 * 2 * 4);
 
 			/* Start DMA */
 			wctdm_start_dma(wc);
@@ -2386,7 +2386,7 @@ static int __devinit wctdm_init_one(struct pci_dev *pdev, const struct pci_devic
 
 static void wctdm_release(struct wctdm *wc)
 {
-	zt_unregister(&wc->span);
+	dahdi_unregister(&wc->span);
 	if (wc->freeregion)
 		release_region(wc->ioaddr, 0xff);
 	kfree(wc);
@@ -2406,7 +2406,7 @@ static void __devexit wctdm_remove_one(struct pci_dev *pdev)
 		wctdm_disable_interrupts(wc);
 		
 		/* Immediately free resources */
-		pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
+		pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
 		free_irq(pdev->irq, wc);
 
 		/* Reset PCI chip and registers */
diff --git a/drivers/dahdi/wctdm.h b/drivers/dahdi/wctdm.h
index 73703aa..144e838 100644
--- a/drivers/dahdi/wctdm.h
+++ b/drivers/dahdi/wctdm.h
@@ -60,10 +60,10 @@ struct wctdm_echo_coefs {
 	unsigned char coef8;
 };
 
-#define WCTDM_GET_STATS	_IOR (ZT_CODE, 60, struct wctdm_stats)
-#define WCTDM_GET_REGS	_IOR (ZT_CODE, 61, struct wctdm_regs)
-#define WCTDM_SET_REG	_IOW (ZT_CODE, 62, struct wctdm_regop)
-#define WCTDM_SET_ECHOTUNE _IOW (ZT_CODE, 63, struct wctdm_echo_coefs)
+#define WCTDM_GET_STATS	_IOR (DAHDI_CODE, 60, struct wctdm_stats)
+#define WCTDM_GET_REGS	_IOR (DAHDI_CODE, 61, struct wctdm_regs)
+#define WCTDM_SET_REG	_IOW (DAHDI_CODE, 62, struct wctdm_regop)
+#define WCTDM_SET_ECHOTUNE _IOW (DAHDI_CODE, 63, struct wctdm_echo_coefs)
 
 
 #endif /* _WCTDM_H */
diff --git a/drivers/dahdi/wctdm24xxp/base.c b/drivers/dahdi/wctdm24xxp/base.c
index 4ca1353..b9c63fa 100644
--- a/drivers/dahdi/wctdm24xxp/base.c
+++ b/drivers/dahdi/wctdm24xxp/base.c
@@ -666,10 +666,10 @@ static inline void wctdm_transmitprep(struct wctdm *wc, unsigned char *writechun
 
 	/* Calculate Transmission */
 	if (likely(wc->initialized)) {
-		zt_transmit(&wc->span);
+		dahdi_transmit(&wc->span);
 	}
 
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
 		/* Send a sample, as a 32-bit word */
 		for (y=0;y < wc->cards;y++) {
 			if (!x) {
@@ -702,7 +702,7 @@ static inline void wctdm_transmitprep(struct wctdm *wc, unsigned char *writechun
 			cmd_dequeue_vpm150m(wc, writechunk, x);
 		}
 #endif		
-		if (x < ZT_CHUNKSIZE - 1) {
+		if (x < DAHDI_CHUNKSIZE - 1) {
 			writechunk[EFRAME_SIZE] = wc->ctlreg;
 			writechunk[EFRAME_SIZE + 1] = wc->txident++;
 #if 1
@@ -850,8 +850,8 @@ static inline void wctdm_receiveprep(struct wctdm *wc, unsigned char *readchunk)
 
 	BUG_ON(NULL == readchunk);
 
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
-		if (x < ZT_CHUNKSIZE - 1) {
+	for (x=0;x<DAHDI_CHUNKSIZE;x++) {
+		if (x < DAHDI_CHUNKSIZE - 1) {
 			expected = wc->rxident+1;
 			wc->rxident = readchunk[EFRAME_SIZE + 1];
 			if (wc->rxident != expected) {
@@ -881,9 +881,9 @@ static inline void wctdm_receiveprep(struct wctdm *wc, unsigned char *readchunk)
 	if (likely(wc->initialized)) {
 		for (x=0;x<wc->type;x++) {
 			if (wc->cardflag & (1 << x))
-				zt_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, wc->chans[x].writechunk);
+				dahdi_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, wc->chans[x].writechunk);
 		}
-		zt_receive(&wc->span);
+		dahdi_receive(&wc->span);
 	}
 	/* Wake up anyone sleeping to read/write a new register */
 	wake_up_interruptible(&wc->regq);
@@ -1104,8 +1104,8 @@ static inline void wctdm_qrvdri_check_hook(struct wctdm *wc, int card)
 	{
 		b1 = wc->qrvhook[qrvcard + 2];
 if (debug) printk("QRV channel %d rx state changed to %d\n",qrvcard,wc->qrvhook[qrvcard + 2]);
-		zt_hooksig(&wc->chans[qrvcard], 
-			(b1) ? ZT_RXSIG_OFFHOOK : ZT_RXSIG_ONHOOK);
+		dahdi_hooksig(&wc->chans[qrvcard], 
+			(b1) ? DAHDI_RXSIG_OFFHOOK : DAHDI_RXSIG_ONHOOK);
 		wc->qrvdebtime[card] = 0;
 	}
 	/* check for change in chan 1 */
@@ -1118,8 +1118,8 @@ if (debug) printk("QRV channel %d rx state changed to %d\n",qrvcard,wc->qrvhook[
 	{
 		b1 = wc->qrvhook[qrvcard + 3];
 if (debug) printk("QRV channel %d rx state changed to %d\n",qrvcard + 1,wc->qrvhook[qrvcard + 3]);
-		zt_hooksig(&wc->chans[qrvcard + 1], 
-			(b1) ? ZT_RXSIG_OFFHOOK : ZT_RXSIG_ONHOOK);
+		dahdi_hooksig(&wc->chans[qrvcard + 1], 
+			(b1) ? DAHDI_RXSIG_OFFHOOK : DAHDI_RXSIG_ONHOOK);
 		wc->qrvdebtime[card] = 0;
 	}
 	return;
@@ -1152,7 +1152,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 						fxo->wasringing = 1;
 						if (debug)
 							printk("RING on %d/%d!\n", wc->span.spanno, card + 1);
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_RING);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_RING);
 					}
 					fxo->lastrdtx = res;
 					fxo->ringdebounce = 10;
@@ -1161,7 +1161,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 						fxo->wasringing = 0;
 						if (debug)
 							printk("NO RING on %d/%d!\n", wc->span.spanno, card + 1);
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 					}
 				}
 			} else if (res && (fxo->battery == BATTERY_PRESENT)) {
@@ -1171,22 +1171,22 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 		} else {
 			res =  wc->cmdq[card].isrshadow[0];
 			if ((res & 0x60) && (fxo->battery == BATTERY_PRESENT)) {
-				fxo->ringdebounce += (ZT_CHUNKSIZE * 16);
-				if (fxo->ringdebounce >= ZT_CHUNKSIZE * ringdebounce) {
+				fxo->ringdebounce += (DAHDI_CHUNKSIZE * 16);
+				if (fxo->ringdebounce >= DAHDI_CHUNKSIZE * ringdebounce) {
 					if (!fxo->wasringing) {
 						fxo->wasringing = 1;
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_RING);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_RING);
 						if (debug)
 							printk("RING on %d/%d!\n", wc->span.spanno, card + 1);
 					}
-					fxo->ringdebounce = ZT_CHUNKSIZE * ringdebounce;
+					fxo->ringdebounce = DAHDI_CHUNKSIZE * ringdebounce;
 				}
 			} else {
-				fxo->ringdebounce -= ZT_CHUNKSIZE * 4;
+				fxo->ringdebounce -= DAHDI_CHUNKSIZE * 4;
 				if (fxo->ringdebounce <= 0) {
 					if (fxo->wasringing) {
 						fxo->wasringing = 0;
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 						if (debug)
 							printk("NO RING on %d/%d!\n", wc->span.spanno, card + 1);
 					}
@@ -1229,7 +1229,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 						printk("NO BATTERY on %d/%d!\n", wc->span.spanno, card + 1);
 #ifdef	JAPAN
 					if (!wc->ohdebounce && wc->offhook) {
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_ONHOOK);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_ONHOOK);
 						if (debug)
 							printk("Signalled On Hook\n");
 #ifdef	ZERO_BATT_RING
@@ -1237,7 +1237,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 #endif
 					}
 #else
-					zt_hooksig(&wc->chans[card], ZT_RXSIG_ONHOOK);
+					dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_ONHOOK);
 					/* set the alarm timer, taking into account that part of its time
 					   period has already passed while debouncing occurred */
 					fxo->battalarm = (battalarm - battdebounce) / MS_PER_CHECK_HOOK;
@@ -1273,12 +1273,12 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 #ifdef	ZERO_BATT_RING
 					if (wc->onhook) {
 						wc->onhook = 0;
-						zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+						dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 						if (debug)
 							printk("Signalled Off Hook\n");
 					}
 #else
-					zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+					dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 #endif
 					/* set the alarm timer, taking into account that part of its time
 					   period has already passed while debouncing occurred */
@@ -1308,7 +1308,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 		if (--fxo->battalarm == 0) {
 			/* the alarm timer has expired, so update the battery alarm state
 			   for this channel */
-			zt_alarm_channel(&wc->chans[card], fxo->battery ? ZT_ALARM_NONE : ZT_ALARM_RED);
+			dahdi_alarm_channel(&wc->chans[card], fxo->battery ? DAHDI_ALARM_NONE : DAHDI_ALARM_RED);
 		}
 	}
 
@@ -1321,7 +1321,7 @@ static inline void wctdm_voicedaa_check_hook(struct wctdm *wc, int card)
 				       fxo->polarity, 
 				       fxo->lastpol);
 			if (fxo->polarity)
-				zt_qevent_lock(&wc->chans[card], ZT_EVENT_POLARITY);
+				dahdi_qevent_lock(&wc->chans[card], DAHDI_EVENT_POLARITY);
 			fxo->polarity = fxo->lastpol;
 		    }
 		}
@@ -1348,7 +1348,7 @@ static inline void wctdm_proslic_check_hook(struct wctdm *wc, int card)
 #endif
 	} else {
 		if (wc->mods[card].fxs.debounce > 0) {
-			wc->mods[card].fxs.debounce-= 4 * ZT_CHUNKSIZE;
+			wc->mods[card].fxs.debounce-= 4 * DAHDI_CHUNKSIZE;
 #if 0
 			printk("Sustaining hook %d, %d\n", hook, wc->mods[card].fxs.debounce);
 #endif
@@ -1362,7 +1362,7 @@ static inline void wctdm_proslic_check_hook(struct wctdm *wc, int card)
 				/* Off hook */
 				if (debug & DEBUG_CARD)
 					printk("wctdm: Card %d Going off hook\n", card);
-				zt_hooksig(&wc->chans[card], ZT_RXSIG_OFFHOOK);
+				dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_OFFHOOK);
 				if (robust)
 					wctdm_init_proslic(wc, card, 1, 0, 1);
 				wc->mods[card].fxs.oldrxhook = 1;
@@ -1371,7 +1371,7 @@ static inline void wctdm_proslic_check_hook(struct wctdm *wc, int card)
 				/* On hook */
 				if (debug & DEBUG_CARD)
 					printk("wctdm: Card %d Going on hook\n", card);
-				zt_hooksig(&wc->chans[card], ZT_RXSIG_ONHOOK);
+				dahdi_hooksig(&wc->chans[card], DAHDI_RXSIG_ONHOOK);
 				wc->mods[card].fxs.oldrxhook = 0;
 			}
 		}
@@ -1402,7 +1402,7 @@ static inline void wctdm_vpm_check(struct wctdm *wc, int x)
 
 #include "adt_lec.c"
 
-static int wctdm_echocan_with_params(struct zt_chan *chan, struct zt_echocanparams *ecp, struct zt_echocanparam *p)
+static int wctdm_echocan_with_params(struct dahdi_chan *chan, struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p)
 {
 	struct wctdm *wc = chan->pvt;
 
@@ -1471,7 +1471,7 @@ static inline void wctdm_isr_misc(struct wctdm *wc)
 					wc->mods[x].fxs.idletxhookstate = 0x2;	/* OHT mode when idle */
 				} else {
 					if (wc->mods[x].fxs.ohttimer) {
-						wc->mods[x].fxs.ohttimer-= ZT_CHUNKSIZE;
+						wc->mods[x].fxs.ohttimer-= DAHDI_CHUNKSIZE;
 						if (!wc->mods[x].fxs.ohttimer) {
 							wc->mods[x].fxs.idletxhookstate = 0x1;	/* Switch to active */
 							if (wc->mods[x].fxs.lasttxhook == 0x2) {
@@ -2256,7 +2256,7 @@ static int wctdm_init_qrvdri(struct wctdm *wc, int card)
 	return 0;
 }
 
-static void qrv_dosetup(struct zt_chan *chan,struct wctdm *wc)
+static void qrv_dosetup(struct dahdi_chan *chan,struct wctdm *wc)
 {
 int qrvcard;
 unsigned char r;
@@ -2315,22 +2315,22 @@ long l;
 	return;
 }
 
-static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
+static int wctdm_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data)
 {
 	struct wctdm_stats stats;
 	struct wctdm_regs regs;
 	struct wctdm_regop regop;
 	struct wctdm_echo_coefs echoregs;
-	struct zt_hwgain hwgain;
+	struct dahdi_hwgain hwgain;
 	struct wctdm *wc = chan->pvt;
 	int x;
 	union {
-		struct zt_radio_stat s;
-		struct zt_radio_param p;
+		struct dahdi_radio_stat s;
+		struct dahdi_radio_param p;
 	} stack;
 
 	switch (cmd) {
-	case ZT_ONHOOKTRANSFER:
+	case DAHDI_ONHOOKTRANSFER:
 		if (wc->modtype[chan->chanpos - 1] != MOD_TYPE_FXS)
 			return -EINVAL;
 		if (get_user(x, (int *)data))
@@ -2420,8 +2420,8 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 
 		}
 		break;
-	case ZT_SET_HWGAIN:
-		if (copy_from_user(&hwgain, (struct zt_hwgain*) data, sizeof(hwgain)))
+	case DAHDI_SET_HWGAIN:
+		if (copy_from_user(&hwgain, (struct dahdi_hwgain*) data, sizeof(hwgain)))
 			return -EFAULT;
 
 		wctdm_set_hwgain(wc, chan->chanpos-1, hwgain.newgain, hwgain.tx);
@@ -2431,19 +2431,19 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 				chan->chanpos-1, hwgain.newgain, hwgain.tx ? "tx" : "rx");
 		break;
 #ifdef VPM_SUPPORT
-	case ZT_TONEDETECT:
+	case DAHDI_TONEDETECT:
 		if (get_user(x, (int *) data))
 			return -EFAULT;
 		if (!wc->vpm && !wc->vpm150m)
 			return -ENOSYS;
 		if ((wc->vpm || wc->vpm150m) && (x && !vpmdtmfsupport))
 			return -ENOSYS;
-		if (x & ZT_TONEDETECT_ON) {
+		if (x & DAHDI_TONEDETECT_ON) {
 			set_bit(chan->chanpos - 1, &wc->dtmfmask);
 		} else {
 			clear_bit(chan->chanpos - 1, &wc->dtmfmask);
 		}
-		if (x & ZT_TONEDETECT_MUTE) {
+		if (x & DAHDI_TONEDETECT_MUTE) {
 			if (wc->vpm150m) {
 				set_bit(chan->chanpos - 1, &wc->vpm150m->desireddtmfmutestate);
 			}
@@ -2454,25 +2454,25 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 		}
 		return 0;
 #endif
-	case ZT_RADIO_GETPARAM:
+	case DAHDI_RADIO_GETPARAM:
 		if (wc->modtype[chan->chanpos - 1] != MOD_TYPE_QRV) 
 			return -ENOTTY;
-		if (copy_from_user(&stack.p,(struct zt_radio_param *)data,sizeof(struct zt_radio_param))) return -EFAULT;
+		if (copy_from_user(&stack.p,(struct dahdi_radio_param *)data,sizeof(struct dahdi_radio_param))) return -EFAULT;
 		stack.p.data = 0; /* start with 0 value in output */
 		switch(stack.p.radpar) {
-		case ZT_RADPAR_INVERTCOR:
+		case DAHDI_RADPAR_INVERTCOR:
 			if (wc->radmode[chan->chanpos - 1] & RADMODE_INVERTCOR)
 				stack.p.data = 1;
 			break;
-		case ZT_RADPAR_IGNORECOR:
+		case DAHDI_RADPAR_IGNORECOR:
 			if (wc->radmode[chan->chanpos - 1] & RADMODE_IGNORECOR)
 				stack.p.data = 1;
 			break;
-		case ZT_RADPAR_IGNORECT:
+		case DAHDI_RADPAR_IGNORECT:
 			if (wc->radmode[chan->chanpos - 1] & RADMODE_IGNORECT)
 				stack.p.data = 1;
 			break;
-		case ZT_RADPAR_EXTRXTONE:
+		case DAHDI_RADPAR_EXTRXTONE:
 			stack.p.data = 0;
 			if (wc->radmode[chan->chanpos - 1] & RADMODE_EXTTONE)
 			{
@@ -2483,23 +2483,23 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 				}
 			}
 			break;
-		case ZT_RADPAR_DEBOUNCETIME:
+		case DAHDI_RADPAR_DEBOUNCETIME:
 			stack.p.data = wc->debouncetime[chan->chanpos - 1];
 			break;
-		case ZT_RADPAR_RXGAIN:
+		case DAHDI_RADPAR_RXGAIN:
 			stack.p.data = wc->rxgain[chan->chanpos - 1] - 1199;
 			break;
-		case ZT_RADPAR_TXGAIN:
+		case DAHDI_RADPAR_TXGAIN:
 			stack.p.data = wc->txgain[chan->chanpos - 1] - 3599;
 			break;
-		case ZT_RADPAR_DEEMP:
+		case DAHDI_RADPAR_DEEMP:
 			stack.p.data = 0;
 			if (wc->radmode[chan->chanpos - 1] & RADMODE_DEEMP)
 			{
 				stack.p.data = 1;
 			}
 			break;
-		case ZT_RADPAR_PREEMP:
+		case DAHDI_RADPAR_PREEMP:
 			stack.p.data = 0;
 			if (wc->radmode[chan->chanpos - 1] & RADMODE_PREEMP)
 			{
@@ -2509,32 +2509,32 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 		default:
 			return -EINVAL;
 		}
-		if (copy_to_user((struct zt_radio_param *)data,&stack.p,sizeof(struct zt_radio_param))) return -EFAULT;
+		if (copy_to_user((struct dahdi_radio_param *)data,&stack.p,sizeof(struct dahdi_radio_param))) return -EFAULT;
 		break;
-	case ZT_RADIO_SETPARAM:
+	case DAHDI_RADIO_SETPARAM:
 		if (wc->modtype[chan->chanpos - 1] != MOD_TYPE_QRV) 
 			return -ENOTTY;
-		if (copy_from_user(&stack.p,(struct zt_radio_param *)data,sizeof(struct zt_radio_param))) return -EFAULT;
+		if (copy_from_user(&stack.p,(struct dahdi_radio_param *)data,sizeof(struct dahdi_radio_param))) return -EFAULT;
 		switch(stack.p.radpar) {
-		case ZT_RADPAR_INVERTCOR:
+		case DAHDI_RADPAR_INVERTCOR:
 			if (stack.p.data)
 				wc->radmode[chan->chanpos - 1] |= RADMODE_INVERTCOR;
 			else
 				wc->radmode[chan->chanpos - 1] &= ~RADMODE_INVERTCOR;
 			return 0;
-		case ZT_RADPAR_IGNORECOR:
+		case DAHDI_RADPAR_IGNORECOR:
 			if (stack.p.data)
 				wc->radmode[chan->chanpos - 1] |= RADMODE_IGNORECOR;
 			else
 				wc->radmode[chan->chanpos - 1] &= ~RADMODE_IGNORECOR;
 			return 0;
-		case ZT_RADPAR_IGNORECT:
+		case DAHDI_RADPAR_IGNORECT:
 			if (stack.p.data)
 				wc->radmode[chan->chanpos - 1] |= RADMODE_IGNORECT;
 			else
 				wc->radmode[chan->chanpos - 1] &= ~RADMODE_IGNORECT;
 			return 0;
-		case ZT_RADPAR_EXTRXTONE:
+		case DAHDI_RADPAR_EXTRXTONE:
 			if (stack.p.data)
 				wc->radmode[chan->chanpos - 1] |= RADMODE_EXTTONE;
 			else
@@ -2544,10 +2544,10 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 			else
 				wc->radmode[chan->chanpos - 1] &= ~RADMODE_EXTINVERT;
 			return 0;
-		case ZT_RADPAR_DEBOUNCETIME:
+		case DAHDI_RADPAR_DEBOUNCETIME:
 			wc->debouncetime[chan->chanpos - 1] = stack.p.data;
 			return 0;
-		case ZT_RADPAR_RXGAIN:
+		case DAHDI_RADPAR_RXGAIN:
 			/* if out of range */
 			if ((stack.p.data <= -1200) || (stack.p.data > 1552))
 			{
@@ -2555,7 +2555,7 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 			}
 			wc->rxgain[chan->chanpos - 1] = stack.p.data + 1199;
 			break;
-		case ZT_RADPAR_TXGAIN:
+		case DAHDI_RADPAR_TXGAIN:
 			/* if out of range */
 			if (wc->radmode[chan->chanpos -1] & RADMODE_PREEMP)
 			{
@@ -2573,14 +2573,14 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 			}
 			wc->txgain[chan->chanpos - 1] = stack.p.data + 3599;
 			break;
-		case ZT_RADPAR_DEEMP:
+		case DAHDI_RADPAR_DEEMP:
 			if (stack.p.data)
 				wc->radmode[chan->chanpos - 1] |= RADMODE_DEEMP;
 			else
 				wc->radmode[chan->chanpos - 1] &= ~RADMODE_DEEMP;
 			wc->rxgain[chan->chanpos - 1] = 1199;
 			break;
-		case ZT_RADPAR_PREEMP:
+		case DAHDI_RADPAR_PREEMP:
 			if (stack.p.data)
 				wc->radmode[chan->chanpos - 1] |= RADMODE_PREEMP;
 			else
@@ -2598,7 +2598,7 @@ static int wctdm_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 	return 0;
 }
 
-static int wctdm_open(struct zt_chan *chan)
+static int wctdm_open(struct dahdi_chan *chan)
 {
 	struct wctdm *wc = chan->pvt;
 	if (!(wc->cardflag & (1 << (chan->chanpos - 1))))
@@ -2614,13 +2614,13 @@ static int wctdm_open(struct zt_chan *chan)
 	return 0;
 }
 
-static int wctdm_watchdog(struct zt_span *span, int event)
+static int wctdm_watchdog(struct dahdi_span *span, int event)
 {
 	printk("TDM: Called watchdog\n");
 	return 0;
 }
 
-static int wctdm_close(struct zt_chan *chan)
+static int wctdm_close(struct dahdi_chan *chan)
 {
 	struct wctdm *wc = chan->pvt;
 	int x;
@@ -2658,18 +2658,18 @@ static int wctdm_close(struct zt_chan *chan)
 	return 0;
 }
 
-static int wctdm_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
+static int wctdm_hooksig(struct dahdi_chan *chan, dahdi_txsig_t txsig)
 {
 	struct wctdm *wc = chan->pvt;
 	int reg=0,qrvcard;
 	if (wc->modtype[chan->chanpos - 1] == MOD_TYPE_QRV) {
 		qrvcard = (chan->chanpos - 1) & 0xfc;
 		switch(txsig) {
-		case ZT_TXSIG_START:
-		case ZT_TXSIG_OFFHOOK:
+		case DAHDI_TXSIG_START:
+		case DAHDI_TXSIG_OFFHOOK:
 			wc->qrvhook[chan->chanpos - 1] = 1;
 			break;
-		case ZT_TXSIG_ONHOOK:
+		case DAHDI_TXSIG_ONHOOK:
 			wc->qrvhook[chan->chanpos - 1] = 0;
 			break;
 		default:
@@ -2682,13 +2682,13 @@ static int wctdm_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
 		/* wctdm_setreg(wc, qrvcard, 3, reg); */
 	} else if (wc->modtype[chan->chanpos - 1] == MOD_TYPE_FXO) {
 		switch(txsig) {
-		case ZT_TXSIG_START:
-		case ZT_TXSIG_OFFHOOK:
+		case DAHDI_TXSIG_START:
+		case DAHDI_TXSIG_OFFHOOK:
 			wc->mods[chan->chanpos - 1].fxo.offhook = 1;
 			wc->sethook[chan->chanpos - 1] = CMD_WR(5, 0x9);
 			/* wctdm_setreg(wc, chan->chanpos - 1, 5, 0x9); */
 			break;
-		case ZT_TXSIG_ONHOOK:
+		case DAHDI_TXSIG_ONHOOK:
 			wc->mods[chan->chanpos - 1].fxo.offhook = 0;
 			wc->sethook[chan->chanpos - 1] = CMD_WR(5, 0x8);
 			/* wctdm_setreg(wc, chan->chanpos - 1, 5, 0x8); */
@@ -2698,22 +2698,22 @@ static int wctdm_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
 		}
 	} else {
 		switch(txsig) {
-		case ZT_TXSIG_ONHOOK:
+		case DAHDI_TXSIG_ONHOOK:
 			switch(chan->sig) {
-			case ZT_SIG_EM:
-			case ZT_SIG_FXOKS:
-			case ZT_SIG_FXOLS:
+			case DAHDI_SIG_EM:
+			case DAHDI_SIG_FXOKS:
+			case DAHDI_SIG_FXOLS:
 				wc->mods[chan->chanpos - 1].fxs.lasttxhook = 0x10 |
 					wc->mods[chan->chanpos - 1].fxs.idletxhookstate;
 				break;
-			case ZT_SIG_FXOGS:
+			case DAHDI_SIG_FXOGS:
 				wc->mods[chan->chanpos - 1].fxs.lasttxhook = 0x13;
 				break;
 			}
 			break;
-		case ZT_TXSIG_OFFHOOK:
+		case DAHDI_TXSIG_OFFHOOK:
 			switch(chan->sig) {
-			case ZT_SIG_EM:
+			case DAHDI_SIG_EM:
 				wc->mods[chan->chanpos - 1].fxs.lasttxhook = 0x15;
 				break;
 			default:
@@ -2722,10 +2722,10 @@ static int wctdm_hooksig(struct zt_chan *chan, zt_txsig_t txsig)
 				break;
 			}
 			break;
-		case ZT_TXSIG_START:
+		case DAHDI_TXSIG_START:
 			wc->mods[chan->chanpos - 1].fxs.lasttxhook = 0x14;
 			break;
-		case ZT_TXSIG_KEWL:
+		case DAHDI_TXSIG_KEWL:
 			wc->mods[chan->chanpos - 1].fxs.lasttxhook = 0x10;
 			break;
 		default:
@@ -2816,7 +2816,7 @@ static void wctdm_dacs_disconnect(struct wctdm *wc, int card)
 	}
 }
 
-static int wctdm_dacs(struct zt_chan *dst, struct zt_chan *src)
+static int wctdm_dacs(struct dahdi_chan *dst, struct dahdi_chan *src)
 {
 	struct wctdm *wc;
 
@@ -2852,13 +2852,13 @@ static int wctdm_initialize(struct wctdm *wc)
 	strncpy(wc->span.devicetype, wc->variety, sizeof(wc->span.devicetype) - 1);
 	if (alawoverride) {
 		printk("ALAW override parameter detected.  Device will be operating in ALAW\n");
-		wc->span.deflaw = ZT_LAW_ALAW;
+		wc->span.deflaw = DAHDI_LAW_ALAW;
 	} else
-		wc->span.deflaw = ZT_LAW_MULAW;
+		wc->span.deflaw = DAHDI_LAW_MULAW;
 	for (x=0;x<wc->cards;x++) {
 		sprintf(wc->chans[x].name, "WCTDM/%d/%d", wc->pos, x);
-		wc->chans[x].sigcap = ZT_SIG_FXOKS | ZT_SIG_FXOLS | ZT_SIG_FXOGS | ZT_SIG_SF | ZT_SIG_EM | ZT_SIG_CLEAR;
-		wc->chans[x].sigcap |= ZT_SIG_FXSKS | ZT_SIG_FXSLS | ZT_SIG_SF | ZT_SIG_CLEAR;
+		wc->chans[x].sigcap = DAHDI_SIG_FXOKS | DAHDI_SIG_FXOLS | DAHDI_SIG_FXOGS | DAHDI_SIG_SF | DAHDI_SIG_EM | DAHDI_SIG_CLEAR;
+		wc->chans[x].sigcap |= DAHDI_SIG_FXSKS | DAHDI_SIG_FXSLS | DAHDI_SIG_SF | DAHDI_SIG_CLEAR;
 		wc->chans[x].chanpos = x+1;
 		wc->chans[x].pvt = wc;
 	}
@@ -2868,7 +2868,7 @@ static int wctdm_initialize(struct wctdm *wc)
 	wc->span.hooksig = wctdm_hooksig;
 	wc->span.open = wctdm_open;
 	wc->span.close = wctdm_close;
-	wc->span.flags = ZT_FLAG_RBS;
+	wc->span.flags = DAHDI_FLAG_RBS;
 	wc->span.ioctl = wctdm_ioctl;
 	wc->span.watchdog = wctdm_watchdog;
 	wc->span.dacs= wctdm_dacs;
@@ -2889,12 +2889,12 @@ static void wctdm_post_initialize(struct wctdm *wc)
 	for (x = 0; x <wc->cards; x++) {
 		if (wc->cardflag & (1 << x)) {
 			if (wc->modtype[x] == MOD_TYPE_FXO)
-				wc->chans[x].sigcap = ZT_SIG_FXSKS | ZT_SIG_FXSLS | ZT_SIG_SF | ZT_SIG_CLEAR;
+				wc->chans[x].sigcap = DAHDI_SIG_FXSKS | DAHDI_SIG_FXSLS | DAHDI_SIG_SF | DAHDI_SIG_CLEAR;
 			else if (wc->modtype[x] == MOD_TYPE_FXS)
-				wc->chans[x].sigcap = ZT_SIG_FXOKS | ZT_SIG_FXOLS | ZT_SIG_FXOGS | ZT_SIG_SF | ZT_SIG_EM | ZT_SIG_CLEAR;
+				wc->chans[x].sigcap = DAHDI_SIG_FXOKS | DAHDI_SIG_FXOLS | DAHDI_SIG_FXOGS | DAHDI_SIG_SF | DAHDI_SIG_EM | DAHDI_SIG_CLEAR;
 			else if (wc->modtype[x] == MOD_TYPE_QRV)
-				wc->chans[x].sigcap = ZT_SIG_SF | ZT_SIG_EM | ZT_SIG_CLEAR;
-		} else if (!(wc->chans[x].sigcap & ZT_SIG_BROKEN)) {
+				wc->chans[x].sigcap = DAHDI_SIG_SF | DAHDI_SIG_EM | DAHDI_SIG_CLEAR;
+		} else if (!(wc->chans[x].sigcap & DAHDI_SIG_BROKEN)) {
 			wc->chans[x].sigcap = 0;
 		}
 	}
@@ -3044,7 +3044,7 @@ static void vpm150m_bh(struct work_struct *data)
 					printk("Channel %d: Detected DTMF tone %d of duration %d!!!\n", channel + 1, tone, duration);
 
 				if (test_bit(channel, &wc->dtmfmask) && (eventdata.toneEvent.ToneDuration > 0)) {
-					struct zt_chan *chan = &wc->chans[channel];
+					struct dahdi_chan *chan = &wc->chans[channel];
 
 					if ((tone != EndofMFDigit) && (zaptone != 0)) {
 						vpm150m->curtone[channel] = tone;
@@ -3057,7 +3057,7 @@ static void vpm150m_bh(struct work_struct *data)
 							spin_lock_irqsave(&chan->lock, flags);
 							for (y = 0; y < chan->numbufs; y++) {
 								if ((chan->inreadbuf > -1) && (chan->readidx[y]))
-									memset(chan->readbuf[chan->inreadbuf], ZT_XLAW(0, chan), chan->readidx[y]);
+									memset(chan->readbuf[chan->inreadbuf], DAHDI_XLAW(0, chan), chan->readidx[y]);
 							}
 							spin_unlock_irqrestore(&chan->lock, flags);
 						}
@@ -3065,12 +3065,12 @@ static void vpm150m_bh(struct work_struct *data)
 							if (debug & DEBUG_ECHOCAN)
 								printk("Queuing DTMFDOWN %c\n", zaptone);
 							set_bit(channel, &wc->dtmfactive);
-							zt_qevent_lock(chan, (ZT_EVENT_DTMFDOWN | zaptone));
+							dahdi_qevent_lock(chan, (DAHDI_EVENT_DTMFDOWN | zaptone));
 						}
 					} else if ((tone == EndofMFDigit) && test_bit(channel, &wc->dtmfactive)) {
 						if (debug & DEBUG_ECHOCAN)
 							printk("Queuing DTMFUP %c\n", vpm150mtone_to_zaptone(vpm150m->curtone[channel]));
-						zt_qevent_lock(chan, (ZT_EVENT_DTMFUP | vpm150mtone_to_zaptone(vpm150m->curtone[channel])));
+						dahdi_qevent_lock(chan, (DAHDI_EVENT_DTMFUP | vpm150mtone_to_zaptone(vpm150m->curtone[channel])));
 						clear_bit(channel, &wc->dtmfactive);
 					}
 				}
@@ -3682,7 +3682,7 @@ retry:
 					printk("Port %d: Installed -- MANUAL FXS\n",x + 1);
 				} else {
 					printk("Port %d: FAILED FXS (%s)\n", x + 1, fxshonormode ? fxo_modes[_opermode].name : "FCC");
-					wc->chans[x].sigcap = ZT_SIG_BROKEN | __ZT_SIG_FXO;
+					wc->chans[x].sigcap = DAHDI_SIG_BROKEN | __DAHDI_SIG_FXO;
 				} 
 			} else if (!(ret = wctdm_init_voicedaa(wc, x, 0, 0, sane))) {
 				wc->cardflag |= (1 << x);
@@ -3844,7 +3844,7 @@ retry:
 	wctdm_post_initialize(wc);
 	
 	/* We should be ready for zaptel to come in now. */
-	if (zt_register(&wc->span, 0)) {
+	if (dahdi_register(&wc->span, 0)) {
 		printk("Unable to register span with zaptel\n");
 		return -1;
 	}
@@ -3862,7 +3862,7 @@ static void wctdm_release(struct wctdm *wc)
 	int i;
 
 	if (wc->initialized) {
-		zt_unregister(&wc->span);
+		dahdi_unregister(&wc->span);
 	}
 
 	voicebus_release(wc->vb);
diff --git a/drivers/dahdi/wctdm24xxp/wctdm24xxp.h b/drivers/dahdi/wctdm24xxp/wctdm24xxp.h
index 87c8dee..dca7ae5 100644
--- a/drivers/dahdi/wctdm24xxp/wctdm24xxp.h
+++ b/drivers/dahdi/wctdm24xxp/wctdm24xxp.h
@@ -52,7 +52,7 @@
 #define EFRAME_SIZE	108
 #define ERING_SIZE 16		/* Maximum ring size */
 #define EFRAME_GAP 20
-#define SFRAME_SIZE ((EFRAME_SIZE * ZT_CHUNKSIZE) + (EFRAME_GAP * (ZT_CHUNKSIZE - 1)))
+#define SFRAME_SIZE ((EFRAME_SIZE * DAHDI_CHUNKSIZE) + (EFRAME_GAP * (DAHDI_CHUNKSIZE - 1)))
 
 #define MAX_ALARMS 10
 
@@ -184,7 +184,7 @@ enum battery_state {
 struct wctdm {
 	char *variety;
 	char board_name[80];
-	struct zt_span span;
+	struct dahdi_span span;
 	unsigned char ios;
 	unsigned int sdi;
 	int usecount;
@@ -266,7 +266,7 @@ struct wctdm {
 #endif	
 #endif
 	struct voicebus *vb;
-	struct zt_chan chans[NUM_CARDS];
+	struct dahdi_chan chans[NUM_CARDS];
 	int initialized;
 };
 
diff --git a/drivers/dahdi/wcte11xp.c b/drivers/dahdi/wcte11xp.c
index db787dc..430d80a 100644
--- a/drivers/dahdi/wcte11xp.c
+++ b/drivers/dahdi/wcte11xp.c
@@ -177,11 +177,11 @@ struct t1 {
 	dma_addr_t	writedma;
 	volatile unsigned char *writechunk;					/* Double-word aligned write memory */
 	volatile unsigned char *readchunk;					/* Double-word aligned read memory */
-	unsigned char ec_chunk1[32][ZT_CHUNKSIZE];
-	unsigned char ec_chunk2[32][ZT_CHUNKSIZE];
+	unsigned char ec_chunk1[32][DAHDI_CHUNKSIZE];
+	unsigned char ec_chunk2[32][DAHDI_CHUNKSIZE];
 	unsigned char tempo[33];
-	struct zt_span span;						/* Span */
-	struct zt_chan chans[32];					/* Channels */
+	struct dahdi_span span;						/* Span */
+	struct dahdi_chan chans[32];					/* Channels */
 };
 
 #define CANARY 0xca1e
@@ -229,7 +229,7 @@ static inline void __select_control(struct t1 *wc)
 	}
 }
 
-static int t1xxp_open(struct zt_chan *chan)
+static int t1xxp_open(struct dahdi_chan *chan)
 {
 	struct t1 *wc = chan->pvt;
 	if (wc->dead)
@@ -348,12 +348,12 @@ static inline void t1_framer_out(struct t1 *wc, const unsigned int addr, const u
 
 static void t1xxp_release(struct t1 *wc)
 {
-	zt_unregister(&wc->span);
+	dahdi_unregister(&wc->span);
 	kfree(wc);
 	printk("Freed a Wildcard\n");
 }
 
-static int t1xxp_close(struct zt_chan *chan)
+static int t1xxp_close(struct dahdi_chan *chan)
 {
 	struct t1 *wc = chan->pvt;
 	wc->usecount--;
@@ -409,7 +409,7 @@ static void __t1xxp_set_clear(struct t1 *wc)
 	unsigned short val=0;
 	for (i=0;i<24;i++) {
 		j = (i/8);
-		if (wc->span.chans[i].flags & ZT_FLAG_CLEAR) 
+		if (wc->span.chans[i].flags & DAHDI_FLAG_CLEAR) 
 			val |= 1 << (7 - (i % 8));
 		if ((i % 8)==7) {
 			if (debug > 1)
@@ -421,7 +421,7 @@ static void __t1xxp_set_clear(struct t1 *wc)
 	}
 }
 
-static int t1xxp_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
+static int t1xxp_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data)
 {
 	struct t4_regs regs;
 	int x;
@@ -450,28 +450,28 @@ static int t1xxp_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 	return 0;
 }
 
-static int t1xxp_maint(struct zt_span *span, int cmd)
+static int t1xxp_maint(struct dahdi_span *span, int cmd)
 {
 	struct t1 *wc = span->pvt;
 
 	if (wc->spantype == TYPE_E1) {
 		switch(cmd) {
-		case ZT_MAINT_NONE:
+		case DAHDI_MAINT_NONE:
 			printk("XXX Turn off local and remote loops E1 XXX\n");
 			break;
-		case ZT_MAINT_LOCALLOOP:
+		case DAHDI_MAINT_LOCALLOOP:
 			printk("XXX Turn on local loopback E1 XXX\n");
 			break;
-		case ZT_MAINT_REMOTELOOP:
+		case DAHDI_MAINT_REMOTELOOP:
 			printk("XXX Turn on remote loopback E1 XXX\n");
 			break;
-		case ZT_MAINT_LOOPUP:
+		case DAHDI_MAINT_LOOPUP:
 			printk("XXX Send loopup code E1 XXX\n");
 			break;
-		case ZT_MAINT_LOOPDOWN:
+		case DAHDI_MAINT_LOOPDOWN:
 			printk("XXX Send loopdown code E1 XXX\n");
 			break;
-		case ZT_MAINT_LOOPSTOP:
+		case DAHDI_MAINT_LOOPSTOP:
 			printk("XXX Stop sending loop codes E1 XXX\n");
 			break;
 		default:
@@ -480,22 +480,22 @@ static int t1xxp_maint(struct zt_span *span, int cmd)
 		}
 	} else {
 		switch(cmd) {
-	    case ZT_MAINT_NONE:
+	    case DAHDI_MAINT_NONE:
 			printk("XXX Turn off local and remote loops T1 XXX\n");
 			break;
-	    case ZT_MAINT_LOCALLOOP:
+	    case DAHDI_MAINT_LOCALLOOP:
 			printk("XXX Turn on local loop and no remote loop XXX\n");
 			break;
-	    case ZT_MAINT_REMOTELOOP:
+	    case DAHDI_MAINT_REMOTELOOP:
 			printk("XXX Turn on remote loopup XXX\n");
 			break;
-	    case ZT_MAINT_LOOPUP:
+	    case DAHDI_MAINT_LOOPUP:
 			t1_framer_out(wc, 0x21, 0x50);	/* FMR5: Nothing but RBS mode */
 			break;
-	    case ZT_MAINT_LOOPDOWN:
+	    case DAHDI_MAINT_LOOPDOWN:
 			t1_framer_out(wc, 0x21, 0x60);	/* FMR5: Nothing but RBS mode */
 			break;
-	    case ZT_MAINT_LOOPSTOP:
+	    case DAHDI_MAINT_LOOPSTOP:
 			t1_framer_out(wc, 0x21, 0x40);	/* FMR5: Nothing but RBS mode */
 			break;
 	    default:
@@ -506,7 +506,7 @@ static int t1xxp_maint(struct zt_span *span, int cmd)
 	return 0;
 }
 
-static int t1xxp_rbsbits(struct zt_chan *chan, int bits)
+static int t1xxp_rbsbits(struct dahdi_chan *chan, int bits)
 {
 	u_char m,c;
 	int n,b;
@@ -530,7 +530,7 @@ static int t1xxp_rbsbits(struct zt_chan *chan, int bits)
 		wc->txsigs[b] = c;
 		  /* output them to the chip */
 		__t1_framer_out(wc,0x71 + b,c); 
-	} else if (wc->span.lineconfig & ZT_CONFIG_D4) {
+	} else if (wc->span.lineconfig & DAHDI_CONFIG_D4) {
 		n = chan->chanpos - 1;
 		b = (n/4);
 		c = wc->txsigs[b];
@@ -541,7 +541,7 @@ static int t1xxp_rbsbits(struct zt_chan *chan, int bits)
 		  /* output them to the chip */
 		__t1_framer_out(wc,0x70 + b,c); 
 		__t1_framer_out(wc,0x70 + b + 6,c); 
-	} else if (wc->span.lineconfig & ZT_CONFIG_ESF) {
+	} else if (wc->span.lineconfig & DAHDI_CONFIG_ESF) {
 		n = chan->chanpos - 1;
 		b = (n/2);
 		c = wc->txsigs[b];
@@ -563,7 +563,7 @@ static void t1_check_sigbits(struct t1 *wc)
 	int a,i,rxs;
 	unsigned long flags;
 
-	if (!(wc->span.flags & ZT_FLAG_RUNNING))
+	if (!(wc->span.flags & DAHDI_FLAG_RUNNING))
 		return;
 
 	spin_lock_irqsave(&wc->lock, flags);
@@ -573,55 +573,55 @@ static void t1_check_sigbits(struct t1 *wc)
 			a = __t1_framer_in(wc, 0x71 + i);
 			/* Get high channel in low bits */
 			rxs = (a & 0xf);
-			if (!(wc->span.chans[i+16].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->span.chans[i+16].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->span.chans[i+16].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->span.chans[i+16], rxs);
+					dahdi_rbsbits(&wc->span.chans[i+16], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
 			rxs = (a >> 4) & 0xf;
-			if (!(wc->span.chans[i].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->span.chans[i].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->span.chans[i].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->span.chans[i], rxs);
+					dahdi_rbsbits(&wc->span.chans[i], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
 		}
-	} else if (wc->span.lineconfig & ZT_CONFIG_D4) {
+	} else if (wc->span.lineconfig & DAHDI_CONFIG_D4) {
 		for (i = 0; i < 24; i+=4) {
 			a = __t1_framer_in(wc, 0x70 + (i>>2));
 			/* Get high channel in low bits */
 			rxs = (a & 0x3) << 2;
-			if (!(wc->span.chans[i+3].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->span.chans[i+3].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->span.chans[i+3].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->span.chans[i+3], rxs);
+					dahdi_rbsbits(&wc->span.chans[i+3], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
 			rxs = (a & 0xc);
-			if (!(wc->span.chans[i+2].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->span.chans[i+2].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->span.chans[i+2].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->span.chans[i+2], rxs);
+					dahdi_rbsbits(&wc->span.chans[i+2], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
 			rxs = (a >> 2) & 0xc;
-			if (!(wc->span.chans[i+1].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->span.chans[i+1].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->span.chans[i+1].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->span.chans[i+1], rxs);
+					dahdi_rbsbits(&wc->span.chans[i+1], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
 			rxs = (a >> 4) & 0xc;
-			if (!(wc->span.chans[i].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->span.chans[i].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->span.chans[i].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->span.chans[i], rxs);
+					dahdi_rbsbits(&wc->span.chans[i], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
@@ -631,18 +631,18 @@ static void t1_check_sigbits(struct t1 *wc)
 			a = __t1_framer_in(wc, 0x70 + (i>>1));
 			/* Get high channel in low bits */
 			rxs = (a & 0xf);
-			if (!(wc->span.chans[i+1].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->span.chans[i+1].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->span.chans[i+1].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->span.chans[i+1], rxs);
+					dahdi_rbsbits(&wc->span.chans[i+1], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
 			rxs = (a >> 4) & 0xf;
-			if (!(wc->span.chans[i].sig & ZT_SIG_CLEAR)) {
+			if (!(wc->span.chans[i].sig & DAHDI_SIG_CLEAR)) {
 				if (wc->span.chans[i].rxsig != rxs) {
 					spin_unlock_irqrestore(&wc->lock, flags);
-					zt_rbsbits(&wc->span.chans[i], rxs);
+					dahdi_rbsbits(&wc->span.chans[i], rxs);
 					spin_lock_irqsave(&wc->lock, flags);
 				}
 			}
@@ -730,14 +730,14 @@ static void __t1_configure_t1(struct t1 *wc, int lineconfig, int txlevel)
 	__t1_framer_out(wc, 0x1e, fmr2);
 
 	/* Configure line interface */
-	if (lineconfig & ZT_CONFIG_AMI) {
+	if (lineconfig & DAHDI_CONFIG_AMI) {
 		line = "AMI";
 		fmr0 = 0xa0;
 	} else {
 		line = "B8ZS";
 		fmr0 = 0xf0;
 	}
-	if (lineconfig & ZT_CONFIG_D4) {
+	if (lineconfig & DAHDI_CONFIG_D4) {
 		framing = "D4";
 	} else {
 		framing = "ESF";
@@ -801,7 +801,7 @@ static void __t1_configure_e1(struct t1 *wc, int lineconfig)
 		fmr2 |= 0x30;
 	if (loopback)
 		fmr2 |= 0x4;
-	if (lineconfig & ZT_CONFIG_CRC4) {
+	if (lineconfig & DAHDI_CONFIG_CRC4) {
 		fmr1 |= 0x08;	/* CRC4 transmit */
 		fmr2 |= 0xc0;	/* CRC4 receive */
 		crc4 = "/CRC4";
@@ -810,14 +810,14 @@ static void __t1_configure_e1(struct t1 *wc, int lineconfig)
 	__t1_framer_out(wc, 0x1e, fmr2);
 
 	/* Configure line interface */
-	if (lineconfig & ZT_CONFIG_AMI) {
+	if (lineconfig & DAHDI_CONFIG_AMI) {
 		line = "AMI";
 		fmr0 = 0xa0;
 	} else {
 		line = "HDB3";
 		fmr0 = 0xf0;
 	}
-	if (lineconfig & ZT_CONFIG_CCS) {
+	if (lineconfig & DAHDI_CONFIG_CCS) {
 		framing = "CCS";
 	} else {
 		framing = "CAS";
@@ -866,9 +866,9 @@ static void __t1_configure_e1(struct t1 *wc, int lineconfig)
 	printk("TE110P: Span configured for %s/%s%s\n", framing, line, crc4);
 }
 
-static void t1xxp_framer_start(struct t1 *wc, struct zt_span *span)
+static void t1xxp_framer_start(struct t1 *wc, struct dahdi_span *span)
 {
-	int alreadyrunning = wc->span.flags & ZT_FLAG_RUNNING;
+	int alreadyrunning = wc->span.flags & DAHDI_FLAG_RUNNING;
 	unsigned long flags;
 
 	spin_lock_irqsave(&wc->lock, flags);
@@ -881,25 +881,25 @@ static void t1xxp_framer_start(struct t1 *wc, struct zt_span *span)
 	}
 	
 	if (!alreadyrunning) 
-		wc->span.flags |= ZT_FLAG_RUNNING;
+		wc->span.flags |= DAHDI_FLAG_RUNNING;
 
 	spin_unlock_irqrestore(&wc->lock, flags);
 }
 
 
-static int t1xxp_startup(struct zt_span *span)
+static int t1xxp_startup(struct dahdi_span *span)
 {
 	struct t1 *wc = span->pvt;
 
-	int i,alreadyrunning = span->flags & ZT_FLAG_RUNNING;
+	int i,alreadyrunning = span->flags & DAHDI_FLAG_RUNNING;
 
 	/* initialize the start value for the entire chunk of last ec buffer */
 	for(i = 0; i < span->channels; i++)
 	{
 		memset(wc->ec_chunk1[i],
-			ZT_LIN2X(0,&span->chans[i]),ZT_CHUNKSIZE);
+			DAHDI_LIN2X(0,&span->chans[i]),DAHDI_CHUNKSIZE);
 		memset(wc->ec_chunk2[i],
-			ZT_LIN2X(0,&span->chans[i]),ZT_CHUNKSIZE);
+			DAHDI_LIN2X(0,&span->chans[i]),DAHDI_CHUNKSIZE);
 	}
 
 	/* Reset framer with proper parameters and start */
@@ -910,12 +910,12 @@ static int t1xxp_startup(struct zt_span *span)
 		/* Only if we're not already going */
 		t1xxp_enable_interrupts(wc);
 		t1xxp_start_dma(wc);
-		span->flags |= ZT_FLAG_RUNNING;
+		span->flags |= DAHDI_FLAG_RUNNING;
 	}
 	return 0;
 }
 
-static int t1xxp_shutdown(struct zt_span *span)
+static int t1xxp_shutdown(struct dahdi_span *span)
 {
 	struct t1 *wc = span->pvt;
 	unsigned long flags;
@@ -924,17 +924,17 @@ static int t1xxp_shutdown(struct zt_span *span)
 	__t1_framer_out(wc, 0x46, 0x41);	/* GCR: Interrupt on Activation/Deactivation of AIX, LOS */
 	__t1xxp_stop_dma(wc);
 	__t1xxp_disable_interrupts(wc);
-	span->flags &= ~ZT_FLAG_RUNNING;
+	span->flags &= ~DAHDI_FLAG_RUNNING;
 	spin_unlock_irqrestore(&wc->lock, flags);
 	return 0;
 }
 
 
-static int t1xxp_chanconfig(struct zt_chan *chan, int sigtype)
+static int t1xxp_chanconfig(struct dahdi_chan *chan, int sigtype)
 {
 	struct t1 *wc = chan->pvt;
 	unsigned long flags;
-	int alreadyrunning = chan->span->flags & ZT_FLAG_RUNNING;
+	int alreadyrunning = chan->span->flags & DAHDI_FLAG_RUNNING;
 
 	spin_lock_irqsave(&wc->lock, flags);
 
@@ -945,14 +945,14 @@ static int t1xxp_chanconfig(struct zt_chan *chan, int sigtype)
 	return 0;
 }
 
-static int t1xxp_spanconfig(struct zt_span *span, struct zt_lineconfig *lc)
+static int t1xxp_spanconfig(struct dahdi_span *span, struct dahdi_lineconfig *lc)
 {
 	struct t1 *wc = span->pvt;
 
 	/* Do we want to SYNC on receive or not */
 	wc->sync = lc->sync;
 	/* If already running, apply changes immediately */
-	if (span->flags & ZT_FLAG_RUNNING)
+	if (span->flags & DAHDI_FLAG_RUNNING)
 		return t1xxp_startup(span);
 
 	return 0;
@@ -992,30 +992,30 @@ static int t1xxp_software_init(struct t1 *wc)
 			wc->span.channels = 32;
 		else
 			wc->span.channels = 31;
-		wc->span.deflaw = ZT_LAW_ALAW;
+		wc->span.deflaw = DAHDI_LAW_ALAW;
 		wc->span.spantype = "E1";
-		wc->span.linecompat = ZT_CONFIG_HDB3 | ZT_CONFIG_CCS | ZT_CONFIG_CRC4;
+		wc->span.linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 	} else {
 		wc->span.channels = 24;
-		wc->span.deflaw = ZT_LAW_MULAW;
+		wc->span.deflaw = DAHDI_LAW_MULAW;
 		wc->span.spantype = "T1";
-		wc->span.linecompat = ZT_CONFIG_AMI | ZT_CONFIG_B8ZS | ZT_CONFIG_D4 | ZT_CONFIG_ESF;
+		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
 	}
 	wc->span.chans = wc->chans;
-	wc->span.flags = ZT_FLAG_RBS;
+	wc->span.flags = DAHDI_FLAG_RBS;
 	wc->span.ioctl = t1xxp_ioctl;
 	wc->span.pvt = wc;
 	init_waitqueue_head(&wc->span.maintq);
 	for (x=0;x<wc->span.channels;x++) {
 		sprintf(wc->chans[x].name, "WCT1/%d/%d", wc->num, x + 1);
-		wc->chans[x].sigcap = ZT_SIG_EM | ZT_SIG_CLEAR | ZT_SIG_EM_E1 | 
-				      ZT_SIG_FXSLS | ZT_SIG_FXSGS | ZT_SIG_MTP2 |
-				      ZT_SIG_FXSKS | ZT_SIG_FXOLS | ZT_SIG_DACS_RBS |
-				      ZT_SIG_FXOGS | ZT_SIG_FXOKS | ZT_SIG_CAS | ZT_SIG_SF;
+		wc->chans[x].sigcap = DAHDI_SIG_EM | DAHDI_SIG_CLEAR | DAHDI_SIG_EM_E1 | 
+				      DAHDI_SIG_FXSLS | DAHDI_SIG_FXSGS | DAHDI_SIG_MTP2 |
+				      DAHDI_SIG_FXSKS | DAHDI_SIG_FXOLS | DAHDI_SIG_DACS_RBS |
+				      DAHDI_SIG_FXOGS | DAHDI_SIG_FXOKS | DAHDI_SIG_CAS | DAHDI_SIG_SF;
 		wc->chans[x].pvt = wc;
 		wc->chans[x].chanpos = x + 1;
 	}
-	if (zt_register(&wc->span, 0)) {
+	if (dahdi_register(&wc->span, 0)) {
 		printk("Unable to register span with zaptel\n");
 		return -1;
 	}
@@ -1026,7 +1026,7 @@ static inline void __handle_leds(struct t1 *wc)
 {
 	int oldreg;
 
-	if (wc->span.alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE)) {
+	if (wc->span.alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE)) {
 		/* Red/Blue alarm */
 		wc->blinktimer++;
 #ifdef FANCY_ALARM
@@ -1052,7 +1052,7 @@ static inline void __handle_leds(struct t1 *wc)
 			wc->blinktimer = 0;
 		}
 #endif
-	} else if (wc->span.alarms & ZT_ALARM_YELLOW) {
+	} else if (wc->span.alarms & DAHDI_ALARM_YELLOW) {
 		/* Yellow Alarm */
 		if (!(wc->blinktimer % 2)) 
 			wc->ledtestreg = (wc->ledtestreg | BIT_LED1) & ~BIT_LED0;
@@ -1062,11 +1062,11 @@ static inline void __handle_leds(struct t1 *wc)
 	} else {
 		/* No Alarm */
 		oldreg = wc->ledtestreg;
-		if (wc->span.maintstat != ZT_MAINT_NONE)
+		if (wc->span.maintstat != DAHDI_MAINT_NONE)
 			wc->ledtestreg |= BIT_TEST;
 		else
 			wc->ledtestreg &= ~BIT_TEST;
-		if (wc->span.flags & ZT_FLAG_RUNNING)
+		if (wc->span.flags & DAHDI_FLAG_RUNNING)
 			wc->ledtestreg = (wc->ledtestreg | BIT_LED0) & ~BIT_LED1;
 		else
 			wc->ledtestreg = wc->ledtestreg & ~(BIT_LED0 | BIT_LED1);
@@ -1086,19 +1086,19 @@ static void t1xxp_transmitprep(struct t1 *wc, int ints)
 		txbuf = wc->writechunk;
 	} else {
 		/* Just finished sending second buffer, fill it now */
-		txbuf = wc->writechunk + 32 * ZT_CHUNKSIZE;
+		txbuf = wc->writechunk + 32 * DAHDI_CHUNKSIZE;
 	}
-	zt_transmit(&wc->span);
+	dahdi_transmit(&wc->span);
 	for (x=0;x<wc->offset;x++)
 		txbuf[x] = wc->tempo[x];
-	for (y=0;y<ZT_CHUNKSIZE;y++) {
+	for (y=0;y<DAHDI_CHUNKSIZE;y++) {
 		for (x=0;x<wc->span.channels;x++) {
 			pos = y * 32 + wc->chanmap[x] + wc->offset;
 			/* Put channel number as outgoing data */
-			if (pos < 32 * ZT_CHUNKSIZE)
+			if (pos < 32 * DAHDI_CHUNKSIZE)
 				txbuf[pos] = wc->chans[x].writechunk[y];
 			else
-				wc->tempo[pos - 32 * ZT_CHUNKSIZE] = wc->chans[x].writechunk[y];
+				wc->tempo[pos - 32 * DAHDI_CHUNKSIZE] = wc->chans[x].writechunk[y];
 		}
 	}
 }
@@ -1113,10 +1113,10 @@ static void t1xxp_receiveprep(struct t1 *wc, int ints)
 	if (ints & 0x04) {
 		/* Just received first buffer */
 		rxbuf = wc->readchunk;
-		canary = (unsigned int *)(wc->readchunk + ZT_CHUNKSIZE * 64 - 4);
+		canary = (unsigned int *)(wc->readchunk + DAHDI_CHUNKSIZE * 64 - 4);
 	} else {
-		rxbuf = wc->readchunk + ZT_CHUNKSIZE * 32;
-		canary = (unsigned int *)(wc->readchunk + ZT_CHUNKSIZE * 32 - 4);
+		rxbuf = wc->readchunk + DAHDI_CHUNKSIZE * 32;
+		canary = (unsigned int *)(wc->readchunk + DAHDI_CHUNKSIZE * 32 - 4);
 	}
 	oldcan = *canary;
 	if (((oldcan & 0xffff0000) >> 16) != CANARY) {
@@ -1127,7 +1127,7 @@ static void t1xxp_receiveprep(struct t1 *wc, int ints)
 		if (debug) printk("Expecting bottom %d, got %d\n", wc->canary - 1, oldcan & 0xffff);
 		wc->span.irqmisses++;
 	}
-	for (y=0;y<ZT_CHUNKSIZE;y++) {
+	for (y=0;y<DAHDI_CHUNKSIZE;y++) {
 		for (x=0;x<wc->span.channels;x++) {
 			/* XXX Optimize, remove * and + XXX */
 			/* Must map received channels into appropriate data */
@@ -1167,15 +1167,15 @@ static void t1xxp_receiveprep(struct t1 *wc, int ints)
 		} 
 	}
 	/* Store the next canary */
-	canary = (unsigned int *)(rxbuf + ZT_CHUNKSIZE * 32 - 4);
+	canary = (unsigned int *)(rxbuf + DAHDI_CHUNKSIZE * 32 - 4);
 	*canary = (wc->canary++) | (CANARY << 16);
 	for (x=0;x<wc->span.channels;x++) {
-		zt_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, 
+		dahdi_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, 
 			wc->ec_chunk2[x]);
-		memcpy(wc->ec_chunk2[x],wc->ec_chunk1[x],ZT_CHUNKSIZE);
-		memcpy(wc->ec_chunk1[x],wc->chans[x].writechunk,ZT_CHUNKSIZE);
+		memcpy(wc->ec_chunk2[x],wc->ec_chunk1[x],DAHDI_CHUNKSIZE);
+		memcpy(wc->ec_chunk1[x],wc->chans[x].writechunk,DAHDI_CHUNKSIZE);
 	}
-	zt_receive(&wc->span);
+	dahdi_receive(&wc->span);
 }
 
 static void t1_check_alarms(struct t1 *wc)
@@ -1185,7 +1185,7 @@ static void t1_check_alarms(struct t1 *wc)
 	int x,j;
 	unsigned long flags;
 
-	if (!(wc->span.flags & ZT_FLAG_RUNNING))
+	if (!(wc->span.flags & DAHDI_FLAG_RUNNING))
 		return;
 
 	spin_lock_irqsave(&wc->lock, flags);
@@ -1200,7 +1200,7 @@ static void t1_check_alarms(struct t1 *wc)
 	alarms = 0;
 
 	/* And consider only carrier alarms */
-	wc->span.alarms &= (ZT_ALARM_RED | ZT_ALARM_BLUE | ZT_ALARM_NOTOPEN);
+	wc->span.alarms &= (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | DAHDI_ALARM_NOTOPEN);
 
 	if (wc->spantype == TYPE_E1) {
 		if (c & 0x04) {
@@ -1226,44 +1226,44 @@ static void t1_check_alarms(struct t1 *wc)
 		/* Detect loopup code if we're not sending one */
 		if ((!wc->span.mainttimer) && (d & 0x08)) {
 			/* Loop-up code detected */
-			if ((wc->loopupcnt++ > 80)  && (wc->span.maintstat != ZT_MAINT_REMOTELOOP)) {
+			if ((wc->loopupcnt++ > 80)  && (wc->span.maintstat != DAHDI_MAINT_REMOTELOOP)) {
 				__t1_framer_out(wc, 0x36, 0x08);	/* LIM0: Disable any local loop */
 				__t1_framer_out(wc, 0x37, 0xf6 );	/* LIM1: Enable remote loop */
-				wc->span.maintstat = ZT_MAINT_REMOTELOOP;
+				wc->span.maintstat = DAHDI_MAINT_REMOTELOOP;
 			}
 		} else
 			wc->loopupcnt = 0;
 		/* Same for loopdown code */
 		if ((!wc->span.mainttimer) && (d & 0x10)) {
 			/* Loop-down code detected */
-			if ((wc->loopdowncnt++ > 80)  && (wc->span.maintstat == ZT_MAINT_REMOTELOOP)) {
+			if ((wc->loopdowncnt++ > 80)  && (wc->span.maintstat == DAHDI_MAINT_REMOTELOOP)) {
 				__t1_framer_out(wc, 0x36, 0x08);	/* LIM0: Disable any local loop */
 				__t1_framer_out(wc, 0x37, 0xf0 );	/* LIM1: Disable remote loop */
-				wc->span.maintstat = ZT_MAINT_NONE;
+				wc->span.maintstat = DAHDI_MAINT_NONE;
 			}
 		} else
 			wc->loopdowncnt = 0;
 	}
 
-	if (wc->span.lineconfig & ZT_CONFIG_NOTOPEN) {
+	if (wc->span.lineconfig & DAHDI_CONFIG_NOTOPEN) {
 		for (x=0,j=0;x < wc->span.channels;x++)
-			if ((wc->span.chans[x].flags & ZT_FLAG_OPEN) ||
-			    (wc->span.chans[x].flags & ZT_FLAG_NETDEV))
+			if ((wc->span.chans[x].flags & DAHDI_FLAG_OPEN) ||
+			    (wc->span.chans[x].flags & DAHDI_FLAG_NETDEV))
 				j++;
 		if (!j)
-			alarms |= ZT_ALARM_NOTOPEN;
+			alarms |= DAHDI_ALARM_NOTOPEN;
 	}
 
 	if (c & 0xa0) {
 		if (wc->alarmcount >= alarmdebounce) {
 			if (!unchannelized)
-				alarms |= ZT_ALARM_RED;
+				alarms |= DAHDI_ALARM_RED;
 		} else
 			wc->alarmcount++;
 	} else
 		wc->alarmcount = 0;
 	if (c & 0x4)
-		alarms |= ZT_ALARM_BLUE;
+		alarms |= DAHDI_ALARM_BLUE;
 
 	if (((!wc->span.alarms) && alarms) || 
 	    (wc->span.alarms && (!alarms))) 
@@ -1271,9 +1271,9 @@ static void t1_check_alarms(struct t1 *wc)
 
 	/* Keep track of recovering */
 	if ((!alarms) && wc->span.alarms) 
-		wc->alarmtimer = ZT_ALARMSETTLE_TIME;
+		wc->alarmtimer = DAHDI_ALARMSETTLE_TIME;
 	if (wc->alarmtimer)
-		alarms |= ZT_ALARM_RECOVER;
+		alarms |= DAHDI_ALARM_RECOVER;
 
 	/* If receiving alarms, go into Yellow alarm state */
 	if (alarms && !(wc->spanflags & FLAG_SENDINGYELLOW)) {
@@ -1299,12 +1299,12 @@ static void t1_check_alarms(struct t1 *wc)
 	/* Re-check the timing source when we enter/leave alarm, not withstanding
 	   yellow alarm */
 	if ((c & 0x10) && !unchannelized)
-		alarms |= ZT_ALARM_YELLOW;
+		alarms |= DAHDI_ALARM_YELLOW;
 	if (wc->span.mainttimer || wc->span.maintstat) 
-		alarms |= ZT_ALARM_LOOPBACK;
+		alarms |= DAHDI_ALARM_LOOPBACK;
 	wc->span.alarms = alarms;
 	spin_unlock_irqrestore(&wc->lock, flags);
-	zt_alarm_notify(&wc->span);
+	dahdi_alarm_notify(&wc->span);
 }
 
 
@@ -1315,9 +1315,9 @@ static void t1_do_counters(struct t1 *wc)
 	spin_lock_irqsave(&wc->lock, flags);
 	if (wc->alarmtimer) {
 		if (!--wc->alarmtimer) {
-			wc->span.alarms &= ~(ZT_ALARM_RECOVER);
+			wc->span.alarms &= ~(DAHDI_ALARM_RECOVER);
 			spin_unlock_irqrestore(&wc->lock, flags);
-			zt_alarm_notify(&wc->span);
+			dahdi_alarm_notify(&wc->span);
 			spin_lock_irqsave(&wc->lock, flags);
 		}
 	}
@@ -1419,15 +1419,15 @@ static int t1xxp_hardware_init(struct t1 *wc)
 	/* Start at writedma */
 	outl(wc->writedma,                    wc->ioaddr + WC_DMAWS);		/* Write start */
 	/* First frame */
-	outl(wc->writedma + ZT_CHUNKSIZE * 32 - 4, wc->ioaddr + WC_DMAWI);		/* Middle (interrupt) */
+	outl(wc->writedma + DAHDI_CHUNKSIZE * 32 - 4, wc->ioaddr + WC_DMAWI);		/* Middle (interrupt) */
 	/* Second frame */
-	outl(wc->writedma + ZT_CHUNKSIZE * 32 * 2 - 4, wc->ioaddr + WC_DMAWE);			/* End */
+	outl(wc->writedma + DAHDI_CHUNKSIZE * 32 * 2 - 4, wc->ioaddr + WC_DMAWE);			/* End */
 	
 	outl(wc->readdma,                    	 wc->ioaddr + WC_DMARS);	/* Read start */
 	/* First frame */
-	outl(wc->readdma + ZT_CHUNKSIZE * 32 - 4, 	 wc->ioaddr + WC_DMARI);	/* Middle (interrupt) */
+	outl(wc->readdma + DAHDI_CHUNKSIZE * 32 - 4, 	 wc->ioaddr + WC_DMARI);	/* Middle (interrupt) */
 	/* Second frame */
-	outl(wc->readdma + ZT_CHUNKSIZE * 32 * 2 - 4, wc->ioaddr + WC_DMARE);	/* End */
+	outl(wc->readdma + DAHDI_CHUNKSIZE * 32 * 2 - 4, wc->ioaddr + WC_DMARE);	/* End */
 	
 	if (debug) printk("Setting up DMA (write/read = %08lx/%08lx)\n", (long)wc->writedma, (long)wc->readdma);
 
@@ -1498,22 +1498,22 @@ static int __devinit t1xxp_init_one(struct pci_dev *pdev, const struct pci_devic
 
 			wc->writechunk = 
 				/* 32 channels, Double-buffer, Read/Write */
-				(unsigned char *)pci_alloc_consistent(pdev, ZT_MAX_CHUNKSIZE * 32 * 2 * 2, &wc->writedma);
+				(unsigned char *)pci_alloc_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 32 * 2 * 2, &wc->writedma);
 			if (!wc->writechunk) {
 				printk("wcte11xp: Unable to allocate DMA-able memory\n");
 				return -ENOMEM;
 			}
 
 			/* Read is after the whole write piece (in bytes) */
-			wc->readchunk = wc->writechunk + ZT_CHUNKSIZE * 32 * 2;
+			wc->readchunk = wc->writechunk + DAHDI_CHUNKSIZE * 32 * 2;
 
 			/* Same thing...  */
-			wc->readdma = wc->writedma + ZT_CHUNKSIZE * 32 * 2;
+			wc->readdma = wc->writedma + DAHDI_CHUNKSIZE * 32 * 2;
 
 			/* Initialize Write/Buffers to all blank data */
-			memset((void *)wc->writechunk,0x00,ZT_MAX_CHUNKSIZE * 2 * 2 * 32);
+			memset((void *)wc->writechunk,0x00,DAHDI_MAX_CHUNKSIZE * 2 * 2 * 32);
 			/* Initialize canary */
-			canary = (unsigned int *)(wc->readchunk + ZT_CHUNKSIZE * 64 - 4);
+			canary = (unsigned int *)(wc->readchunk + DAHDI_CHUNKSIZE * 64 - 4);
 			*canary = (CANARY << 16) | (0xffff);
 
 			/* Enable bus mastering */
@@ -1568,7 +1568,7 @@ static void __devexit t1xxp_remove_one(struct pci_dev *pdev)
 		t1xxp_stop_stuff(wc);
 
 		/* Immediately free resources */
-		pci_free_consistent(pdev, ZT_MAX_CHUNKSIZE * 2 * 2 * 32 * 4, (void *)wc->writechunk, wc->writedma);
+		pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 32 * 4, (void *)wc->writechunk, wc->writedma);
 		free_irq(pdev->irq, wc);
 
 		/* Reset PCI chip and registers */
diff --git a/drivers/dahdi/wcte12xp/base.c b/drivers/dahdi/wcte12xp/base.c
index 0c5e840..0a4e9b2 100644
--- a/drivers/dahdi/wcte12xp/base.c
+++ b/drivers/dahdi/wcte12xp/base.c
@@ -144,7 +144,7 @@ static inline void cmd_dequeue(struct t1 *wc, volatile unsigned char *writechunk
 	/* Skip audio */
 	writechunk += 66;
 	/* Search for something waiting to transmit */
-	if ((slot < 6) && (eframe) && (eframe < ZT_CHUNKSIZE - 1)) { 
+	if ((slot < 6) && (eframe) && (eframe < DAHDI_CHUNKSIZE - 1)) { 
 		/* only 6 useable cs slots per */
 
 		/* framer */
@@ -440,7 +440,7 @@ static void __t1xxp_set_clear(struct t1 *wc, int channo)
 	
 	for (i = 0; i < 24; i++) {
 		j = (i / 8);
-		if (wc->span.chans[i].flags & ZT_FLAG_CLEAR) 
+		if (wc->span.chans[i].flags & DAHDI_FLAG_CLEAR) 
 			val |= 1 << (7 - (i % 8));
 		if (((i % 8)==7) &&  /* write byte every 8 channels */
 		    ((channo < 0) ||    /* channo=-1 means all channels */ 
@@ -455,7 +455,7 @@ static void __t1xxp_set_clear(struct t1 *wc, int channo)
 
 static void t1_release(struct t1 *wc)
 {
-	zt_unregister(&wc->span);
+	dahdi_unregister(&wc->span);
 	kfree(wc);
 	printk("Freed a Wildcard TE12xP\n");
 }
@@ -528,14 +528,14 @@ static void t1_configure_t1(struct t1 *wc, int lineconfig, int txlevel)
 	t1_setreg(wc, 0x1e, fmr2);
 
 	/* Configure line interface */
-	if (lineconfig & ZT_CONFIG_AMI) {
+	if (lineconfig & DAHDI_CONFIG_AMI) {
 		line = "AMI";
 		fmr0 = 0xa0;
 	} else {
 		line = "B8ZS";
 		fmr0 = 0xf0;
 	}
-	if (lineconfig & ZT_CONFIG_D4) {
+	if (lineconfig & DAHDI_CONFIG_D4) {
 		framing = "D4";
 	} else {
 		framing = "ESF";
@@ -601,7 +601,7 @@ static void t1_configure_e1(struct t1 *wc, int lineconfig)
 		fmr2 |= 0x30;
 	if (loopback)
 		fmr2 |= 0x4;
-	if (lineconfig & ZT_CONFIG_CRC4) {
+	if (lineconfig & DAHDI_CONFIG_CRC4) {
 		fmr1 |= 0x08;	/* CRC4 transmit */
 		fmr2 |= 0xc0;	/* CRC4 receive */
 		crc4 = "/CRC4";
@@ -610,14 +610,14 @@ static void t1_configure_e1(struct t1 *wc, int lineconfig)
 	t1_setreg(wc, 0x1e, fmr2);
 
 	/* Configure line interface */
-	if (lineconfig & ZT_CONFIG_AMI) {
+	if (lineconfig & DAHDI_CONFIG_AMI) {
 		line = "AMI";
 		fmr0 = 0xa0;
 	} else {
 		line = "HDB3";
 		fmr0 = 0xf0;
 	}
-	if (lineconfig & ZT_CONFIG_CCS) {
+	if (lineconfig & DAHDI_CONFIG_CCS) {
 		framing = "CCS";
 	} else {
 		framing = "CAS";
@@ -666,9 +666,9 @@ static void t1_configure_e1(struct t1 *wc, int lineconfig)
 	module_printk("Span configured for %s/%s%s\n", framing, line, crc4);
 }
 
-static void t1xxp_framer_start(struct t1 *wc, struct zt_span *span)
+static void t1xxp_framer_start(struct t1 *wc, struct dahdi_span *span)
 {
-	int alreadyrunning = wc->span.flags & ZT_FLAG_RUNNING;
+	int alreadyrunning = wc->span.flags & DAHDI_FLAG_RUNNING;
 	unsigned long flags;
 
 	if (wc->spantype == TYPE_E1) { /* if this is an E1 card */
@@ -680,19 +680,19 @@ static void t1xxp_framer_start(struct t1 *wc, struct zt_span *span)
 
 	spin_lock_irqsave(&wc->reglock, flags);
 	if (!alreadyrunning) 
-		wc->span.flags |= ZT_FLAG_RUNNING;
+		wc->span.flags |= DAHDI_FLAG_RUNNING;
 	spin_unlock_irqrestore(&wc->reglock, flags);
 }
 
-static int t1xxp_startup(struct zt_span *span)
+static int t1xxp_startup(struct dahdi_span *span)
 {
 	struct t1 *wc = span->pvt;
 	int i;
 
 	/* initialize the start value for the entire chunk of last ec buffer */
 	for (i = 0; i < span->channels; i++) {
-		memset(wc->ec_chunk1[i], ZT_LIN2X(0, &span->chans[i]), ZT_CHUNKSIZE);
-		memset(wc->ec_chunk2[i], ZT_LIN2X(0, &span->chans[i]), ZT_CHUNKSIZE);
+		memset(wc->ec_chunk1[i], DAHDI_LIN2X(0, &span->chans[i]), DAHDI_CHUNKSIZE);
+		memset(wc->ec_chunk2[i], DAHDI_LIN2X(0, &span->chans[i]), DAHDI_CHUNKSIZE);
 	}
 
 	/* Reset framer with proper parameters and start */
@@ -702,22 +702,22 @@ static int t1xxp_startup(struct zt_span *span)
 	return 0;
 }
 
-static int t1xxp_shutdown(struct zt_span *span)
+static int t1xxp_shutdown(struct dahdi_span *span)
 {
 	struct t1 *wc = span->pvt;
 	unsigned long flags;
 
 	t1_setreg(wc, 0x46, 0x41);	/* GCR: Interrupt on Activation/Deactivation of AIX, LOS */
 	spin_lock_irqsave(&wc->reglock, flags);
-	span->flags &= ~ZT_FLAG_RUNNING;
+	span->flags &= ~DAHDI_FLAG_RUNNING;
 	spin_unlock_irqrestore(&wc->reglock, flags);
 	return 0;
 }
 
-static int t1xxp_chanconfig(struct zt_chan *chan, int sigtype)
+static int t1xxp_chanconfig(struct dahdi_chan *chan, int sigtype)
 {
 	struct t1 *wc = chan->pvt;
-	int alreadyrunning = chan->span->flags & ZT_FLAG_RUNNING;
+	int alreadyrunning = chan->span->flags & DAHDI_FLAG_RUNNING;
 
 	if (alreadyrunning && (wc->spantype != TYPE_E1))
 		__t1xxp_set_clear(wc, chan->channo);
@@ -725,7 +725,7 @@ static int t1xxp_chanconfig(struct zt_chan *chan, int sigtype)
 	return 0;
 }
 
-static int t1xxp_spanconfig(struct zt_span *span, struct zt_lineconfig *lc)
+static int t1xxp_spanconfig(struct dahdi_span *span, struct dahdi_lineconfig *lc)
 {
 	struct t1 *wc = span->pvt;
 
@@ -737,13 +737,13 @@ static int t1xxp_spanconfig(struct zt_span *span, struct zt_lineconfig *lc)
 		wc->ctlreg &= ~0x80;
 
 	/* If already running, apply changes immediately */
-	if (span->flags & ZT_FLAG_RUNNING)
+	if (span->flags & DAHDI_FLAG_RUNNING)
 		return t1xxp_startup(span);
 
 	return 0;
 }
 
-static int t1xxp_rbsbits(struct zt_chan *chan, int bits)
+static int t1xxp_rbsbits(struct dahdi_chan *chan, int bits)
 {
 	u_char m,c;
 	int n,b;
@@ -767,7 +767,7 @@ static int t1xxp_rbsbits(struct zt_chan *chan, int bits)
 		spin_unlock_irqrestore(&wc->reglock, flags);
 		  /* output them to the chip */
 		t1_setreg_full(wc,0x71 + b,c,1,NOT_VPM); 
-	} else if (wc->span.lineconfig & ZT_CONFIG_D4) {
+	} else if (wc->span.lineconfig & DAHDI_CONFIG_D4) {
 		n = chan->chanpos - 1;
 		b = (n / 4);
 		spin_lock_irqsave(&wc->reglock, flags);	
@@ -780,7 +780,7 @@ static int t1xxp_rbsbits(struct zt_chan *chan, int bits)
 		/* output them to the chip */
 		t1_setreg_full(wc,0x70 + b,c,1,NOT_VPM); 
 		t1_setreg_full(wc,0x70 + b + 6,c,1,NOT_VPM); 
-	} else if (wc->span.lineconfig & ZT_CONFIG_ESF) {
+	} else if (wc->span.lineconfig & DAHDI_CONFIG_ESF) {
 		n = chan->chanpos - 1;
 		b = (n / 2);
 		spin_lock_irqsave(&wc->reglock, flags);	
@@ -802,14 +802,14 @@ static inline void __t1_check_sigbits_reads(struct t1 *wc)
 {
 	int i;
 
-	if (!(wc->span.flags & ZT_FLAG_RUNNING))
+	if (!(wc->span.flags & DAHDI_FLAG_RUNNING))
 		return;
 	if (wc->spantype == TYPE_E1) {
 		for (i = 0; i < 15; i++) {
 			if (t1_getreg(wc, 0x71 + i, 1))
 				wc->isrreaderrors++;
 		}
-	} else if (wc->span.lineconfig & ZT_CONFIG_D4) {
+	} else if (wc->span.lineconfig & DAHDI_CONFIG_D4) {
 		for (i = 0; i < 24; i+=4) {
 			if (t1_getreg(wc, 0x70 + (i >> 2), 1))
 				wc->isrreaderrors++;
@@ -826,7 +826,7 @@ static inline void __t1_check_sigbits(struct t1 *wc)
 {
 	int a,i,rxs;
 
-	if (!(wc->span.flags & ZT_FLAG_RUNNING))
+	if (!(wc->span.flags & DAHDI_FLAG_RUNNING))
 		return;
 	if (wc->spantype == TYPE_E1) {
 		for (i = 0; i < 15; i++) {
@@ -834,57 +834,57 @@ static inline void __t1_check_sigbits(struct t1 *wc)
 			if (a > -1) {
 				/* Get high channel in low bits */
 				rxs = (a & 0xf);
-				if (!(wc->span.chans[i+16].sig & ZT_SIG_CLEAR)) {
+				if (!(wc->span.chans[i+16].sig & DAHDI_SIG_CLEAR)) {
 					if (wc->span.chans[i+16].rxsig != rxs) {
 						spin_unlock(&wc->reglock);
-						zt_rbsbits(&wc->span.chans[i+16], rxs);
+						dahdi_rbsbits(&wc->span.chans[i+16], rxs);
 						spin_lock(&wc->reglock);
 					}
 				}
 				rxs = (a >> 4) & 0xf;
-				if (!(wc->span.chans[i].sig & ZT_SIG_CLEAR)) {
+				if (!(wc->span.chans[i].sig & DAHDI_SIG_CLEAR)) {
 					if (wc->span.chans[i].rxsig != rxs) {
 						spin_unlock(&wc->reglock);
-						zt_rbsbits(&wc->span.chans[i], rxs);
+						dahdi_rbsbits(&wc->span.chans[i], rxs);
 						spin_lock(&wc->reglock);
 					}
 				}
 			}
 		}
-	} else if (wc->span.lineconfig & ZT_CONFIG_D4) {
+	} else if (wc->span.lineconfig & DAHDI_CONFIG_D4) {
 		for (i = 0; i < 24; i+=4) {
 			a = t1_getreg_isr(wc, 0x70 + (i>>2));
 			if (a > -1) {
 				/* Get high channel in low bits */
 				rxs = (a & 0x3) << 2;
-				if (!(wc->span.chans[i+3].sig & ZT_SIG_CLEAR)) {
+				if (!(wc->span.chans[i+3].sig & DAHDI_SIG_CLEAR)) {
 					if (wc->span.chans[i+3].rxsig != rxs) {
 						spin_unlock(&wc->reglock);
-						zt_rbsbits(&wc->span.chans[i+3], rxs);
+						dahdi_rbsbits(&wc->span.chans[i+3], rxs);
 						spin_lock(&wc->reglock);
 					}
 				}
 				rxs = (a & 0xc);
-				if (!(wc->span.chans[i+2].sig & ZT_SIG_CLEAR)) {
+				if (!(wc->span.chans[i+2].sig & DAHDI_SIG_CLEAR)) {
 					if (wc->span.chans[i+2].rxsig != rxs) {
 						spin_unlock(&wc->reglock);
-						zt_rbsbits(&wc->span.chans[i+2], rxs);
+						dahdi_rbsbits(&wc->span.chans[i+2], rxs);
 						spin_lock(&wc->reglock);
 					}
 				}
 				rxs = (a >> 2) & 0xc;
-				if (!(wc->span.chans[i+1].sig & ZT_SIG_CLEAR)) {
+				if (!(wc->span.chans[i+1].sig & DAHDI_SIG_CLEAR)) {
 					if (wc->span.chans[i+1].rxsig != rxs) {
 						spin_unlock(&wc->reglock);
-						zt_rbsbits(&wc->span.chans[i+1], rxs);
+						dahdi_rbsbits(&wc->span.chans[i+1], rxs);
 						spin_lock(&wc->reglock);
 					}
 				}
 				rxs = (a >> 4) & 0xc;
-				if (!(wc->span.chans[i].sig & ZT_SIG_CLEAR)) {
+				if (!(wc->span.chans[i].sig & DAHDI_SIG_CLEAR)) {
 					if (wc->span.chans[i].rxsig != rxs) {
 						spin_unlock(&wc->reglock);
-						zt_rbsbits(&wc->span.chans[i], rxs);
+						dahdi_rbsbits(&wc->span.chans[i], rxs);
 						spin_lock(&wc->reglock);
 					}	
 				}
@@ -896,18 +896,18 @@ static inline void __t1_check_sigbits(struct t1 *wc)
 			if (a > -1) {
 				/* Get high channel in low bits */
 				rxs = (a & 0xf);
-				if (!(wc->span.chans[i+1].sig & ZT_SIG_CLEAR)) {
+				if (!(wc->span.chans[i+1].sig & DAHDI_SIG_CLEAR)) {
 					if (wc->span.chans[i+1].rxsig != rxs) {
 						spin_unlock(&wc->reglock);
-						zt_rbsbits(&wc->span.chans[i+1], rxs);
+						dahdi_rbsbits(&wc->span.chans[i+1], rxs);
 						spin_lock(&wc->reglock);
 					}
 				}
 				rxs = (a >> 4) & 0xf;
-				if (!(wc->span.chans[i].sig & ZT_SIG_CLEAR)) {
+				if (!(wc->span.chans[i].sig & DAHDI_SIG_CLEAR)) {
 					if (wc->span.chans[i].rxsig != rxs) {
 						spin_unlock(&wc->reglock);
-						zt_rbsbits(&wc->span.chans[i], rxs);
+						dahdi_rbsbits(&wc->span.chans[i], rxs);
 						spin_lock(&wc->reglock);
 					}
 				}
@@ -916,28 +916,28 @@ static inline void __t1_check_sigbits(struct t1 *wc)
 	}
 }
 
-static int t1xxp_maint(struct zt_span *span, int cmd)
+static int t1xxp_maint(struct dahdi_span *span, int cmd)
 {
 	struct t1 *wc = span->pvt;
 
 	if (wc->spantype == TYPE_E1) {
 		switch (cmd) {
-		case ZT_MAINT_NONE:
+		case DAHDI_MAINT_NONE:
 			module_printk("XXX Turn off local and remote loops E1 XXX\n");
 			break;
-		case ZT_MAINT_LOCALLOOP:
+		case DAHDI_MAINT_LOCALLOOP:
 			module_printk("XXX Turn on local loopback E1 XXX\n");
 			break;
-		case ZT_MAINT_REMOTELOOP:
+		case DAHDI_MAINT_REMOTELOOP:
 			module_printk("XXX Turn on remote loopback E1 XXX\n");
 			break;
-		case ZT_MAINT_LOOPUP:
+		case DAHDI_MAINT_LOOPUP:
 			module_printk("XXX Send loopup code E1 XXX\n");
 			break;
-		case ZT_MAINT_LOOPDOWN:
+		case DAHDI_MAINT_LOOPDOWN:
 			module_printk("XXX Send loopdown code E1 XXX\n");
 			break;
-		case ZT_MAINT_LOOPSTOP:
+		case DAHDI_MAINT_LOOPSTOP:
 			module_printk("XXX Stop sending loop codes E1 XXX\n");
 			break;
 		default:
@@ -946,22 +946,22 @@ static int t1xxp_maint(struct zt_span *span, int cmd)
 		}
 	} else {
 		switch (cmd) {
-		case ZT_MAINT_NONE:
+		case DAHDI_MAINT_NONE:
 			module_printk("XXX Turn off local and remote loops T1 XXX\n");
 			break;
-		case ZT_MAINT_LOCALLOOP:
+		case DAHDI_MAINT_LOCALLOOP:
 			module_printk("XXX Turn on local loop and no remote loop XXX\n");
 			break;
-		case ZT_MAINT_REMOTELOOP:
+		case DAHDI_MAINT_REMOTELOOP:
 			module_printk("XXX Turn on remote loopup XXX\n");
 			break;
-		case ZT_MAINT_LOOPUP:
+		case DAHDI_MAINT_LOOPUP:
 			t1_setreg(wc, 0x21, 0x50);	/* FMR5: Nothing but RBS mode */
 			break;
-		case ZT_MAINT_LOOPDOWN:
+		case DAHDI_MAINT_LOOPDOWN:
 			t1_setreg(wc, 0x21, 0x60);	/* FMR5: Nothing but RBS mode */
 			break;
-		case ZT_MAINT_LOOPSTOP:
+		case DAHDI_MAINT_LOOPSTOP:
 			t1_setreg(wc, 0x21, 0x40);	/* FMR5: Nothing but RBS mode */
 			break;
 		default:
@@ -973,7 +973,7 @@ static int t1xxp_maint(struct zt_span *span, int cmd)
 	return 0;
 }
 
-static int t1xxp_open(struct zt_chan *chan)
+static int t1xxp_open(struct dahdi_chan *chan)
 {
 	struct t1 *wc = chan->pvt;
 
@@ -990,7 +990,7 @@ static int t1xxp_open(struct zt_chan *chan)
 	return 0;
 }
 
-static int t1xxp_close(struct zt_chan *chan)
+static int t1xxp_close(struct dahdi_chan *chan)
 {
 	struct t1 *wc = chan->pvt;
 
@@ -1009,7 +1009,7 @@ static int t1xxp_close(struct zt_chan *chan)
 	return 0;
 }
 
-static int t1xxp_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long data)
+static int t1xxp_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long data)
 {
 	unsigned int x;
 	struct t1 *wc = chan->pvt;
@@ -1024,21 +1024,21 @@ static int t1xxp_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 		return -ENOSYS;
 		break;
 #ifdef VPM_SUPPORT
-	case ZT_TONEDETECT:
+	case DAHDI_TONEDETECT:
 		if (get_user(x, (int *) data))
 			return -EFAULT;
 		if (!wc->vpm150m)
 			return -ENOSYS;
 		if (wc->vpm150m && (x && !vpmdtmfsupport))
 			return -ENOSYS;
-		if (x & ZT_TONEDETECT_ON) {
+		if (x & DAHDI_TONEDETECT_ON) {
 			set_bit(chan->chanpos - 1, &wc->dtmfmask);
 			module_printk("turning on tone detection\n");
 		} else {
 			clear_bit(chan->chanpos - 1, &wc->dtmfmask);
 			module_printk("turning off tone detection\n");
 		}
-		if (x & ZT_TONEDETECT_MUTE) {
+		if (x & DAHDI_TONEDETECT_MUTE) {
 			if(wc->vpm150m)
 				set_bit(chan->chanpos - 1, &wc->vpm150m->desireddtmfmutestate);
 		} else {
@@ -1057,7 +1057,7 @@ static int t1xxp_ioctl(struct zt_chan *chan, unsigned int cmd, unsigned long dat
 
 #include "adt_lec.c"
 
-static int t1xxp_echocan_with_params(struct zt_chan *chan, struct zt_echocanparams *ecp, struct zt_echocanparam *p)
+static int t1xxp_echocan_with_params(struct dahdi_chan *chan, struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p)
 {
 	struct adt_lec_params params;
 	struct t1 *wc = chan->pvt;
@@ -1150,28 +1150,28 @@ static int t1_software_init(struct t1 *wc)
 		else
 			wc->span.channels = 31;
 		wc->span.spantype = "E1";
-		wc->span.linecompat = ZT_CONFIG_HDB3 | ZT_CONFIG_CCS | ZT_CONFIG_CRC4;
-		wc->span.deflaw = ZT_LAW_ALAW;
+		wc->span.linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
+		wc->span.deflaw = DAHDI_LAW_ALAW;
 	} else {
 		wc->span.channels = 24;
 		wc->span.spantype = "T1";
-		wc->span.linecompat = ZT_CONFIG_AMI | ZT_CONFIG_B8ZS | ZT_CONFIG_D4 | ZT_CONFIG_ESF;
-		wc->span.deflaw = ZT_LAW_MULAW;
+		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
+		wc->span.deflaw = DAHDI_LAW_MULAW;
 	}
 	wc->span.chans = wc->chans;
-	wc->span.flags = ZT_FLAG_RBS;
+	wc->span.flags = DAHDI_FLAG_RBS;
 	wc->span.pvt = wc;
 	init_waitqueue_head(&wc->span.maintq);
 	for (x = 0; x < wc->span.channels; x++) {
 		sprintf(wc->chans[x].name, "WCT1/%d/%d", wc->num, x + 1);
-		wc->chans[x].sigcap = ZT_SIG_EM | ZT_SIG_CLEAR | ZT_SIG_EM_E1 | 
-				      ZT_SIG_FXSLS | ZT_SIG_FXSGS | ZT_SIG_MTP2 |
-				      ZT_SIG_FXSKS | ZT_SIG_FXOLS | ZT_SIG_DACS_RBS |
-				      ZT_SIG_FXOGS | ZT_SIG_FXOKS | ZT_SIG_CAS | ZT_SIG_SF;
+		wc->chans[x].sigcap = DAHDI_SIG_EM | DAHDI_SIG_CLEAR | DAHDI_SIG_EM_E1 | 
+				      DAHDI_SIG_FXSLS | DAHDI_SIG_FXSGS | DAHDI_SIG_MTP2 |
+				      DAHDI_SIG_FXSKS | DAHDI_SIG_FXOLS | DAHDI_SIG_DACS_RBS |
+				      DAHDI_SIG_FXOGS | DAHDI_SIG_FXOKS | DAHDI_SIG_CAS | DAHDI_SIG_SF;
 		wc->chans[x].pvt = wc;
 		wc->chans[x].chanpos = x + 1;
 	}
-	if (zt_register(&wc->span, 0)) {
+	if (dahdi_register(&wc->span, 0)) {
 		module_printk("Unable to register span with Zaptel\n");
 		return -1;
 	}
@@ -1253,7 +1253,7 @@ static int t1_hardware_post_init(struct t1 *wc)
 
 static inline void __t1_check_alarms_reads(struct t1 *wc)
 {
-	if (!(wc->span.flags & ZT_FLAG_RUNNING))
+	if (!(wc->span.flags & DAHDI_FLAG_RUNNING))
 		return;
 
 	if (t1_getreg(wc, 0x4c, 1))
@@ -1271,7 +1271,7 @@ static inline void __t1_check_alarms(struct t1 *wc)
 	int x,j;
 	unsigned char fmr4; /* must read this always */
 
-	if (!(wc->span.flags & ZT_FLAG_RUNNING))
+	if (!(wc->span.flags & DAHDI_FLAG_RUNNING))
 		return;
 
 	c = t1_getreg_isr(wc, 0x4c);
@@ -1282,7 +1282,7 @@ static inline void __t1_check_alarms(struct t1 *wc)
 	alarms = 0;
 
 	/* And consider only carrier alarms */
-	wc->span.alarms &= (ZT_ALARM_RED | ZT_ALARM_BLUE | ZT_ALARM_NOTOPEN);
+	wc->span.alarms &= (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE | DAHDI_ALARM_NOTOPEN);
 
 	if (wc->spantype == TYPE_E1) {
 		if (c & 0x04) {
@@ -1308,50 +1308,50 @@ static inline void __t1_check_alarms(struct t1 *wc)
 		/* Detect loopup code if we're not sending one */
 		if ((!wc->span.mainttimer) && (d & 0x08)) {
 			/* Loop-up code detected */
-			if ((wc->loopupcnt++ > 80)  && (wc->span.maintstat != ZT_MAINT_REMOTELOOP)) {
+			if ((wc->loopupcnt++ > 80)  && (wc->span.maintstat != DAHDI_MAINT_REMOTELOOP)) {
 				t1_setreg_full(wc, 0x36, 0x08, 1, NOT_VPM);	/* LIM0: Disable any local loop */
 				t1_setreg_full(wc, 0x37, 0xf6, 1, NOT_VPM);	/* LIM1: Enable remote loop */
-				wc->span.maintstat = ZT_MAINT_REMOTELOOP;
+				wc->span.maintstat = DAHDI_MAINT_REMOTELOOP;
 			}
 		} else
 			wc->loopupcnt = 0;
 		/* Same for loopdown code */
 		if ((!wc->span.mainttimer) && (d & 0x10)) {
 			/* Loop-down code detected */
-			if ((wc->loopdowncnt++ > 80)  && (wc->span.maintstat == ZT_MAINT_REMOTELOOP)) {
+			if ((wc->loopdowncnt++ > 80)  && (wc->span.maintstat == DAHDI_MAINT_REMOTELOOP)) {
 				t1_setreg_full(wc, 0x36, 0x08, 1, NOT_VPM);	/* LIM0: Disable any local loop */
 				t1_setreg_full(wc, 0x37, 0xf0, 1, NOT_VPM);	/* LIM1: Disable remote loop */
-				wc->span.maintstat = ZT_MAINT_NONE;
+				wc->span.maintstat = DAHDI_MAINT_NONE;
 			}
 		} else
 			wc->loopdowncnt = 0;
 	}
 
-	if (wc->span.lineconfig & ZT_CONFIG_NOTOPEN) {
+	if (wc->span.lineconfig & DAHDI_CONFIG_NOTOPEN) {
 		for (x=0,j=0;x < wc->span.channels;x++)
-			if ((wc->span.chans[x].flags & ZT_FLAG_OPEN) ||
-			    (wc->span.chans[x].flags & ZT_FLAG_NETDEV))
+			if ((wc->span.chans[x].flags & DAHDI_FLAG_OPEN) ||
+			    (wc->span.chans[x].flags & DAHDI_FLAG_NETDEV))
 				j++;
 		if (!j)
-			alarms |= ZT_ALARM_NOTOPEN;
+			alarms |= DAHDI_ALARM_NOTOPEN;
 	}
 
 	if (c & 0xa0) {
 		if (wc->alarmcount >= alarmdebounce) {
 			if (!unchannelized)
-				alarms |= ZT_ALARM_RED;
+				alarms |= DAHDI_ALARM_RED;
 		} else
 			wc->alarmcount++;
 	} else
 		wc->alarmcount = 0;
 	if (c & 0x4)
-		alarms |= ZT_ALARM_BLUE;
+		alarms |= DAHDI_ALARM_BLUE;
 
 	/* Keep track of recovering */
 	if ((!alarms) && wc->span.alarms) 
-		wc->alarmtimer = ZT_ALARMSETTLE_TIME;
+		wc->alarmtimer = DAHDI_ALARMSETTLE_TIME;
 	if (wc->alarmtimer)
-		alarms |= ZT_ALARM_RECOVER;
+		alarms |= DAHDI_ALARM_RECOVER;
 
 	/* If receiving alarms, go into Yellow alarm state */
 	if (alarms && !wc->flags.sendingyellow) {
@@ -1368,18 +1368,18 @@ static inline void __t1_check_alarms(struct t1 *wc)
 	}
 	
 	if ((c & 0x10) && !unchannelized)
-		alarms |= ZT_ALARM_YELLOW;
+		alarms |= DAHDI_ALARM_YELLOW;
 	if (wc->span.mainttimer || wc->span.maintstat) 
-		alarms |= ZT_ALARM_LOOPBACK;
+		alarms |= DAHDI_ALARM_LOOPBACK;
 	wc->span.alarms = alarms;
 	spin_unlock(&wc->reglock);
-	zt_alarm_notify(&wc->span);
+	dahdi_alarm_notify(&wc->span);
 	spin_lock(&wc->reglock);
 }
 
 static inline void __handle_leds(struct t1 *wc)
 {
-	if (wc->span.alarms & (ZT_ALARM_RED | ZT_ALARM_BLUE)) {
+	if (wc->span.alarms & (DAHDI_ALARM_RED | DAHDI_ALARM_BLUE)) {
 		wc->blinktimer++;
 		if (wc->blinktimer == 160)
 			wc->ledtestreg = SET_LED_RED(wc->ledtestreg); 
@@ -1387,18 +1387,18 @@ static inline void __handle_leds(struct t1 *wc)
 			wc->ledtestreg = UNSET_LED_REDGREEN(wc->ledtestreg); 
 			wc->blinktimer = 0;
 		}
-	} else if (wc->span.alarms & ZT_ALARM_YELLOW) {
+	} else if (wc->span.alarms & DAHDI_ALARM_YELLOW) {
 		wc->yellowtimer++;
 		if (!(wc->yellowtimer % 2))
 			wc->ledtestreg = SET_LED_RED(wc->ledtestreg); 
 		else
 			wc->ledtestreg = SET_LED_GREEN(wc->ledtestreg); 
 	} else {
-		if (wc->span.maintstat != ZT_MAINT_NONE)
+		if (wc->span.maintstat != DAHDI_MAINT_NONE)
 			wc->ledtestreg = SET_LED_ORANGE(wc->ledtestreg);
 		else
 			wc->ledtestreg = UNSET_LED_ORANGE(wc->ledtestreg);
-		if (wc->span.flags & ZT_FLAG_RUNNING)
+		if (wc->span.flags & DAHDI_FLAG_RUNNING)
 			wc->ledtestreg = SET_LED_GREEN(wc->ledtestreg); 
 		else
 			wc->ledtestreg = UNSET_LED_REDGREEN(wc->ledtestreg); 
@@ -1415,8 +1415,8 @@ static void __t1_do_counters(struct t1 *wc)
 {
 	if (wc->alarmtimer) {
 		if (!--wc->alarmtimer) {
-			wc->span.alarms &= ~(ZT_ALARM_RECOVER);
-			zt_alarm_notify(&wc->span);
+			wc->span.alarms &= ~(DAHDI_ALARM_RECOVER);
+			dahdi_alarm_notify(&wc->span);
 		}
 	}
 }
@@ -1464,11 +1464,11 @@ static inline void t1_transmitprep(struct t1 *wc, unsigned char* writechunk)
 	/* Calculate Transmission */
 	if (likely(wc->initialized)) {
 		spin_unlock(&wc->reglock);
-		zt_transmit(&wc->span);
+		dahdi_transmit(&wc->span);
 		spin_lock(&wc->reglock);
 	}
 
-	for (x = 0; x < ZT_CHUNKSIZE; x++) {
+	for (x = 0; x < DAHDI_CHUNKSIZE; x++) {
 		if (likely(wc->initialized)) {
 			for (chan = 0; chan < wc->span.channels; chan++)
 				writechunk[(chan+1)*2] = wc->chans[chan].writechunk[x];	
@@ -1484,7 +1484,7 @@ static inline void t1_transmitprep(struct t1 *wc, unsigned char* writechunk)
 		}
 #endif
 
-		if (x < ZT_CHUNKSIZE - 1) {
+		if (x < DAHDI_CHUNKSIZE - 1) {
 			writechunk[EFRAME_SIZE] = wc->ctlreg;
 			writechunk[EFRAME_SIZE + 1] = wc->txident++;
 		}
@@ -1509,13 +1509,13 @@ static inline void t1_receiveprep(struct t1 *wc, unsigned char* readchunk)
 	int x,chan;
 	unsigned char expected;
 
-	for (x = 0; x < ZT_CHUNKSIZE; x++) {
+	for (x = 0; x < DAHDI_CHUNKSIZE; x++) {
 		if (likely(wc->initialized)) {
 			for (chan = 0; chan < wc->span.channels; chan++) {
 				wc->chans[chan].readchunk[x]= readchunk[(chan+1)*2];
 			}
 		}
-		if (x < ZT_CHUNKSIZE - 1) {
+		if (x < DAHDI_CHUNKSIZE - 1) {
 			expected = wc->rxident+1;
 			wc->rxident = readchunk[EFRAME_SIZE + 1];
 			wc->statreg = readchunk[EFRAME_SIZE + 2];
@@ -1538,11 +1538,11 @@ static inline void t1_receiveprep(struct t1 *wc, unsigned char* readchunk)
 	if (likely(wc->initialized)) {
 		spin_unlock(&wc->reglock);
 		for (x = 0; x < wc->span.channels; x++) {
-			zt_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, wc->ec_chunk2[x]);
-			memcpy(wc->ec_chunk2[x],wc->ec_chunk1[x],ZT_CHUNKSIZE);
-			memcpy(wc->ec_chunk1[x],wc->chans[x].writechunk,ZT_CHUNKSIZE);
+			dahdi_ec_chunk(&wc->chans[x], wc->chans[x].readchunk, wc->ec_chunk2[x]);
+			memcpy(wc->ec_chunk2[x],wc->ec_chunk1[x],DAHDI_CHUNKSIZE);
+			memcpy(wc->ec_chunk1[x],wc->chans[x].writechunk,DAHDI_CHUNKSIZE);
 		}
-		zt_receive(&wc->span);
+		dahdi_receive(&wc->span);
 		spin_lock(&wc->reglock);
 	}
 
@@ -1637,7 +1637,7 @@ retry:
 		printk(KERN_NOTICE "%s: Restarting board initialization " \
 		 "after increasing latency.\n", wc->name);
 		latency = voicebus_current_latency(wc->vb);
-		zt_unregister(&wc->span);
+		dahdi_unregister(&wc->span);
 		voicebus_release(wc->vb);
 		wc->vb = NULL;
 		kfree(wc);
diff --git a/drivers/dahdi/wcte12xp/vpmadt032.c b/drivers/dahdi/wcte12xp/vpmadt032.c
index b22d322..835cdb5 100644
--- a/drivers/dahdi/wcte12xp/vpmadt032.c
+++ b/drivers/dahdi/wcte12xp/vpmadt032.c
@@ -508,7 +508,7 @@ static void vpm150m_echocan_bh(struct work_struct *data)
 
 	list_for_each_safe(task, next_task, &vpm150m->worklist) {
 		struct vpm150m_workentry *we = list_entry(task, struct vpm150m_workentry, list);
-		struct zt_chan *chan = we->chan;
+		struct dahdi_chan *chan = we->chan;
 		int deflaw;
 		int res;
 		GPAK_AlgControlStat_t pstatus;
@@ -649,7 +649,7 @@ static void vpm150m_dtmf_bh(struct work_struct *data)
 				debug_printk(1, "Channel %d: Detected DTMF tone %d of duration %d\n", channel + 1, tone, duration);
 
 				if (test_bit(channel, &wc->dtmfmask) && (eventdata.toneEvent.ToneDuration > 0)) {
-					struct zt_chan *chan = &wc->chans[channel];
+					struct dahdi_chan *chan = &wc->chans[channel];
 
 					module_printk("DTMF detected channel=%d tone=%d duration=%d\n", channel + 1, tone, duration);
 
@@ -664,18 +664,18 @@ static void vpm150m_dtmf_bh(struct work_struct *data)
 							spin_lock_irqsave(&chan->lock, flags);
 							for (y = 0; y < chan->numbufs; y++) {
 								if ((chan->inreadbuf > -1) && (chan->readidx[y]))
-									memset(chan->readbuf[chan->inreadbuf], ZT_XLAW(0, chan), chan->readidx[y]);
+									memset(chan->readbuf[chan->inreadbuf], DAHDI_XLAW(0, chan), chan->readidx[y]);
 							}
 							spin_unlock_irqrestore(&chan->lock, flags);
 						}
 						if (!test_bit(channel, &wc->dtmfactive)) {
 							debug_printk(1,"Queuing DTMFDOWN %c\n", zaptone);
 							set_bit(channel, &wc->dtmfactive);
-							zt_qevent_lock(chan, (ZT_EVENT_DTMFDOWN | zaptone));
+							dahdi_qevent_lock(chan, (DAHDI_EVENT_DTMFDOWN | zaptone));
 						}
 					} else if ((tone == EndofMFDigit) && test_bit(channel, &wc->dtmfactive)) {
 						debug_printk(1,"Queuing DTMFUP %c\n", vpm150mtone_to_zaptone(vpm150m->curtone[channel]));
-						zt_qevent_lock(chan, (ZT_EVENT_DTMFUP | vpm150mtone_to_zaptone(vpm150m->curtone[channel])));
+						dahdi_qevent_lock(chan, (DAHDI_EVENT_DTMFUP | vpm150mtone_to_zaptone(vpm150m->curtone[channel])));
 						clear_bit(channel, &wc->dtmfactive);
 					}
 				}
diff --git a/drivers/dahdi/wcte12xp/vpmadt032.h b/drivers/dahdi/wcte12xp/vpmadt032.h
index e103e05..117b22e 100644
--- a/drivers/dahdi/wcte12xp/vpmadt032.h
+++ b/drivers/dahdi/wcte12xp/vpmadt032.h
@@ -105,7 +105,7 @@ struct vpm150m {
 struct vpm150m_workentry {
 	struct list_head list;
 	struct t1 *wc; /* what card are we dealing with? */
-	struct zt_chan *chan; /* what channels are we going to deal with? */
+	struct dahdi_chan *chan; /* what channels are we going to deal with? */
 	struct adt_lec_params params; /* how should we behave? */
 };
 
diff --git a/drivers/dahdi/wcte12xp/wcte12xp.h b/drivers/dahdi/wcte12xp/wcte12xp.h
index aa6306b..4de98d6 100644
--- a/drivers/dahdi/wcte12xp/wcte12xp.h
+++ b/drivers/dahdi/wcte12xp/wcte12xp.h
@@ -50,7 +50,7 @@
 #define EFRAME_SIZE	108
 #define ERING_SIZE	16		/* Maximum ring size */
 #define EFRAME_GAP	20
-#define SFRAME_SIZE	((EFRAME_SIZE * ZT_CHUNKSIZE) + (EFRAME_GAP * (ZT_CHUNKSIZE - 1)))
+#define SFRAME_SIZE	((EFRAME_SIZE * DAHDI_CHUNKSIZE) + (EFRAME_GAP * (DAHDI_CHUNKSIZE - 1)))
 
 #define PCI_WINDOW_SIZE ((2 * 2 * 2 * SFRAME_SIZE) + (2 * ERING_SIZE * 4))
 
@@ -139,10 +139,10 @@ struct t1 {
 	int initialized;
 	int *chanmap;
 	unsigned char ledtestreg;
-	unsigned char ec_chunk1[32][ZT_CHUNKSIZE];
-	unsigned char ec_chunk2[32][ZT_CHUNKSIZE];
-	struct zt_span span;						/* Span */
-	struct zt_chan chans[32];					/* Channels */
+	unsigned char ec_chunk1[32][DAHDI_CHUNKSIZE];
+	unsigned char ec_chunk2[32][DAHDI_CHUNKSIZE];
+	struct dahdi_span span;						/* Span */
+	struct dahdi_chan chans[32];					/* Channels */
 	wait_queue_head_t regq;
 	struct cmdq	cmdq;
 	struct command dummy;	/* preallocate for dummy noop command */
diff --git a/include/dahdi/kernel.h b/include/dahdi/kernel.h
index 7d3d793..4993c74 100644
--- a/include/dahdi/kernel.h
+++ b/include/dahdi/kernel.h
@@ -97,96 +97,96 @@
 #endif
 
 /* Per-span configuration values */
-#define	ZT_CONFIG_TXLEVEL	7	/* bits 0-2 are tx level */
+#define	DAHDI_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)
+#define DAHDI_CONFIG_D4	 (1 << 4)	
+#define DAHDI_CONFIG_ESF	 (1 << 5)
+#define DAHDI_CONFIG_AMI	 (1 << 6)
+#define DAHDI_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)
+#define	DAHDI_CONFIG_CCS	 (1 << 8)	/* CCS (ISDN) instead of CAS (Robbed Bit) */
+#define	DAHDI_CONFIG_HDB3	 (1 << 9)	/* HDB3 instead of AMI (line coding) */
+#define	DAHDI_CONFIG_CRC4   (1 << 10)	/* CRC4 framing */
+#define DAHDI_CONFIG_NOTOPEN (1 << 16)
 
 /* Signalling types */
-#define ZT_SIG_BROKEN	(1 << 31)	/* The port is broken and/or failed initialization */
+#define DAHDI_SIG_BROKEN	(1 << 31)	/* The port is broken and/or failed initialization */
 
-#define __ZT_SIG_FXO	(1 << 12)	/* Never use directly */
-#define __ZT_SIG_FXS	(1 << 13)	/* Never use directly */
+#define __DAHDI_SIG_FXO	(1 << 12)	/* Never use directly */
+#define __DAHDI_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 DAHDI_SIG_NONE		(0)			/* Channel not configured */
+#define DAHDI_SIG_FXSLS	((1 << 0) | __DAHDI_SIG_FXS)	/* FXS, Loopstart */
+#define DAHDI_SIG_FXSGS	((1 << 1) | __DAHDI_SIG_FXS)	/* FXS, Groundstart */
+#define DAHDI_SIG_FXSKS	((1 << 2) | __DAHDI_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 DAHDI_SIG_FXOLS	((1 << 3) | __DAHDI_SIG_FXO)	/* FXO, Loopstart */
+#define DAHDI_SIG_FXOGS	((1 << 4) | __DAHDI_SIG_FXO)	/* FXO, Groupstart */
+#define DAHDI_SIG_FXOKS	((1 << 5) | __DAHDI_SIG_FXO)	/* FXO, Kewlstart */
 
-#define ZT_SIG_EM	(1 << 6)		/* Ear & Mouth (E&M) */
+#define DAHDI_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 */
-#define ZT_SIG_HARDHDLC	((1 << 19) | ZT_SIG_CLEAR)
-#define ZT_SIG_MTP2	((1 << 20) | ZT_SIG_HDLCFCS)	/* MTP2 support  Need HDLC bitstuff and FCS calcuation too */
+#define __DAHDI_SIG_DACS	(1 << 16)
+
+#define DAHDI_SIG_CLEAR	(1 << 7)					/* Clear channel */
+#define DAHDI_SIG_HDLCRAW	((1 << 8)  | DAHDI_SIG_CLEAR)	/* Raw unchecked HDLC */
+#define DAHDI_SIG_HDLCFCS	((1 << 9)  | DAHDI_SIG_HDLCRAW)	/* HDLC with FCS calculation */
+#define DAHDI_SIG_HDLCNET	((1 << 10) | DAHDI_SIG_HDLCFCS)	/* HDLC Network */
+#define DAHDI_SIG_SLAVE	(1 << 11) 					/* Slave to another channel */
+#define	DAHDI_SIG_SF	(1 << 14)			/* Single Freq. tone only, no sig bits */
+#define DAHDI_SIG_CAS	(1 << 15)			/* Just get bits */
+#define DAHDI_SIG_DACS	(__DAHDI_SIG_DACS | DAHDI_SIG_CLEAR)	/* Cross connect */
+#define DAHDI_SIG_EM_E1	(1 << 17)			/* E1 E&M Variation */
+#define DAHDI_SIG_DACS_RBS	((1 << 18) | __DAHDI_SIG_DACS)	/* Cross connect w/ RBS */
+#define DAHDI_SIG_HARDHDLC	((1 << 19) | DAHDI_SIG_CLEAR)
+#define DAHDI_SIG_MTP2	((1 << 20) | DAHDI_SIG_HDLCFCS)	/* MTP2 support  Need HDLC bitstuff and FCS calcuation too */
 
 /* tone flag values */
-#define	ZT_REVERSE_RXTONE 1  /* reverse polarity rx tone logic */
-#define	ZT_REVERSE_TXTONE 2  /* reverse polarity tx tone logic */
+#define	DAHDI_REVERSE_RXTONE 1  /* reverse polarity rx tone logic */
+#define	DAHDI_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 DAHDI_ABIT			8
+#define DAHDI_BBIT			4
+#define	DAHDI_CBIT			2
+#define	DAHDI_DBIT			1
 
-#define ZT_MAJOR	196
+#define DAHDI_MAJOR	196
 
-#define ZT_CODE	'J'
+#define DAHDI_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 DAHDI_CHUNKSIZE		 8
+#define DAHDI_MIN_CHUNKSIZE	 DAHDI_CHUNKSIZE
+#define DAHDI_DEFAULT_CHUNKSIZE	 DAHDI_CHUNKSIZE
+#define DAHDI_MAX_CHUNKSIZE 	 DAHDI_CHUNKSIZE
+#define DAHDI_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 DAHDI_MAX_BLOCKSIZE 	 8192
+#define DAHDI_DEFAULT_NUM_BUFS	 2
+#define DAHDI_MAX_NUM_BUFS		 32
+#define DAHDI_MAX_BUF_SPACE         32768
 
-#define ZT_DEFAULT_BLOCKSIZE 1024
-#define ZT_DEFAULT_MTR_MRU	 2048
+#define DAHDI_DEFAULT_BLOCKSIZE 1024
+#define DAHDI_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 DAHDI_POLICY_IMMEDIATE	 0		/* Start play/record immediately */
+#define DAHDI_POLICY_WHEN_FULL  1		/* Start play/record when buffer is full */
 
 #define	RING_DEBOUNCE_TIME	2000	/* 2000 ms ring debounce time */
 
-#define ZT_GET_PARAMS_RETURN_MASTER 0x40000000
+#define DAHDI_GET_PARAMS_RETURN_MASTER 0x40000000
 
 /* Extended attributes in lineconfig structure */
-#define ZT_SPANINFO_HAS_LINECONFIG
-#define ZT_SPANINFO_HAS_LBONAME
+#define DAHDI_SPANINFO_HAS_LINECONFIG
+#define DAHDI_SPANINFO_HAS_LBONAME
 
-struct zt_params_v1
+struct dahdi_params_v1
 {
 	int channo;		/* Channel number */
 	int spanno;		/* Span itself */
@@ -198,7 +198,7 @@ struct zt_params_v1
 	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 curlaw;		/* read-only  -- one of DAHDI_LAW_MULAW or DAHDI_LAW_ALAW */
 	int idlebits;		/* read-only  -- What is considered the idle state */
 	char name[40];		/* Name of channel */
 	int prewinktime;
@@ -214,7 +214,7 @@ struct zt_params_v1
 	int pulseaftertime;
 };
 
-typedef struct zt_params
+typedef struct dahdi_params
 {
 	int channo;		/* Channel number */
 	int spanno;		/* Span itself */
@@ -226,7 +226,7 @@ typedef struct zt_params
 	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 curlaw;		/* read-only  -- one of DAHDI_LAW_MULAW or DAHDI_LAW_ALAW */
 	int idlebits;		/* read-only  -- What is considered the idle state */
 	char name[40];		/* Name of channel */
 	int prewinktime;
@@ -241,9 +241,9 @@ typedef struct zt_params
 	int pulsemaketime;
 	int pulseaftertime;
 	__u32 chan_alarms;	/* alarms on this channel */
-} ZT_PARAMS;
+} DAHDI_PARAMS;
 
-struct zt_spaninfo_v1 {
+struct dahdi_spaninfo_v1 {
 	int	spanno;		/* span number */
 	char	name[20];	/* Name */
 	char	desc[40];	/* Description */
@@ -261,7 +261,7 @@ struct zt_spaninfo_v1 {
 	int	totaflspans;	/* total number of spans in entire system */
 };
 
-struct zt_spaninfo_v2 {
+struct dahdi_spaninfo_v2 {
 	int	spanno;		/* span number */
 	char	name[20];	/* Name */
 	char	desc[40];	/* Description */
@@ -281,7 +281,7 @@ struct zt_spaninfo_v2 {
 	int	lineconfig;	 /* framing/coding */
 };
 
-typedef struct zt_spaninfo {
+typedef struct dahdi_spaninfo {
 	int	spanno;		/* span number */
 	char	name[20];	/* Name */
 	char	desc[40];	/* Description */
@@ -306,50 +306,50 @@ typedef struct zt_spaninfo {
 	int	irq;		/* span's device IRQ */
 	int	linecompat;	/* signaling modes possible on this span */
 	char	spantype[6];	/* type of span in text form */
-} ZT_SPANINFO;
+} DAHDI_SPANINFO;
 
-typedef struct zt_maintinfo
+typedef struct dahdi_maintinfo
 {
 int	spanno;		/* span number 1-2 */
 int	command;	/* command */
-} ZT_MAINTINFO;
+} DAHDI_MAINTINFO;
 
-typedef struct zt_confinfo
+typedef struct dahdi_confinfo
 {
 int	chan;		/* channel number, 0 for current */
 int	confno;		/* conference number */
 int	confmode;	/* conferencing mode */
-} ZT_CONFINFO;
+} DAHDI_CONFINFO;
 
-typedef struct zt_gains
+typedef struct dahdi_gains
 {
 int	chan;		/* channel number, 0 for current */
 unsigned char rxgain[256];	/* Receive gain table */
 unsigned char txgain[256];	/* Transmit gain table */
-} ZT_GAINS;
+} DAHDI_GAINS;
 
-typedef struct zt_lineconfig
+typedef struct dahdi_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;
+} DAHDI_LINECONFIG;
 
-typedef struct zt_chanconfig
+typedef struct dahdi_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	deflaw;		/* Default law (DAHDI_LAW_DEFAULT, DAHDI_LAW_MULAW, or DAHDI_LAW_ALAW */
+int	master;		/* Master channel if sigtype is DAHDI_SLAVE */
 int	idlebits;	/* Idle bits (if this is a CAS channel) or
 			   channel to monitor (if this is DACS channel) */
 char netdev_name[16]; /*name for the hdlc network device*/
-} ZT_CHANCONFIG;
+} DAHDI_CHANCONFIG;
 
-typedef struct zt_sfconfig
+typedef struct dahdi_sfconfig
 {
 int	chan;		/* Channel we're applying this to (0 to use name) */
 char	name[40];	/* Name of channel to use */
@@ -360,9 +360,9 @@ int	txtone;		/* Tx tone factor */
 int	tx_v2;		/* initial v2 value */
 int	tx_v3;		/* initial v3 value */
 int	toneflag;	/* Tone flags */
-} ZT_SFCONFIG;
+} DAHDI_SFCONFIG;
 
-typedef struct zt_bufferinfo
+typedef struct dahdi_bufferinfo
 {
 int txbufpolicy;	/* Policy for handling receive buffers */
 int rxbufpolicy;	/* Policy for handling receive buffers */
@@ -370,225 +370,225 @@ 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;
+} DAHDI_BUFFERINFO;
 
-typedef struct zt_dialparams {
+typedef struct dahdi_dialparams {
 	int mfv1_tonelen;	/* MF R1 tone length for digits */
 	int dtmf_tonelen;	/* DTMF tone length */
 	int mfr2_tonelen;	/* MF R2 tone length */
 	int reserved[3];	/* Reserved for future expansion -- always set to 0 */
-} ZT_DIAL_PARAMS;
+} DAHDI_DIAL_PARAMS;
 
-typedef struct zt_dynamic_span {
+typedef struct dahdi_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;
+} DAHDI_DYNAMIC_SPAN;
 
 /* Define the max # of outgoing DTMF, MFR1 or MFR2 digits to queue in-kernel */
-#define ZT_MAX_DTMF_BUF 256
+#define DAHDI_MAX_DTMF_BUF 256
 
-#define ZT_DIAL_OP_APPEND	1
-#define ZT_DIAL_OP_REPLACE	2
-#define ZT_DIAL_OP_CANCEL	3
+#define DAHDI_DIAL_OP_APPEND	1
+#define DAHDI_DIAL_OP_REPLACE	2
+#define DAHDI_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 */
+#define DAHDI_LAW_DEFAULT	0	/* Default law for span */
+#define DAHDI_LAW_MULAW	1	/* Mu-law */
+#define DAHDI_LAW_ALAW	2	/* A-law */
 
-typedef struct zt_dialoperation {
+typedef struct dahdi_dialoperation {
 	int op;
-	char dialstr[ZT_MAX_DTMF_BUF];
-} ZT_DIAL_OPERATION;
+	char dialstr[DAHDI_MAX_DTMF_BUF];
+} DAHDI_DIAL_OPERATION;
 
 
-typedef struct zt_indirect_data
+typedef struct dahdi_indirect_data
 {
 int	chan;
 int	op;
 void	*data;
-} ZT_INDIRECT_DATA;	
+} DAHDI_INDIRECT_DATA;	
 
-struct zt_versioninfo {
+struct dahdi_versioninfo {
 	char version[80];
 	char echo_canceller[80];
 };
 
-struct zt_hwgain{
+struct dahdi_hwgain{
 	__s32 newgain;	/* desired gain in dB but x10.  -3.5dB would be -35 */
 	__u32 tx:1;	/* 0=rx; 1=tx */
 };
 
 
 /* ioctl definitions */
-#define ZT_CODE	'J'
+#define DAHDI_CODE	'J'
 
 /*
  * Get Transfer Block Size.
  */
-#define ZT_GET_BLOCKSIZE	_IOR (ZT_CODE, 1, int)
+#define DAHDI_GET_BLOCKSIZE	_IOR (DAHDI_CODE, 1, int)
 
 /*
  * Set Transfer Block Size.
  */
-#define ZT_SET_BLOCKSIZE	_IOW (ZT_CODE, 2, int)
+#define DAHDI_SET_BLOCKSIZE	_IOW (DAHDI_CODE, 2, int)
 
 /*
  * Flush Buffer(s) and stop I/O
  */
-#define	ZT_FLUSH		_IOW (ZT_CODE, 3, int)
+#define	DAHDI_FLUSH		_IOW (DAHDI_CODE, 3, int)
 
 /*
  * Wait for Write to Finish
  */
-#define	ZT_SYNC		_IOW (ZT_CODE, 4, int)
+#define	DAHDI_SYNC		_IOW (DAHDI_CODE, 4, int)
 
 /*
  * Get channel parameters
  */
-#define ZT_GET_PARAMS_V1	_IOR (ZT_CODE, 5, struct zt_params_v1)
-#define ZT_GET_PARAMS		_IOR (ZT_CODE, 5, struct zt_params)
+#define DAHDI_GET_PARAMS_V1	_IOR (DAHDI_CODE, 5, struct dahdi_params_v1)
+#define DAHDI_GET_PARAMS		_IOR (DAHDI_CODE, 5, struct dahdi_params)
 
 /*
  * Get channel parameters
  */
-#define ZT_SET_PARAMS_V1	_IOW (ZT_CODE, 6, struct zt_params_v1)
-#define ZT_SET_PARAMS		_IOW (ZT_CODE, 6, struct zt_params)
+#define DAHDI_SET_PARAMS_V1	_IOW (DAHDI_CODE, 6, struct dahdi_params_v1)
+#define DAHDI_SET_PARAMS		_IOW (DAHDI_CODE, 6, struct dahdi_params)
 
 /*
  * Set Hookswitch Status
  */
-#define ZT_HOOK		_IOW (ZT_CODE, 7, int)
+#define DAHDI_HOOK		_IOW (DAHDI_CODE, 7, int)
 
 /*
  * Get Signalling Event
  */
-#define ZT_GETEVENT		_IOR (ZT_CODE, 8, int)
+#define DAHDI_GETEVENT		_IOR (DAHDI_CODE, 8, int)
 
 /*
  * Wait for something to happen (IO Mux)
  */
-#define ZT_IOMUX		_IOWR (ZT_CODE, 9, int)
+#define DAHDI_IOMUX		_IOWR (DAHDI_CODE, 9, int)
 
 /*
  * Get Span Status
  */
-#define ZT_SPANSTAT_V1		_IOWR (ZT_CODE, 10, struct zt_spaninfo_v1)
-#define ZT_SPANSTAT_V2		_IOWR (ZT_CODE, 10, struct zt_spaninfo_v2)
-#define ZT_SPANSTAT		_IOWR (ZT_CODE, 10, struct zt_spaninfo)
+#define DAHDI_SPANSTAT_V1		_IOWR (DAHDI_CODE, 10, struct dahdi_spaninfo_v1)
+#define DAHDI_SPANSTAT_V2		_IOWR (DAHDI_CODE, 10, struct dahdi_spaninfo_v2)
+#define DAHDI_SPANSTAT		_IOWR (DAHDI_CODE, 10, struct dahdi_spaninfo)
 
 /*
  * Set Maintenance Mode
  */
-#define ZT_MAINT		_IOW (ZT_CODE, 11, struct zt_maintinfo)
+#define DAHDI_MAINT		_IOW (DAHDI_CODE, 11, struct dahdi_maintinfo)
 
 /*
  * Get Conference Mode
  */
-#define ZT_GETCONF		_IOWR (ZT_CODE, 12, struct zt_confinfo)
+#define DAHDI_GETCONF		_IOWR (DAHDI_CODE, 12, struct dahdi_confinfo)
 
 /*
  * Set Conference Mode
  */
-#define ZT_SETCONF		_IOWR (ZT_CODE, 13, struct zt_confinfo)
+#define DAHDI_SETCONF		_IOWR (DAHDI_CODE, 13, struct dahdi_confinfo)
 
 /*
  * Setup or Remove Conference Link
  */
-#define ZT_CONFLINK		_IOW (ZT_CODE, 14, struct zt_confinfo)
+#define DAHDI_CONFLINK		_IOW (DAHDI_CODE, 14, struct dahdi_confinfo)
 
 /*
  * Display Conference Diagnostic Information on Console
  */
-#define ZT_CONFDIAG		_IOR (ZT_CODE, 15, int)
+#define DAHDI_CONFDIAG		_IOR (DAHDI_CODE, 15, int)
 
 /*
  * Get Channel audio gains
  */
-#define ZT_GETGAINS		_IOWR (ZT_CODE, 16, struct zt_gains)
+#define DAHDI_GETGAINS		_IOWR (DAHDI_CODE, 16, struct dahdi_gains)
 
 /*
  * Set Channel audio gains
  */
-#define ZT_SETGAINS		_IOWR (ZT_CODE, 17, struct zt_gains)
+#define DAHDI_SETGAINS		_IOWR (DAHDI_CODE, 17, struct dahdi_gains)
 
 /*
  * Set Line (T1) Configurations and start system
  */
-#define	ZT_SPANCONFIG		_IOW (ZT_CODE, 18, struct zt_lineconfig)
+#define	DAHDI_SPANCONFIG		_IOW (DAHDI_CODE, 18, struct dahdi_lineconfig)
 
 /*
  * Set Channel Configuration
  */
-#define	ZT_CHANCONFIG		_IOW (ZT_CODE, 19, struct zt_chanconfig)
+#define	DAHDI_CHANCONFIG		_IOW (DAHDI_CODE, 19, struct dahdi_chanconfig)
 
 /*
  * Set Conference to mute mode
  */
-#define	ZT_CONFMUTE		_IOW (ZT_CODE, 20, int)
+#define	DAHDI_CONFMUTE		_IOW (DAHDI_CODE, 20, int)
 
 /*
- * Send a particular tone (see ZT_TONE_*)
+ * Send a particular tone (see DAHDI_TONE_*)
  */
-#define	ZT_SENDTONE		_IOW (ZT_CODE, 21, int)
+#define	DAHDI_SENDTONE		_IOW (DAHDI_CODE, 21, int)
 
 /*
- * Set your region for tones (see ZT_TONE_ZONE_*)
+ * Set your region for tones (see DAHDI_TONE_ZONE_*)
  */
-#define	ZT_SETTONEZONE		_IOW (ZT_CODE, 22, int)
+#define	DAHDI_SETTONEZONE		_IOW (DAHDI_CODE, 22, int)
 
 /*
- * Retrieve current region for tones (see ZT_TONE_ZONE_*)
+ * Retrieve current region for tones (see DAHDI_TONE_ZONE_*)
  */
-#define	ZT_GETTONEZONE		_IOR (ZT_CODE, 23, int)
+#define	DAHDI_GETTONEZONE		_IOR (DAHDI_CODE, 23, int)
 
 /*
- * Master unit only -- set default zone (see ZT_TONE_ZONE_*)
+ * Master unit only -- set default zone (see DAHDI_TONE_ZONE_*)
  */
-#define	ZT_DEFAULTZONE		_IOW (ZT_CODE, 24, int)
+#define	DAHDI_DEFAULTZONE		_IOW (DAHDI_CODE, 24, int)
 
 /*
- * Load a tone zone from a zt_tone_def_header, see
+ * Load a tone zone from a dahdi_tone_def_header, see
  * below...
  */
-#define ZT_LOADZONE		_IOW (ZT_CODE, 25, struct zt_tone_def_header)
+#define DAHDI_LOADZONE		_IOW (DAHDI_CODE, 25, struct dahdi_tone_def_header)
 
 /*
  * Free a tone zone 
  */
-#define ZT_FREEZONE		_IOW (ZT_CODE, 26, int)
+#define DAHDI_FREEZONE		_IOW (DAHDI_CODE, 26, int)
 
 /*
  * Set buffer policy 
  */
-#define ZT_SET_BUFINFO		_IOW (ZT_CODE, 27, struct zt_bufferinfo)
+#define DAHDI_SET_BUFINFO		_IOW (DAHDI_CODE, 27, struct dahdi_bufferinfo)
 
 /*
  * Get current buffer info
  */
-#define ZT_GET_BUFINFO		_IOR (ZT_CODE, 28, struct zt_bufferinfo)
+#define DAHDI_GET_BUFINFO		_IOR (DAHDI_CODE, 28, struct dahdi_bufferinfo)
 
 /*
  * Get dialing parameters
  */
-#define ZT_GET_DIALPARAMS	_IOR (ZT_CODE, 29, struct zt_dialparams)
+#define DAHDI_GET_DIALPARAMS	_IOR (DAHDI_CODE, 29, struct dahdi_dialparams)
 
 /*
  * Set dialing parameters
  */
-#define ZT_SET_DIALPARAMS	_IOW (ZT_CODE, 30, struct zt_dialparams)
+#define DAHDI_SET_DIALPARAMS	_IOW (DAHDI_CODE, 30, struct dahdi_dialparams)
 
 /*
  * Append, replace, or cancel a dial string
  */
-#define ZT_DIAL			_IOW (ZT_CODE, 31, struct zt_dialoperation)
+#define DAHDI_DIAL			_IOW (DAHDI_CODE, 31, struct dahdi_dialoperation)
 
 /*
  * Set a clear channel into audio mode
  */
-#define ZT_AUDIOMODE		_IOW (ZT_CODE, 32, int)
+#define DAHDI_AUDIOMODE		_IOW (DAHDI_CODE, 32, int)
 
 /*
  * Enable or disable echo cancellation on a channel 
@@ -602,18 +602,18 @@ struct zt_hwgain{
  * The structure contains parameters that should be passed to the
  * echo canceler instance for the selected channel.
  */
-#define ZT_ECHOCANCEL		_IOW (ZT_CODE, 33, int)
-#define ZT_ECHOCANCEL_PARAMS	_IOW (ZT_CODE, 33, struct zt_echocanparams)
+#define DAHDI_ECHOCANCEL		_IOW (DAHDI_CODE, 33, int)
+#define DAHDI_ECHOCANCEL_PARAMS	_IOW (DAHDI_CODE, 33, struct dahdi_echocanparams)
 
 /*
  * Return a channel's channel number (useful for the /dev/zap/pseudo type interfaces 
  */
-#define ZT_CHANNO		_IOR (ZT_CODE, 34, int)
+#define DAHDI_CHANNO		_IOR (DAHDI_CODE, 34, int)
 
 /*
  * Return a flag indicating whether channel is currently dialing
  */
-#define ZT_DIALING		_IOR (ZT_CODE, 35, int)
+#define DAHDI_DIALING		_IOR (DAHDI_CODE, 35, int)
 
 /* Numbers 60 to 90 are reserved for private use of low level hardware
    drivers */
@@ -621,120 +621,120 @@ struct zt_hwgain{
 /*
  * Set a clear channel into HDLC w/out FCS checking/calculation mode
  */
-#define ZT_HDLCRAWMODE		_IOW (ZT_CODE, 36, int)
+#define DAHDI_HDLCRAWMODE		_IOW (DAHDI_CODE, 36, int)
 
 /*
  * Set a clear channel into HDLC w/ FCS mode
  */
-#define ZT_HDLCFCSMODE		_IOW (ZT_CODE, 37, int)
+#define DAHDI_HDLCFCSMODE		_IOW (DAHDI_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)
+#define DAHDI_SPECIFY		_IOW (DAHDI_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.  
+ * DAHDI_LAW_DEFAULT, DAHDI_LAW_ALAW, or DAHDI_LAW_MULAW.  Is reset on close.  
  */
-#define ZT_SETLAW		_IOW (ZT_CODE, 39, int)
+#define DAHDI_SETLAW		_IOW (DAHDI_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)
+#define DAHDI_SETLINEAR		_IOW (DAHDI_CODE, 40, int)
 
 /*
  * Set a clear channel into HDLC w/ PPP interface mode
  */
-#define ZT_HDLCPPP		_IOW (ZT_CODE, 41, int)
+#define DAHDI_HDLCPPP		_IOW (DAHDI_CODE, 41, int)
 
 /*
  * Set the ring cadence for FXS interfaces
  */
-#define ZT_SETCADENCE		_IOW (ZT_CODE, 42, struct zt_ring_cadence)
+#define DAHDI_SETCADENCE		_IOW (DAHDI_CODE, 42, struct dahdi_ring_cadence)
 
 /*
  * Set the bits going out for CAS interface
  */
-#define ZT_SETTXBITS			_IOW (ZT_CODE, 43, int)
+#define DAHDI_SETTXBITS			_IOW (DAHDI_CODE, 43, int)
 
 
 /*
  * Display Channel Diagnostic Information on Console
  */
-#define ZT_CHANDIAG		_IOR (ZT_CODE, 44, int) 
+#define DAHDI_CHANDIAG		_IOR (DAHDI_CODE, 44, int) 
 
 /* 
  * Obtain received signalling
  */
-#define ZT_GETRXBITS _IOR (ZT_CODE, 45, int)
+#define DAHDI_GETRXBITS _IOR (DAHDI_CODE, 45, int)
 
 /*
  * Set Channel's SF Tone Configuration
  */
-#define	ZT_SFCONFIG		_IOW (ZT_CODE, 46, struct zt_sfconfig)
+#define	DAHDI_SFCONFIG		_IOW (DAHDI_CODE, 46, struct dahdi_sfconfig)
 
 /*
  * Set timer expiration (in samples)
  */
-#define ZT_TIMERCONFIG	_IOW (ZT_CODE, 47, int)
+#define DAHDI_TIMERCONFIG	_IOW (DAHDI_CODE, 47, int)
 
 /*
  * Acknowledge timer expiration (number to acknowledge, or -1 for all)
  */
-#define ZT_TIMERACK _IOW (ZT_CODE, 48, int)
+#define DAHDI_TIMERACK _IOW (DAHDI_CODE, 48, int)
 
 /*
  * Get Conference to mute mode
  */
-#define	ZT_GETCONFMUTE		_IOR (ZT_CODE, 49, int)
+#define	DAHDI_GETCONFMUTE		_IOR (DAHDI_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)
+#define	DAHDI_ECHOTRAIN		_IOW (DAHDI_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)
+#define	DAHDI_ONHOOKTRANSFER		_IOW (DAHDI_CODE, 51, int)
 
 /*
  * Queue Ping
  */
-#define ZT_TIMERPING _IOW (ZT_CODE, 42, int) /* Should be 52, but works */
+#define DAHDI_TIMERPING _IOW (DAHDI_CODE, 42, int) /* Should be 52, but works */
 
 /*
  * Acknowledge ping
  */
-#define ZT_TIMERPONG _IOW (ZT_CODE, 53, int)
+#define DAHDI_TIMERPONG _IOW (DAHDI_CODE, 53, int)
 
 /*
  * Set/get signalling freeze
  */
-#define ZT_SIGFREEZE _IOW (ZT_CODE, 54, int)
-#define ZT_GETSIGFREEZE _IOR (ZT_CODE, 55, int)
+#define DAHDI_SIGFREEZE _IOW (DAHDI_CODE, 54, int)
+#define DAHDI_GETSIGFREEZE _IOR (DAHDI_CODE, 55, int)
 
 /*
  * Do a channel IOCTL from the /dev/zap/ctl interface
  */
-#define ZT_INDIRECT _IOWR (ZT_CODE, 56, struct zt_indirect_data)
+#define DAHDI_INDIRECT _IOWR (DAHDI_CODE, 56, struct dahdi_indirect_data)
 
 
 /*
  * Get the version of Zaptel that is running, and a description
  * of the compiled-in echo canceller (if any)
  */
-#define ZT_GETVERSION _IOR(ZT_CODE, 57, struct zt_versioninfo)
+#define DAHDI_GETVERSION _IOR(DAHDI_CODE, 57, struct dahdi_versioninfo)
 
 /*
  * Put the channel in loopback mode (receive from the channel is
  * transmitted back on the interface)
  */
-#define ZT_LOOPBACK _IOW(ZT_CODE, 58, int)
+#define DAHDI_LOOPBACK _IOW(DAHDI_CODE, 58, int)
 
 
 /*
@@ -745,233 +745,233 @@ struct zt_hwgain{
 /*
  * Create a dynamic span
  */
-#define ZT_DYNAMIC_CREATE	_IOWR (ZT_CODE, 80, struct zt_dynamic_span)
+#define DAHDI_DYNAMIC_CREATE	_IOWR (DAHDI_CODE, 80, struct dahdi_dynamic_span)
 
 /* 
  * Destroy a dynamic span 
  */
-#define ZT_DYNAMIC_DESTROY	_IOW (ZT_CODE, 81, struct zt_dynamic_span)
+#define DAHDI_DYNAMIC_DESTROY	_IOW (DAHDI_CODE, 81, struct dahdi_dynamic_span)
 
 /*
  * Set the HW gain for a device
  */
-#define ZT_SET_HWGAIN		_IOW (ZT_CODE, 86, struct zt_hwgain)
+#define DAHDI_SET_HWGAIN		_IOW (DAHDI_CODE, 86, struct dahdi_hwgain)
 
 /*
  * Enable tone detection -- implemented by low level driver
  */
-#define ZT_TONEDETECT		_IOW (ZT_CODE, 91, int)
+#define DAHDI_TONEDETECT		_IOW (DAHDI_CODE, 91, int)
 
 /*
  * Set polarity -- implemented by individual driver.  0 = forward, 1 = reverse
  */
-#define	ZT_SETPOLARITY		_IOW (ZT_CODE, 92, int)
+#define	DAHDI_SETPOLARITY		_IOW (DAHDI_CODE, 92, int)
 
 /*
  * Transcoder operations
  */
-#define ZT_TRANSCODE_OP		_IOWR(ZT_CODE, 93, int)
+#define DAHDI_TRANSCODE_OP		_IOWR(DAHDI_CODE, 93, int)
 
 /*
  * VoiceMail Waiting Indication (WMWI) -- implemented by low-level driver.
  * Value: number of waiting messages (hence 0: switch messages off).
  */
-#define ZT_VMWI			_IOWR(ZT_CODE, 94, int)
+#define DAHDI_VMWI			_IOWR(DAHDI_CODE, 94, int)
 
 /* 
  * Startup or Shutdown a span
  */
-#define ZT_STARTUP		_IOW (ZT_CODE, 99, int)
-#define ZT_SHUTDOWN		_IOW (ZT_CODE, 100, int)
+#define DAHDI_STARTUP		_IOW (DAHDI_CODE, 99, int)
+#define DAHDI_SHUTDOWN		_IOW (DAHDI_CODE, 100, int)
 
-#define ZT_TONE_ZONE_MAX		128
+#define DAHDI_TONE_ZONE_MAX		128
 
-#define ZT_TONE_ZONE_DEFAULT 	-1	/* To restore default */
+#define DAHDI_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 DAHDI_TONE_STOP		-1
+#define DAHDI_TONE_DIALTONE	0
+#define DAHDI_TONE_BUSY		1
+#define DAHDI_TONE_RINGTONE	2
+#define DAHDI_TONE_CONGESTION	3
+#define DAHDI_TONE_CALLWAIT	4
+#define DAHDI_TONE_DIALRECALL	5
+#define DAHDI_TONE_RECORDTONE	6
+#define DAHDI_TONE_INFO		7
+#define DAHDI_TONE_CUST1		8
+#define DAHDI_TONE_CUST2		9
+#define DAHDI_TONE_STUTTER		10
+#define DAHDI_TONE_MAX		16
 
-#define ZT_TONE_DTMF_BASE	64
-#define ZT_TONE_MFR1_BASE	80
-#define ZT_TONE_MFR2_FWD_BASE	96
-#define ZT_TONE_MFR2_REV_BASE	112
+#define DAHDI_TONE_DTMF_BASE	64
+#define DAHDI_TONE_MFR1_BASE	80
+#define DAHDI_TONE_MFR2_FWD_BASE	96
+#define DAHDI_TONE_MFR2_REV_BASE	112
 
 enum {
-	ZT_TONE_DTMF_0 = ZT_TONE_DTMF_BASE,
-	ZT_TONE_DTMF_1,
-	ZT_TONE_DTMF_2,
-	ZT_TONE_DTMF_3,
-	ZT_TONE_DTMF_4,
-	ZT_TONE_DTMF_5,
-	ZT_TONE_DTMF_6,
-	ZT_TONE_DTMF_7,
-	ZT_TONE_DTMF_8,
-	ZT_TONE_DTMF_9,
-	ZT_TONE_DTMF_s,
-	ZT_TONE_DTMF_p,
-	ZT_TONE_DTMF_A,
-	ZT_TONE_DTMF_B,
-	ZT_TONE_DTMF_C,
-	ZT_TONE_DTMF_D
+	DAHDI_TONE_DTMF_0 = DAHDI_TONE_DTMF_BASE,
+	DAHDI_TONE_DTMF_1,
+	DAHDI_TONE_DTMF_2,
+	DAHDI_TONE_DTMF_3,
+	DAHDI_TONE_DTMF_4,
+	DAHDI_TONE_DTMF_5,
+	DAHDI_TONE_DTMF_6,
+	DAHDI_TONE_DTMF_7,
+	DAHDI_TONE_DTMF_8,
+	DAHDI_TONE_DTMF_9,
+	DAHDI_TONE_DTMF_s,
+	DAHDI_TONE_DTMF_p,
+	DAHDI_TONE_DTMF_A,
+	DAHDI_TONE_DTMF_B,
+	DAHDI_TONE_DTMF_C,
+	DAHDI_TONE_DTMF_D
 };
 
-#define ZT_TONE_DTMF_MAX ZT_TONE_DTMF_D
+#define DAHDI_TONE_DTMF_MAX DAHDI_TONE_DTMF_D
 
 enum {
-	ZT_TONE_MFR1_0 = ZT_TONE_MFR1_BASE,
-	ZT_TONE_MFR1_1,
-	ZT_TONE_MFR1_2,
-	ZT_TONE_MFR1_3,
-	ZT_TONE_MFR1_4,
-	ZT_TONE_MFR1_5,
-	ZT_TONE_MFR1_6,
-	ZT_TONE_MFR1_7,
-	ZT_TONE_MFR1_8,
-	ZT_TONE_MFR1_9,
-	ZT_TONE_MFR1_KP,
-	ZT_TONE_MFR1_ST,
-	ZT_TONE_MFR1_STP,
-	ZT_TONE_MFR1_ST2P,
-	ZT_TONE_MFR1_ST3P,
+	DAHDI_TONE_MFR1_0 = DAHDI_TONE_MFR1_BASE,
+	DAHDI_TONE_MFR1_1,
+	DAHDI_TONE_MFR1_2,
+	DAHDI_TONE_MFR1_3,
+	DAHDI_TONE_MFR1_4,
+	DAHDI_TONE_MFR1_5,
+	DAHDI_TONE_MFR1_6,
+	DAHDI_TONE_MFR1_7,
+	DAHDI_TONE_MFR1_8,
+	DAHDI_TONE_MFR1_9,
+	DAHDI_TONE_MFR1_KP,
+	DAHDI_TONE_MFR1_ST,
+	DAHDI_TONE_MFR1_STP,
+	DAHDI_TONE_MFR1_ST2P,
+	DAHDI_TONE_MFR1_ST3P,
 };
 
-#define ZT_TONE_MFR1_MAX ZT_TONE_MFR1_ST3P
+#define DAHDI_TONE_MFR1_MAX DAHDI_TONE_MFR1_ST3P
 
 enum {
-	ZT_TONE_MFR2_FWD_1 = ZT_TONE_MFR2_FWD_BASE,
-	ZT_TONE_MFR2_FWD_2,
-	ZT_TONE_MFR2_FWD_3,
-	ZT_TONE_MFR2_FWD_4,
-	ZT_TONE_MFR2_FWD_5,
-	ZT_TONE_MFR2_FWD_6,
-	ZT_TONE_MFR2_FWD_7,
-	ZT_TONE_MFR2_FWD_8,
-	ZT_TONE_MFR2_FWD_9,
-	ZT_TONE_MFR2_FWD_10,
-	ZT_TONE_MFR2_FWD_11,
-	ZT_TONE_MFR2_FWD_12,
-	ZT_TONE_MFR2_FWD_13,
-	ZT_TONE_MFR2_FWD_14,
-	ZT_TONE_MFR2_FWD_15,
+	DAHDI_TONE_MFR2_FWD_1 = DAHDI_TONE_MFR2_FWD_BASE,
+	DAHDI_TONE_MFR2_FWD_2,
+	DAHDI_TONE_MFR2_FWD_3,
+	DAHDI_TONE_MFR2_FWD_4,
+	DAHDI_TONE_MFR2_FWD_5,
+	DAHDI_TONE_MFR2_FWD_6,
+	DAHDI_TONE_MFR2_FWD_7,
+	DAHDI_TONE_MFR2_FWD_8,
+	DAHDI_TONE_MFR2_FWD_9,
+	DAHDI_TONE_MFR2_FWD_10,
+	DAHDI_TONE_MFR2_FWD_11,
+	DAHDI_TONE_MFR2_FWD_12,
+	DAHDI_TONE_MFR2_FWD_13,
+	DAHDI_TONE_MFR2_FWD_14,
+	DAHDI_TONE_MFR2_FWD_15,
 };
 
-#define ZT_TONE_MFR2_FWD_MAX ZT_TONE_MFR2_FWD_15
+#define DAHDI_TONE_MFR2_FWD_MAX DAHDI_TONE_MFR2_FWD_15
 
 enum {
-	ZT_TONE_MFR2_REV_1 = ZT_TONE_MFR2_REV_BASE,
-	ZT_TONE_MFR2_REV_2,
-	ZT_TONE_MFR2_REV_3,
-	ZT_TONE_MFR2_REV_4,
-	ZT_TONE_MFR2_REV_5,
-	ZT_TONE_MFR2_REV_6,
-	ZT_TONE_MFR2_REV_7,
-	ZT_TONE_MFR2_REV_8,
-	ZT_TONE_MFR2_REV_9,
-	ZT_TONE_MFR2_REV_10,
-	ZT_TONE_MFR2_REV_11,
-	ZT_TONE_MFR2_REV_12,
-	ZT_TONE_MFR2_REV_13,
-	ZT_TONE_MFR2_REV_14,
-	ZT_TONE_MFR2_REV_15,
+	DAHDI_TONE_MFR2_REV_1 = DAHDI_TONE_MFR2_REV_BASE,
+	DAHDI_TONE_MFR2_REV_2,
+	DAHDI_TONE_MFR2_REV_3,
+	DAHDI_TONE_MFR2_REV_4,
+	DAHDI_TONE_MFR2_REV_5,
+	DAHDI_TONE_MFR2_REV_6,
+	DAHDI_TONE_MFR2_REV_7,
+	DAHDI_TONE_MFR2_REV_8,
+	DAHDI_TONE_MFR2_REV_9,
+	DAHDI_TONE_MFR2_REV_10,
+	DAHDI_TONE_MFR2_REV_11,
+	DAHDI_TONE_MFR2_REV_12,
+	DAHDI_TONE_MFR2_REV_13,
+	DAHDI_TONE_MFR2_REV_14,
+	DAHDI_TONE_MFR2_REV_15,
 };
 
-#define ZT_TONE_MFR2_REV_MAX ZT_TONE_MFR2_REV_15
+#define DAHDI_TONE_MFR2_REV_MAX DAHDI_TONE_MFR2_REV_15
 
-#define ZT_MAX_CADENCE		16
+#define DAHDI_MAX_CADENCE		16
 
-#define ZT_TONEDETECT_ON	(1 << 0)		/* Detect tones */
-#define ZT_TONEDETECT_MUTE	(1 << 1)		/* Mute audio in received channel */
+#define DAHDI_TONEDETECT_ON	(1 << 0)		/* Detect tones */
+#define DAHDI_TONEDETECT_MUTE	(1 << 1)		/* Mute audio in received channel */
 
-#define ZT_TRANSCODE_MAGIC 0x74a9c0de
+#define DAHDI_TRANSCODE_MAGIC 0x74a9c0de
 
 /* Operations */
-#define ZT_TCOP_ALLOCATE	1			/* Allocate/reset DTE channel */
-#define ZT_TCOP_TRANSCODE	2			/* Begin transcoding a block */
-#define ZT_TCOP_GETINFO		3			/* Get information (use zt_transcode_info) */
-#define ZT_TCOP_RELEASE         4                       /* Release DTE channel */
-#define ZT_TCOP_TEST            5                       /* test DTE device */
-typedef struct zt_transcode_info {
+#define DAHDI_TCOP_ALLOCATE	1			/* Allocate/reset DTE channel */
+#define DAHDI_TCOP_TRANSCODE	2			/* Begin transcoding a block */
+#define DAHDI_TCOP_GETINFO		3			/* Get information (use dahdi_transcode_info) */
+#define DAHDI_TCOP_RELEASE         4                       /* Release DTE channel */
+#define DAHDI_TCOP_TEST            5                       /* test DTE device */
+typedef struct dahdi_transcode_info {
 	unsigned int op;
 	unsigned int tcnum;
 	char name[80];
 	int numchannels;
 	unsigned int srcfmts;
 	unsigned int dstfmts;
-} ZT_TRANSCODE_INFO;
+} DAHDI_TRANSCODE_INFO;
 
-#define ZT_TCCONF_USETS		(1 << 0)		/* Use/update timestamp field */
-#define ZT_TCCONF_USESEQ	(1 << 1)		/* Use/update seqno field */
+#define DAHDI_TCCONF_USETS		(1 << 0)		/* Use/update timestamp field */
+#define DAHDI_TCCONF_USESEQ	(1 << 1)		/* Use/update seqno field */
 
-#define ZT_TCSTAT_DSTRDY	(1 << 0)		/* Destination data is ready */
-#define ZT_TCSTAT_DSTBUSY	(1 << 1)		/* Destination data is outstanding */
+#define DAHDI_TCSTAT_DSTRDY	(1 << 0)		/* Destination data is ready */
+#define DAHDI_TCSTAT_DSTBUSY	(1 << 1)		/* Destination data is outstanding */
 
-#define __ZT_TRANSCODE_BUFSIZ	16384
-#define ZT_TRANSCODE_HDRLEN	256
-#define ZT_TRANSCODE_BUFSIZ	((__ZT_TRANSCODE_BUFSIZ) - (ZT_TRANSCODE_HDRLEN))
-#define ZT_TRANSCODE_DSTOFFSET	(((ZT_TRANSCODE_BUFSIZ) / 2) + ZT_TRANSCODE_HDRLEN)
-#define ZT_TRANSCODE_SRCOFFSET	(((ZT_TRANSCODE_BUFSIZ) / 2) + ZT_TRANSCODE_HDRLEN)
+#define __DAHDI_TRANSCODE_BUFSIZ	16384
+#define DAHDI_TRANSCODE_HDRLEN	256
+#define DAHDI_TRANSCODE_BUFSIZ	((__DAHDI_TRANSCODE_BUFSIZ) - (DAHDI_TRANSCODE_HDRLEN))
+#define DAHDI_TRANSCODE_DSTOFFSET	(((DAHDI_TRANSCODE_BUFSIZ) / 2) + DAHDI_TRANSCODE_HDRLEN)
+#define DAHDI_TRANSCODE_SRCOFFSET	(((DAHDI_TRANSCODE_BUFSIZ) / 2) + DAHDI_TRANSCODE_HDRLEN)
 
-typedef struct zt_transcode_header {
+typedef struct dahdi_transcode_header {
 	unsigned int srcfmt;		/* See formats.h -- use TCOP_RESET when you change */
 	unsigned int srcoffset; 	/* In bytes -- written by user */
 	unsigned int srclen;		/* In bytes -- written by user */
-	unsigned int srctimestamp;	/* In samples -- written by user (only used if ZT_TCCONF_USETS is set) */
-	unsigned int srcseqno;		/* In units -- written by user (only used if ZT_TCCONF_USESEQ is set) */
+	unsigned int srctimestamp;	/* In samples -- written by user (only used if DAHDI_TCCONF_USETS is set) */
+	unsigned int srcseqno;		/* In units -- written by user (only used if DAHDI_TCCONF_USESEQ is set) */
 
 	unsigned int dstfmt;		/* See formats.h -- use TCOP_RESET when you change */
 	unsigned int dstoffset;  	/* In bytes -- written by user */
 	unsigned int dsttimestamp;	/* In samples -- read by user */
-	unsigned int dstseqno;		/* In units -- read by user (only used if ZT_TCCONF_USESEQ is set) */
+	unsigned int dstseqno;		/* In units -- read by user (only used if DAHDI_TCCONF_USESEQ is set) */
 	unsigned int dstlen;  		/* In bytes -- read by user */
 	unsigned int dstsamples;	/* In timestamp units -- read by user */
 
-	unsigned int magic;		/* Magic value -- ZT_TRANSCODE_MAGIC, read by user */
+	unsigned int magic;		/* Magic value -- DAHDI_TRANSCODE_MAGIC, read by user */
 	unsigned int config;		/* Read/write by user */
 	unsigned int status;		/* Read/write by user */
-	unsigned char userhdr[ZT_TRANSCODE_HDRLEN - (sizeof(unsigned int) * 14)];	/* Storage for user parameters */
-	unsigned char srcdata[ZT_TRANSCODE_BUFSIZ / 2];	/* Storage of source data */
-	unsigned char dstdata[ZT_TRANSCODE_BUFSIZ / 2];	/* Storage of destination data */
-} ZT_TRANSCODE_HEADER;
+	unsigned char userhdr[DAHDI_TRANSCODE_HDRLEN - (sizeof(unsigned int) * 14)];	/* Storage for user parameters */
+	unsigned char srcdata[DAHDI_TRANSCODE_BUFSIZ / 2];	/* Storage of source data */
+	unsigned char dstdata[DAHDI_TRANSCODE_BUFSIZ / 2];	/* Storage of destination data */
+} DAHDI_TRANSCODE_HEADER;
 
-struct zt_ring_cadence {
-	int ringcadence[ZT_MAX_CADENCE];
+struct dahdi_ring_cadence {
+	int ringcadence[DAHDI_MAX_CADENCE];
 };
 
-#define ZT_MAX_ECHOCANPARAMS 8
+#define DAHDI_MAX_ECHOCANPARAMS 8
 
-struct zt_echocanparam {
+struct dahdi_echocanparam {
 	char name[16];
         __s32 value;
 };
 
-struct zt_echocanparams {
+struct dahdi_echocanparams {
 	__u32 tap_length;		/* 8 taps per millisecond */
 	__u32 param_count;		/* number of parameters supplied */
-	/* immediately follow this structure with zt_echocanparam structures */
-	struct zt_echocanparam params[0];
+	/* immediately follow this structure with dahdi_echocanparam structures */
+	struct dahdi_echocanparam params[0];
 };
 
-struct zt_tone_def_header {
+struct dahdi_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) */
+	int ringcadence[DAHDI_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 */
+	/* Immediately follow the dahdi_tone_def_header by dahdi_tone_def's */
 };
 
-struct zt_tone_def {		/* Structure for zone programming */
-	int tone;		/* See ZT_TONE_* */
+struct dahdi_tone_def {		/* Structure for zone programming */
+	int tone;		/* See DAHDI_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 */
@@ -1009,234 +1009,234 @@ struct zt_tone_def {		/* Structure for zone programming */
 #endif /* KERNEL */
 
 /* Define the maximum block size */
-#define	ZT_MAX_BLOCKSIZE	8192
+#define	DAHDI_MAX_BLOCKSIZE	8192
 
 /* Define the default network block size */
-#define ZT_DEFAULT_MTU_MRU	2048
+#define DAHDI_DEFAULT_MTU_MRU	2048
 
 /* Flush and stop the read (input) process */
-#define	ZT_FLUSH_READ		1
+#define	DAHDI_FLUSH_READ		1
 
 /* Flush and stop the write (output) process */
-#define	ZT_FLUSH_WRITE		2
+#define	DAHDI_FLUSH_WRITE		2
 
 /* Flush and stop both (input and output) processes */
-#define	ZT_FLUSH_BOTH		(ZT_FLUSH_READ | ZT_FLUSH_WRITE)
+#define	DAHDI_FLUSH_BOTH		(DAHDI_FLUSH_READ | DAHDI_FLUSH_WRITE)
 
 /* Flush the event queue */
-#define	ZT_FLUSH_EVENT		4
+#define	DAHDI_FLUSH_EVENT		4
 
 /* Flush everything */
-#define	ZT_FLUSH_ALL		(ZT_FLUSH_READ | ZT_FLUSH_WRITE | ZT_FLUSH_EVENT)
+#define	DAHDI_FLUSH_ALL		(DAHDI_FLUSH_READ | DAHDI_FLUSH_WRITE | DAHDI_FLUSH_EVENT)
 
 
-/* Value for ZT_HOOK, set to ON hook */
-#define	ZT_ONHOOK	0
+/* Value for DAHDI_HOOK, set to ON hook */
+#define	DAHDI_ONHOOK	0
 
-/* Value for ZT_HOOK, set to OFF hook */
-#define	ZT_OFFHOOK	1
+/* Value for DAHDI_HOOK, set to OFF hook */
+#define	DAHDI_OFFHOOK	1
 
-/* Value for ZT_HOOK, wink (off hook momentarily) */
-#define	ZT_WINK		2
+/* Value for DAHDI_HOOK, wink (off hook momentarily) */
+#define	DAHDI_WINK		2
 
-/* Value for ZT_HOOK, flash (on hook momentarily) */
-#define	ZT_FLASH	3
+/* Value for DAHDI_HOOK, flash (on hook momentarily) */
+#define	DAHDI_FLASH	3
 
-/* Value for ZT_HOOK, start line */
-#define	ZT_START	4
+/* Value for DAHDI_HOOK, start line */
+#define	DAHDI_START	4
 
-/* Value for ZT_HOOK, ring line (same as start line) */
-#define	ZT_RING		5
+/* Value for DAHDI_HOOK, ring line (same as start line) */
+#define	DAHDI_RING		5
 
-/* Value for ZT_HOOK, turn ringer off */
-#define ZT_RINGOFF  6
+/* Value for DAHDI_HOOK, turn ringer off */
+#define DAHDI_RINGOFF  6
 
 /* Ret. Value for GET/WAIT Event, no event */
-#define	ZT_EVENT_NONE	0
+#define	DAHDI_EVENT_NONE	0
 
 /* Ret. Value for GET/WAIT Event, Went Onhook */
-#define	ZT_EVENT_ONHOOK 1
+#define	DAHDI_EVENT_ONHOOK 1
 
 /* Ret. Value for GET/WAIT Event, Went Offhook or got Ring */
-#define	ZT_EVENT_RINGOFFHOOK 2
+#define	DAHDI_EVENT_RINGOFFHOOK 2
 
 /* Ret. Value for GET/WAIT Event, Got Wink or Flash */
-#define	ZT_EVENT_WINKFLASH 3
+#define	DAHDI_EVENT_WINKFLASH 3
 
 /* Ret. Value for GET/WAIT Event, Got Alarm */
-#define	ZT_EVENT_ALARM	4
+#define	DAHDI_EVENT_ALARM	4
 
 /* Ret. Value for GET/WAIT Event, Got No Alarm (after alarm) */
-#define	ZT_EVENT_NOALARM 5
+#define	DAHDI_EVENT_NOALARM 5
 
 /* Ret. Value for GET/WAIT Event, HDLC Abort frame */
-#define ZT_EVENT_ABORT 6
+#define DAHDI_EVENT_ABORT 6
 
 /* Ret. Value for GET/WAIT Event, HDLC Frame overrun */
-#define ZT_EVENT_OVERRUN 7
+#define DAHDI_EVENT_OVERRUN 7
 
 /* Ret. Value for GET/WAIT Event, Bad FCS */
-#define ZT_EVENT_BADFCS 8
+#define DAHDI_EVENT_BADFCS 8
 
 /* Ret. Value for dial complete */
-#define ZT_EVENT_DIALCOMPLETE	9
+#define DAHDI_EVENT_DIALCOMPLETE	9
 
 /* Ret Value for ringer going on */
-#define ZT_EVENT_RINGERON 10
+#define DAHDI_EVENT_RINGERON 10
 
 /* Ret Value for ringer going off */
-#define ZT_EVENT_RINGEROFF 11
+#define DAHDI_EVENT_RINGEROFF 11
 
 /* Ret Value for hook change complete */
-#define ZT_EVENT_HOOKCOMPLETE 12
+#define DAHDI_EVENT_HOOKCOMPLETE 12
 
 /* Ret Value for bits changing on a CAS / User channel */
-#define ZT_EVENT_BITSCHANGED 13
+#define DAHDI_EVENT_BITSCHANGED 13
 
 /* Ret value for the beginning of a pulse coming on its way */
-#define ZT_EVENT_PULSE_START 14
+#define DAHDI_EVENT_PULSE_START 14
 
 /* Timer event -- timer expired */
-#define ZT_EVENT_TIMER_EXPIRED	15
+#define DAHDI_EVENT_TIMER_EXPIRED	15
 
 /* Timer event -- ping ready */
-#define ZT_EVENT_TIMER_PING		16
+#define DAHDI_EVENT_TIMER_PING		16
 
 /* Polarity reversal event */
-#define ZT_EVENT_POLARITY  17
+#define DAHDI_EVENT_POLARITY  17
 
 /* Ring Begin event */
-#define ZT_EVENT_RINGBEGIN  18
+#define DAHDI_EVENT_RINGBEGIN  18
 
 /* Echo can disabled event */
-#define ZT_EVENT_EC_DISABLED 19
+#define DAHDI_EVENT_EC_DISABLED 19
 
 /* Channel was disconnected. Hint user to close channel */
-#define ZT_EVENT_REMOVED   20
+#define DAHDI_EVENT_REMOVED   20
 
 /* A neon MWI pulse was detected */
-#define ZT_EVENT_NEONMWI_ACTIVE   21
+#define DAHDI_EVENT_NEONMWI_ACTIVE   21
 
 /* No neon MWI pulses were detected over some period of time */
-#define ZT_EVENT_NEONMWI_INACTIVE   22
+#define DAHDI_EVENT_NEONMWI_INACTIVE   22
 
-#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 */
+#define DAHDI_EVENT_PULSEDIGIT (1 << 16)	/* This is OR'd with the digit received */
+#define DAHDI_EVENT_DTMFDOWN  (1 << 17)	/* Ditto for DTMF key down event */
+#define DAHDI_EVENT_DTMFUP (1 << 18)	/* Ditto for DTMF key up event */
 
 /* Flag Value for IOMUX, read avail */
-#define	ZT_IOMUX_READ	1
+#define	DAHDI_IOMUX_READ	1
 
 /* Flag Value for IOMUX, write avail */
-#define	ZT_IOMUX_WRITE	2
+#define	DAHDI_IOMUX_WRITE	2
 
 /* Flag Value for IOMUX, write done */
-#define	ZT_IOMUX_WRITEEMPTY	4
+#define	DAHDI_IOMUX_WRITEEMPTY	4
 
 /* Flag Value for IOMUX, signalling event avail */
-#define	ZT_IOMUX_SIGEVENT	8
+#define	DAHDI_IOMUX_SIGEVENT	8
 
 /* Flag Value for IOMUX, Do Not Wait if nothing to report */
-#define	ZT_IOMUX_NOWAIT	0x100
+#define	DAHDI_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
+#define	DAHDI_ALARM_NONE		0	/* No alarms */
+#define	DAHDI_ALARM_RECOVER	1	/* Recovering from alarm */
+#define	DAHDI_ALARM_LOOPBACK	2	/* In loopback */
+#define	DAHDI_ALARM_YELLOW		4	/* Yellow Alarm */
+#define	DAHDI_ALARM_RED		8	/* Red Alarm */
+#define	DAHDI_ALARM_BLUE		16	/* Blue Alarm */
+#define DAHDI_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 */
+#define	DAHDI_MAINT_NONE		0	/* Normal Mode */
+#define	DAHDI_MAINT_LOCALLOOP	1	/* Local Loopback */
+#define	DAHDI_MAINT_REMOTELOOP	2	/* Remote Loopback */
+#define	DAHDI_MAINT_LOOPUP	3	/* send loopup code */
+#define	DAHDI_MAINT_LOOPDOWN	4	/* send loopdown code */
+#define	DAHDI_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_MONITOR_RX_PREECHO 10	/* monitor mode (rx of other chan) - before echo can is done */
-#define	ZT_CONF_MONITOR_TX_PREECHO 11	/* monitor mode (tx of other chan) - before echo can is done */
-#define	ZT_CONF_MONITORBOTH_PREECHO 12	/* monitor mode (rx & tx of other chan) - before echo can is done */
-#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) */
+#define	DAHDI_CONF_MODE_MASK 0xff		/* mask for modes */
+#define	DAHDI_CONF_NORMAL	0		/* normal mode */
+#define	DAHDI_CONF_MONITOR 1		/* monitor mode (rx of other chan) */
+#define	DAHDI_CONF_MONITORTX 2		/* monitor mode (tx of other chan) */
+#define	DAHDI_CONF_MONITORBOTH 3		/* monitor mode (rx & tx of other chan) */
+#define	DAHDI_CONF_CONF 4			/* conference mode */
+#define	DAHDI_CONF_CONFANN 5		/* conference announce mode */
+#define	DAHDI_CONF_CONFMON 6		/* conference monitor mode */
+#define	DAHDI_CONF_CONFANNMON 7		/* conference announce/monitor mode */
+#define	DAHDI_CONF_REALANDPSEUDO 8	/* real and pseudo port both on conf */
+#define DAHDI_CONF_DIGITALMON 9	/* Do not decode or interpret */
+#define	DAHDI_CONF_MONITOR_RX_PREECHO 10	/* monitor mode (rx of other chan) - before echo can is done */
+#define	DAHDI_CONF_MONITOR_TX_PREECHO 11	/* monitor mode (tx of other chan) - before echo can is done */
+#define	DAHDI_CONF_MONITORBOTH_PREECHO 12	/* monitor mode (rx & tx of other chan) - before echo can is done */
+#define	DAHDI_CONF_FLAG_MASK 0xff00	/* mask for flags */
+#define	DAHDI_CONF_LISTENER 0x100		/* is a listener on the conference */
+#define	DAHDI_CONF_TALKER 0x200		/* is a talker on the conference */
+#define	DAHDI_CONF_PSEUDO_LISTENER 0x400	/* pseudo is a listener on the conference */
+#define	DAHDI_CONF_PSEUDO_TALKER 0x800	/* pseudo is a talker on the conference */
+
+
+#define	DAHDI_DEFAULT_WINKTIME	150	/* 150 ms default wink time */
+#define	DAHDI_DEFAULT_FLASHTIME	750	/* 750 ms default flash time */
+
+#define	DAHDI_DEFAULT_PREWINKTIME	50	/* 50 ms before wink */
+#define	DAHDI_DEFAULT_PREFLASHTIME 50	/* 50 ms before flash */
+#define	DAHDI_DEFAULT_STARTTIME 1500	/* 1500 ms of start */
+#define	DAHDI_DEFAULT_RINGTIME 2000	/* 2000 ms of ring on (start, FXO) */
 #if 0
-#define	ZT_DEFAULT_RXWINKTIME 250	/* 250ms longest rx wink */
+#define	DAHDI_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	DAHDI_DEFAULT_RXWINKTIME 300	/* 300ms longest rx wink (to work with the Atlas) */
+#define	DAHDI_DEFAULT_RXFLASHTIME 1250	/* 1250ms longest rx flash */
+#define	DAHDI_DEFAULT_DEBOUNCETIME 600	/* 600ms of FXS GS signalling debounce */
+#define	DAHDI_DEFAULT_PULSEMAKETIME 50	/* 50 ms of line closed when dial pulsing */
+#define	DAHDI_DEFAULT_PULSEBREAKTIME 50	/* 50 ms of line open when dial pulsing */
+#define	DAHDI_DEFAULT_PULSEAFTERTIME 750	/* 750ms between dial pulse digits */
 
-#define	ZT_MINPULSETIME (15 * 8)	/* 15 ms minimum */
+#define	DAHDI_MINPULSETIME (15 * 8)	/* 15 ms minimum */
 
 #ifdef SHORT_FLASH_TIME
-#define	ZT_MAXPULSETIME (80 * 8)	/* we need 80 ms, not 200ms, as we have a short flash */
+#define	DAHDI_MAXPULSETIME (80 * 8)	/* we need 80 ms, not 200ms, as we have a short flash */
 #else
-#define	ZT_MAXPULSETIME (200 * 8)	/* 200 ms maximum */
+#define	DAHDI_MAXPULSETIME (200 * 8)	/* 200 ms maximum */
 #endif
 
-#define	ZT_PULSETIMEOUT ((ZT_MAXPULSETIME / 8) + 50)
+#define	DAHDI_PULSETIMEOUT ((DAHDI_MAXPULSETIME / 8) + 50)
 
-#define ZT_RINGTRAILER (50 * 8)	/* Don't consider a ring "over" until it's been gone at least this
+#define DAHDI_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	DAHDI_LOOPCODE_TIME 10000		/* send loop codes for 10 secs */
+#define	DAHDI_ALARMSETTLE_TIME	5000	/* allow alarms to settle for 5 secs */
+#define	DAHDI_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 DAHDI_RINGOFFTIME 4000		/* Turn off ringer for 4000 ms */
+#define	DAHDI_KEWLTIME 500		/* 500ms for kewl pulse */
+#define	DAHDI_AFTERKEWLTIME 300    /* 300ms after kewl pulse */
 
-#define ZT_MAX_PRETRAINING   1000	/* 1000ms max pretraining time */
+#define DAHDI_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 */
+#define DAHDI_MAX_SPANS		128		/* Max, 128 spans */
+#define DAHDI_MAX_CHANNELS		1024	/* Max, 1024 channels */
+#define DAHDI_MAX_CONF			1024	/* Max, 1024 conferences */
 
 #ifdef	FXSFLASH
-#define ZT_FXSFLASHMINTIME	450	/* min 450ms */
-#define ZT_FXSFLASHMAXTIME	550	/* max 550ms */
+#define DAHDI_FXSFLASHMINTIME	450	/* min 450ms */
+#define DAHDI_FXSFLASHMAXTIME	550	/* max 550ms */
 #endif
 
 #ifdef __KERNEL__
 
 #include <linux/poll.h>
 
-#define	ZT_MAX_EVENTSIZE	64	/* 64 events max in buffer */
+#define	DAHDI_MAX_EVENTSIZE	64	/* 64 events max in buffer */
 
-struct zt_span;
-struct zt_chan;
+struct dahdi_span;
+struct dahdi_chan;
 
-struct zt_tone_state {
+struct dahdi_tone_state {
 	int v1_1;
 	int v2_1;
 	int v3_1;
@@ -1246,7 +1246,7 @@ struct zt_tone_state {
 	int modulate;
 };
 
-struct zt_chardev {
+struct dahdi_chardev {
 	const char *name;
 	__u8 minor;
 #ifdef CONFIG_DEVFS_FS
@@ -1254,17 +1254,17 @@ struct zt_chardev {
 #endif
 };
 
-int zt_register_chardev(struct zt_chardev *dev);
-int zt_unregister_chardev(struct zt_chardev *dev);
+int dahdi_register_chardev(struct dahdi_chardev *dev);
+int dahdi_unregister_chardev(struct dahdi_chardev *dev);
 
 #ifdef CONFIG_ZAPATA_NET
-struct zt_hdlc {
+struct dahdi_hdlc {
 #ifdef LINUX26	
 	struct net_device *netdev;
 #else
 	hdlc_device netdev;
 #endif
-	struct zt_chan *chan;
+	struct dahdi_chan *chan;
 };
 #endif
 
@@ -1275,7 +1275,7 @@ struct echo_can_state;
 void echo_can_init(void);
 void echo_chan_shutdown(void);
 void echo_can_identify(char *buf, size_t len);
-int echo_can_create(struct zt_echocanparams *ecp, struct zt_echocanparam *p, struct echo_can_state **ec);
+int echo_can_create(struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p, struct echo_can_state **ec);
 void echo_can_free(struct echo_can_state *ec);
 short echo_can_update(struct echo_can_state *ec, short iref, short isig);
 void echo_can_array_update(struct echo_can_state *ec, short *iref, short *isig);
@@ -1284,8 +1284,8 @@ int echo_can_traintap(struct echo_can_state *ec, int pos, short val);
 
 /* Conference queue stucture */
 struct confq {
-	u_char buffer[ZT_CHUNKSIZE * ZT_CB_SIZE];
-	u_char *buf[ZT_CB_SIZE];
+	u_char buffer[DAHDI_CHUNKSIZE * DAHDI_CB_SIZE];
+	u_char *buf[DAHDI_CB_SIZE];
 	int inbuf;
 	int outbuf;
 };
@@ -1302,10 +1302,10 @@ typedef struct
 	int	lastdetect;
 } sf_detect_state_t;
 
-struct zt_chan {
+struct dahdi_chan {
 #ifdef CONFIG_ZAPATA_NET
 	/* Must be first */
-	struct zt_hdlc *hdlcnetdev;
+	struct dahdi_hdlc *hdlcnetdev;
 #endif
 #ifdef CONFIG_ZAPATA_PPP
 	struct ppp_channel *ppp;
@@ -1332,14 +1332,14 @@ struct zt_chan {
 	int toneflags;
 	sf_detect_state_t rd;
 
-	struct zt_chan *master;	/* Our Master channel (could be us) */
+	struct dahdi_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 swritechunk[DAHDI_MAX_CHUNKSIZE];	/* Buffer to be written */
 	u_char *readchunk;						/* Actual place to read from */
-	u_char sreadchunk[ZT_MAX_CHUNKSIZE];	/* Preallocated static area */
+	u_char sreadchunk[DAHDI_MAX_CHUNKSIZE];	/* Preallocated static area */
 	short *readchunkpreec;
 
 	/* Pointer to tx and rx gain tables */
@@ -1354,19 +1354,19 @@ struct zt_chan {
 	struct file *file;	/* File structure */
 	
 	
-	struct zt_span	*span;			/* Span we're a member of */
+	struct dahdi_span	*span;			/* Span we're a member of */
 	int		sig;			/* Signalling */
 	int		sigcap;			/* Capability for signalling */
 	__u32		chan_alarms;		/* alarms status */
 
 	/* Used only by zaptel -- NO DRIVER SERVICEABLE PARTS BELOW */
 	/* Buffer declarations */
-	u_char		*readbuf[ZT_MAX_NUM_BUFS];	/* read buffer */
+	u_char		*readbuf[DAHDI_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 */
+	u_char		*writebuf[DAHDI_MAX_NUM_BUFS]; /* write buffers */
 	int		inwritebuf;
 	int		outwritebuf;
 	wait_queue_head_t writebufq; /* write wait queue */
@@ -1375,15 +1375,15 @@ struct zt_chan {
 
 	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 */
+	unsigned int	eventbuf[DAHDI_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		readn[DAHDI_MAX_NUM_BUFS];  /* # of bytes ready in read buf */
+	int		readidx[DAHDI_MAX_NUM_BUFS];  /* current read pointer */
+	int		writen[DAHDI_MAX_NUM_BUFS];  /* # of bytes ready in write buf */
+	int		writeidx[DAHDI_MAX_NUM_BUFS];  /* current write pointer */
 	
 	int		numbufs;			/* How many buffers in channel */
 	int		txbufpolicy;			/* Buffer policy */
@@ -1393,22 +1393,22 @@ struct zt_chan {
 	
 	
 	/* Tone zone stuff */
-	struct zt_zone *curzone;		/* Zone for selecting tones */
+	struct dahdi_zone *curzone;		/* Zone for selecting tones */
 	int 	tonezone;				/* Tone zone for this channel */
-	struct zt_tone *curtone;		/* Current tone we're playing (if any) */
+	struct dahdi_tone *curtone;		/* Current tone we're playing (if any) */
 	int		tonep;					/* Current position in tone */
-	struct zt_tone_state ts;		/* Tone state */
+	struct dahdi_tone_state ts;		/* Tone state */
 
 	/* Pulse dial stuff */
 	int	pdialcount;			/* pulse dial count */
 
 	/* Ring cadence */
-	int ringcadence[ZT_MAX_CADENCE];
+	int ringcadence[DAHDI_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];
+	char	txdialbuf[DAHDI_MAX_DTMF_BUF];
 	int 	dialing;
 	int	afterdialingtimer;
 	int		cadencepos;				/* Where in the cadence we are */
@@ -1434,14 +1434,14 @@ struct zt_chan {
 	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 */
+	short	getlin[DAHDI_MAX_CHUNKSIZE];			/* Last transmitted samples */
+	unsigned char getraw[DAHDI_MAX_CHUNKSIZE];		/* Last received raw data */
+	short	getlin_lastchunk[DAHDI_MAX_CHUNKSIZE];	/* Last transmitted samples from last chunk */
+	short	putlin[DAHDI_MAX_CHUNKSIZE];			/* Last received samples */
+	unsigned char putraw[DAHDI_MAX_CHUNKSIZE];		/* Last received raw data */
+	short	conflast[DAHDI_MAX_CHUNKSIZE];			/* Last conference sample -- base part of channel */
+	short	conflast1[DAHDI_MAX_CHUNKSIZE];		/* Last conference sample  -- pseudo part of channel */
+	short	conflast2[DAHDI_MAX_CHUNKSIZE];		/* Previous last conference sample -- pseudo part of channel */
 	
 
 	/* Is echo cancellation enabled or disabled */
@@ -1516,73 +1516,73 @@ struct zt_chan {
 
 /* 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;
+	DAHDI_TXSIG_ONHOOK,			/* On hook */
+	DAHDI_TXSIG_OFFHOOK,			/* Off hook */
+	DAHDI_TXSIG_START,				/* Start / Ring */
+	DAHDI_TXSIG_KEWL				/* Drop battery if possible */
+} dahdi_txsig_t;
 
 typedef enum {
-	ZT_RXSIG_ONHOOK,
-	ZT_RXSIG_OFFHOOK,
-	ZT_RXSIG_START,
-	ZT_RXSIG_RING,
-	ZT_RXSIG_INITIAL
-} zt_rxsig_t;
+	DAHDI_RXSIG_ONHOOK,
+	DAHDI_RXSIG_OFFHOOK,
+	DAHDI_RXSIG_START,
+	DAHDI_RXSIG_RING,
+	DAHDI_RXSIG_INITIAL
+} dahdi_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 */
+#define DAHDI_FLAG_REGISTERED		(1 << 0)
+#define DAHDI_FLAG_RUNNING			(1 << 1)
+#define DAHDI_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 */
+#define DAHDI_FLAG_DTMFDECODE		(1 << 2)	/* Channel supports native DTMF decode */
+#define DAHDI_FLAG_MFDECODE		(1 << 3)	/* Channel supports native MFr2 decode */
+#define DAHDI_FLAG_ECHOCANCEL		(1 << 4)	/* Channel supports native echo cancellation */
+
+#define DAHDI_FLAG_HDLC			(1 << 5)	/* Perform HDLC */
+#define DAHDI_FLAG_NETDEV			(1 << 6)	/* Send to network */
+#define DAHDI_FLAG_PSEUDO			(1 << 7)	/* Pseudo channel */
+#define DAHDI_FLAG_CLEAR			(1 << 8)	/* Clear channel */
+#define DAHDI_FLAG_AUDIO			(1 << 9)	/* Audio mode channel */
+
+#define DAHDI_FLAG_OPEN			(1 << 10)	/* Channel is open */
+#define DAHDI_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 */
-#define ZT_FLAG_NOSTDTXRX		(1 << 17)	/* Do NOT do standard transmit and receive on every interrupt */
-#define ZT_FLAG_LOOPED			(1 << 18)	/* Loopback the receive data from the channel to the transmit */
-#define ZT_FLAG_MTP2			(1 << 19)	/* Repeats last message in buffer and also discards repeating messages sent to us */
+#define DAHDI_FLAG_LINEAR			(1 << 13)	/* Talk to user space in linear */
+#define DAHDI_FLAG_PPP			(1 << 14)	/* PPP is available */
+#define DAHDI_FLAG_T1PPP			(1 << 15)
+#define DAHDI_FLAG_SIGFREEZE		(1 << 16)	/* Freeze signalling */
+#define DAHDI_FLAG_NOSTDTXRX		(1 << 17)	/* Do NOT do standard transmit and receive on every interrupt */
+#define DAHDI_FLAG_LOOPED			(1 << 18)	/* Loopback the receive data from the channel to the transmit */
+#define DAHDI_FLAG_MTP2			(1 << 19)	/* Repeats last message in buffer and also discards repeating messages sent to us */
 
 /* This is a redefinition of the flags from above to allow use of the kernel atomic bit testing and changing routines.
- * See the above descriptions for ZT_FLAG_....  for documentation about function. */
+ * See the above descriptions for DAHDI_FLAG_....  for documentation about function. */
 enum {
-	ZT_FLAGBIT_REGISTERED = 0,
-	ZT_FLAGBIT_RUNNING    = 1,
-	ZT_FLAGBIT_RBS	      = 12,
-	ZT_FLAGBIT_DTMFDECODE = 2,
-	ZT_FLAGBIT_MFDECODE   = 3,
-	ZT_FLAGBIT_ECHOCANCEL = 4,
-	ZT_FLAGBIT_HDLC	      = 5,
-	ZT_FLAGBIT_NETDEV     = 6,
-	ZT_FLAGBIT_PSEUDO     = 7,
-	ZT_FLAGBIT_CLEAR      = 8,
-	ZT_FLAGBIT_AUDIO      = 9,
-	ZT_FLAGBIT_OPEN	      = 10,
-	ZT_FLAGBIT_FCS	      = 11,
-	ZT_FLAGBIT_LINEAR     = 13,
-	ZT_FLAGBIT_PPP	      = 14,
-	ZT_FLAGBIT_T1PPP      = 15,
-	ZT_FLAGBIT_SIGFREEZE  = 16,
-	ZT_FLAGBIT_NOSTDTXRX  = 17,
-	ZT_FLAGBIT_LOOPED     = 18,
-	ZT_FLAGBIT_MTP2       = 19,
+	DAHDI_FLAGBIT_REGISTERED = 0,
+	DAHDI_FLAGBIT_RUNNING    = 1,
+	DAHDI_FLAGBIT_RBS	      = 12,
+	DAHDI_FLAGBIT_DTMFDECODE = 2,
+	DAHDI_FLAGBIT_MFDECODE   = 3,
+	DAHDI_FLAGBIT_ECHOCANCEL = 4,
+	DAHDI_FLAGBIT_HDLC	      = 5,
+	DAHDI_FLAGBIT_NETDEV     = 6,
+	DAHDI_FLAGBIT_PSEUDO     = 7,
+	DAHDI_FLAGBIT_CLEAR      = 8,
+	DAHDI_FLAGBIT_AUDIO      = 9,
+	DAHDI_FLAGBIT_OPEN	      = 10,
+	DAHDI_FLAGBIT_FCS	      = 11,
+	DAHDI_FLAGBIT_LINEAR     = 13,
+	DAHDI_FLAGBIT_PPP	      = 14,
+	DAHDI_FLAGBIT_T1PPP      = 15,
+	DAHDI_FLAGBIT_SIGFREEZE  = 16,
+	DAHDI_FLAGBIT_NOSTDTXRX  = 17,
+	DAHDI_FLAGBIT_LOOPED     = 18,
+	DAHDI_FLAGBIT_MTP2       = 19,
 };
 
-struct zt_span {
+struct dahdi_span {
 	spinlock_t lock;
 	void *pvt;			/* Private stuff */
 	char name[40];			/* Span name */
@@ -1591,7 +1591,7 @@ struct zt_span {
 	const char *manufacturer;	/* span's device manufacturer */
 	char devicetype[80];		/* span's device type */
 	char location[40];		/* span device's location in system */
-	int deflaw;			/* Default law (ZT_MULAW or ZT_ALAW) */
+	int deflaw;			/* Default law (DAHDI_MULAW or DAHDI_ALAW) */
 	int alarms;			/* Pending alarms on span */
 	int flags;
 	int irq;			/* IRQ for this span's hardware */
@@ -1615,73 +1615,73 @@ struct zt_span {
 
 	int timingslips;			/* Clock slips */
 
-	struct zt_chan *chans;		/* Member channel structures */
+	struct dahdi_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);
+	int (*setchunksize)(struct dahdi_span *span, int chunksize);
 
 	/* Opt: Configure the span (if appropriate) */
-	int (*spanconfig)(struct zt_span *span, struct zt_lineconfig *lc);
+	int (*spanconfig)(struct dahdi_span *span, struct dahdi_lineconfig *lc);
 	
 	/* Opt: Start the span */
-	int (*startup)(struct zt_span *span);
+	int (*startup)(struct dahdi_span *span);
 	
 	/* Opt: Shutdown the span */
-	int (*shutdown)(struct zt_span *span);
+	int (*shutdown)(struct dahdi_span *span);
 	
 	/* Opt: Enable maintenance modes */
-	int (*maint)(struct zt_span *span, int mode);
+	int (*maint)(struct dahdi_span *span, int mode);
 
 #ifdef	ZAPTEL_SYNC_TICK
 	/* Opt: send sync to spans */
-	int (*sync_tick)(struct zt_span *span, int is_master);
+	int (*sync_tick)(struct dahdi_span *span, int is_master);
 #endif
 
 	/* ====  Channel Callback Operations ==== */
 	/* Opt: Set signalling type (if appropriate) */
-	int (*chanconfig)(struct zt_chan *chan, int sigtype);
+	int (*chanconfig)(struct dahdi_chan *chan, int sigtype);
 
 	/* Opt: Prepare a channel for I/O */
-	int (*open)(struct zt_chan *chan);
+	int (*open)(struct dahdi_chan *chan);
 
 	/* Opt: Close channel for I/O */
-	int (*close)(struct zt_chan *chan);
+	int (*close)(struct dahdi_chan *chan);
 	
 	/* Opt: IOCTL */
-	int (*ioctl)(struct zt_chan *chan, unsigned int cmd, unsigned long data);
+	int (*ioctl)(struct dahdi_chan *chan, unsigned int cmd, unsigned long data);
 	
 	/* Opt: Native echo cancellation (simple) */
-	int (*echocan)(struct zt_chan *chan, int ecval);
+	int (*echocan)(struct dahdi_chan *chan, int ecval);
 
-	int (*echocan_with_params)(struct zt_chan *chan, struct zt_echocanparams *ecp, struct zt_echocanparam *p);
+	int (*echocan_with_params)(struct dahdi_chan *chan, struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p);
 
 	/* 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.  */
+	   set the DAHDI_FLAG_RBS in this case.  */
 
 	/* Opt: If the span uses A/B bits, set them here */
-	int (*rbsbits)(struct zt_chan *chan, int bits);
+	int (*rbsbits)(struct dahdi_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);
+	   to set.  Still set the DAHDI_FLAG_RBS in this case as well */
+	int (*hooksig)(struct dahdi_chan *chan, dahdi_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);
+	int (*sethook)(struct dahdi_chan *chan, int hookstate);
 	
 	/* Opt: Dacs the contents of chan2 into chan1 if possible */
-	int (*dacs)(struct zt_chan *chan1, struct zt_chan *chan2);
+	int (*dacs)(struct dahdi_chan *chan1, struct dahdi_chan *chan2);
 
 	/* Opt: Used to tell an onboard HDLC controller that there is data ready to transmit */
-	void (*hdlc_hard_xmit)(struct zt_chan *chan);
+	void (*hdlc_hard_xmit)(struct dahdi_chan *chan);
 
 	/* Used by zaptel only -- no user servicable parts inside */
 	int spanno;			/* Span number for zaptel */
@@ -1693,16 +1693,16 @@ struct zt_span {
 #endif	
 	/* If the watchdog detects no received data, it will call the
 	   watchdog routine */
-	int (*watchdog)(struct zt_span *span, int cause);
+	int (*watchdog)(struct dahdi_span *span, int cause);
 #ifdef CONFIG_ZAPTEL_WATCHDOG
 	int watchcounter;
 	int watchstate;
 #endif	
 };
 
-struct zt_transcoder_channel {
+struct dahdi_transcoder_channel {
 	void *pvt;
-	struct zt_transcoder *parent;
+	struct dahdi_transcoder *parent;
 	wait_queue_head_t ready;
 	int errorstatus;
 	int offset;
@@ -1711,35 +1711,35 @@ struct zt_transcoder_channel {
 	unsigned int flags;
 	unsigned int srcfmt;
 	unsigned int dstfmt;
-	struct zt_transcode_header *tch;
+	struct dahdi_transcode_header *tch;
 };
 
-#define ZT_TC_FLAG_BUSY       (1 << 0)
-#define ZT_TC_FLAG_TRANSIENT  (1 << 1)
+#define DAHDI_TC_FLAG_BUSY       (1 << 0)
+#define DAHDI_TC_FLAG_TRANSIENT  (1 << 1)
 
 
-struct zt_transcoder {
-	struct zt_transcoder *next;
+struct dahdi_transcoder {
+	struct dahdi_transcoder *next;
 	char name[80];
 	int numchannels;
 	unsigned int srcfmts;
 	unsigned int dstfmts;
-	int (*operation)(struct zt_transcoder_channel *channel, int op);
+	int (*operation)(struct dahdi_transcoder_channel *channel, int op);
 	/* Transcoder channels */
-	struct zt_transcoder_channel channels[0];
+	struct dahdi_transcoder_channel channels[0];
 };
 
-#define ZT_WATCHDOG_NOINTS		(1 << 0)
+#define DAHDI_WATCHDOG_NOINTS		(1 << 0)
 
-#define ZT_WATCHDOG_INIT			1000
+#define DAHDI_WATCHDOG_INIT			1000
 
-#define ZT_WATCHSTATE_UNKNOWN		0
-#define ZT_WATCHSTATE_OK			1
-#define ZT_WATCHSTATE_RECOVERING	2
-#define ZT_WATCHSTATE_FAILED		3
+#define DAHDI_WATCHSTATE_UNKNOWN		0
+#define DAHDI_WATCHSTATE_OK			1
+#define DAHDI_WATCHSTATE_RECOVERING	2
+#define DAHDI_WATCHSTATE_FAILED		3
 
 
-struct zt_dynamic_driver {
+struct dahdi_dynamic_driver {
 	/* Driver name (e.g. Eth) */
 	char name[20];
 
@@ -1747,7 +1747,7 @@ struct zt_dynamic_driver {
 	char desc[80];
 
 	/* Create a new transmission pipe */
-	void *(*create)(struct zt_span *span, char *address);
+	void *(*create)(struct dahdi_span *span, char *address);
 
 	/* Destroy a created transmission pipe */
 	void (*destroy)(void *tpipe);
@@ -1758,115 +1758,115 @@ struct zt_dynamic_driver {
 	/* Flush any pending messages */
 	int (*flush)(void);
 
-	struct zt_dynamic_driver *next;
+	struct dahdi_dynamic_driver *next;
 };
 
 /* Receive a dynamic span message */
-void zt_dynamic_receive(struct zt_span *span, unsigned char *msg, int msglen);
+void dahdi_dynamic_receive(struct dahdi_span *span, unsigned char *msg, int msglen);
 
 /* Register a dynamic driver */
-int zt_dynamic_register(struct zt_dynamic_driver *driver);
+int dahdi_dynamic_register(struct dahdi_dynamic_driver *driver);
 
 /* Unregister a dynamic driver */
-void zt_dynamic_unregister(struct zt_dynamic_driver *driver);
+void dahdi_dynamic_unregister(struct dahdi_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 */
-int zt_receive(struct zt_span *span);
+int dahdi_receive(struct dahdi_span *span);
 
 /* Prepare writechunk buffers on all channels for this span */
-int zt_transmit(struct zt_span *span);
+int dahdi_transmit(struct dahdi_span *span);
 
 /* Abort the buffer currently being receive with event "event" */
-void zt_hdlc_abort(struct zt_chan *ss, int event);
+void dahdi_hdlc_abort(struct dahdi_chan *ss, int event);
 
 /* Indicate to zaptel that the end of frame was received and rotate buffers */
-void zt_hdlc_finish(struct zt_chan *ss);
+void dahdi_hdlc_finish(struct dahdi_chan *ss);
 
 /* Put a chunk of data into the current receive buffer */
-void zt_hdlc_putbuf(struct zt_chan *ss, unsigned char *rxb, int bytes);
+void dahdi_hdlc_putbuf(struct dahdi_chan *ss, unsigned char *rxb, int bytes);
 
 /* Get a chunk of data from the current transmit buffer.  Returns -1 if no data
  * is left to send, 0 if there is data remaining in the current message to be sent
  * and 1 if the currently transmitted message is now done */
-int zt_hdlc_getbuf(struct zt_chan *ss, unsigned char *bufptr, unsigned int *size);
+int dahdi_hdlc_getbuf(struct dahdi_chan *ss, unsigned char *bufptr, unsigned int *size);
 
 
 /* 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 */
-int zt_register(struct zt_span *span, int prefmaster);
+int dahdi_register(struct dahdi_span *span, int prefmaster);
 
 /* Allocate / free memory for a transcoder */
-struct zt_transcoder *zt_transcoder_alloc(int numchans);
-void zt_transcoder_free(struct zt_transcoder *ztc);
+struct dahdi_transcoder *dahdi_transcoder_alloc(int numchans);
+void dahdi_transcoder_free(struct dahdi_transcoder *ztc);
 
 /* Register a transcoder */
-int zt_transcoder_register(struct zt_transcoder *tc);
+int dahdi_transcoder_register(struct dahdi_transcoder *tc);
 
 /* Unregister a transcoder */
-int zt_transcoder_unregister(struct zt_transcoder *tc);
+int dahdi_transcoder_unregister(struct dahdi_transcoder *tc);
 
 /* Alert a transcoder */
-int zt_transcoder_alert(struct zt_transcoder_channel *ztc);
+int dahdi_transcoder_alert(struct dahdi_transcoder_channel *ztc);
 
 /* Unregister a span */
-int zt_unregister(struct zt_span *span);
+int dahdi_unregister(struct dahdi_span *span);
 
 /* Gives a name to an LBO */
-char *zt_lboname(int lbo);
+char *dahdi_lboname(int lbo);
 
 /* Tell Zaptel about changes in received rbs bits */
-void zt_rbsbits(struct zt_chan *chan, int bits);
+void dahdi_rbsbits(struct dahdi_chan *chan, int bits);
 
 /* Tell Zaptel abou changes in received signalling */
-void zt_hooksig(struct zt_chan *chan, zt_rxsig_t rxsig);
+void dahdi_hooksig(struct dahdi_chan *chan, dahdi_rxsig_t rxsig);
 
 /* Queue an event on a channel */
-void zt_qevent_nolock(struct zt_chan *chan, int event);
+void dahdi_qevent_nolock(struct dahdi_chan *chan, int event);
 
 /* Queue an event on a channel, locking it first */
-void zt_qevent_lock(struct zt_chan *chan, int event);
+void dahdi_qevent_lock(struct dahdi_chan *chan, int event);
 
 /* Notify a change possible change in alarm status on a channel */
-void zt_alarm_channel(struct zt_chan *chan, int alarms);
+void dahdi_alarm_channel(struct dahdi_chan *chan, int alarms);
 
 /* Notify a change possible change in alarm status on a span */
-void zt_alarm_notify(struct zt_span *span);
+void dahdi_alarm_notify(struct dahdi_span *span);
 
 /* Initialize a tone state */
-void zt_init_tone_state(struct zt_tone_state *ts, struct zt_tone *zt);
+void dahdi_init_tone_state(struct dahdi_tone_state *ts, struct dahdi_tone *zt);
 
-/* Get a given MF tone struct, suitable for zt_tone_nextsample. */
-struct zt_tone *zt_mf_tone(const struct zt_chan *chan, char digit, int digitmode);
+/* Get a given MF tone struct, suitable for dahdi_tone_nextsample. */
+struct dahdi_tone *dahdi_mf_tone(const struct dahdi_chan *chan, char digit, int digitmode);
 
 /* 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
+   AT THE ZAPTEL LEVEL.  dahdi_ec_chunk will not echo cancel if it should
    not be doing so.  rxchunk is modified in-place */
 
-void zt_ec_chunk(struct zt_chan *chan, unsigned char *rxchunk, const unsigned char *txchunk);
-void zt_ec_span(struct zt_span *span);
+void dahdi_ec_chunk(struct dahdi_chan *chan, unsigned char *rxchunk, const unsigned char *txchunk);
+void dahdi_ec_span(struct dahdi_span *span);
 
-extern struct file_operations *zt_transcode_fops;
+extern struct file_operations *dahdi_transcode_fops;
 
 /* Don't use these directly -- they're not guaranteed to
    be there. */
-extern short __zt_mulaw[256];
-extern short __zt_alaw[256];
+extern short __dahdi_mulaw[256];
+extern short __dahdi_alaw[256];
 #ifdef CONFIG_CALC_XLAW
-u_char __zt_lineartoulaw(short a);
-u_char __zt_lineartoalaw(short a);
+u_char __dahdi_lineartoulaw(short a);
+u_char __dahdi_lineartoalaw(short a);
 #else
-extern u_char __zt_lin2mu[16384];
-extern u_char __zt_lin2a[16384];
+extern u_char __dahdi_lin2mu[16384];
+extern u_char __dahdi_lin2a[16384];
 #endif
 
 /* Used by dynamic zaptel -- don't use directly */
-void zt_set_dynamic_ioctl(int (*func)(unsigned int cmd, unsigned long data));
+void dahdi_set_dynamic_ioctl(int (*func)(unsigned int cmd, unsigned long data));
 
 /* Used privately by zaptel.  Avoid touching directly */
-struct zt_tone {
+struct dahdi_tone {
 	int fac1;
 	int init_v2_1;
 	int init_v3_1;
@@ -1877,12 +1877,12 @@ struct zt_tone {
 
 	int tonesamples;		/* How long to play this tone before 
 					   going to the next (in samples) */
-	struct zt_tone *next;		/* Next tone in this sequence */
+	struct dahdi_tone *next;		/* Next tone in this sequence */
 
 	int modulate;
 };
 
-static inline short zt_tone_nextsample(struct zt_tone_state *ts, struct zt_tone *zt)
+static inline short dahdi_tone_nextsample(struct dahdi_tone_state *ts, struct dahdi_tone *zt)
 {
 	/* follow the curves, return the sum */
 
@@ -1906,7 +1906,7 @@ static inline short zt_tone_nextsample(struct zt_tone_state *ts, struct zt_tone
 
 }
 
-static inline short zt_txtone_nextsample(struct zt_chan *ss)
+static inline short dahdi_txtone_nextsample(struct dahdi_chan *ss)
 {
 	/* follow the curves, return the sum */
 
@@ -1918,23 +1918,23 @@ static inline short zt_txtone_nextsample(struct zt_chan *ss)
 
 /* 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)])
+#define DAHDI_MULAW(a) (__dahdi_mulaw[(a)])
+#define DAHDI_ALAW(a) (__dahdi_alaw[(a)])
+#define DAHDI_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 DAHDI_LIN2MU(a) (__dahdi_lineartoulaw((a)))
+#define DAHDI_LIN2A(a) (__dahdi_lineartoalaw((a)))
 
-#define ZT_LIN2X(a,c) ((c)->lineartoxlaw((a)))
+#define DAHDI_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])
+#define DAHDI_LIN2MU(a) (__dahdi_lin2mu[((unsigned short)(a)) >> 2])
+#define DAHDI_LIN2A(a) (__dahdi_lin2a[((unsigned short)(a)) >> 2])
 
 /* Manipulate as appropriate for x-law */
-#define ZT_LIN2X(a,c) ((c)->lin2x[((unsigned short)(a)) >> 2])
+#define DAHDI_LIN2X(a,c) ((c)->lin2x[((unsigned short)(a)) >> 2])
 
 #endif /* CONFIG_CALC_XLAW */
 
@@ -1945,7 +1945,7 @@ this file because external processes need to interact with the device.
 Some devices have private functions used for test/diagnostic only, but
 this is not the case here. */
 
-struct zt_radio_stat {
+struct dahdi_radio_stat {
 	unsigned short ctcode_rx;	/* code of currently received CTCSS 
 					   or DCS, 0 for none */
 	unsigned short ctclass;		/* class of currently received CTCSS or
@@ -1957,7 +1957,7 @@ struct zt_radio_stat {
 
 #define	RAD_SERIAL_BUFLEN 128
 
-struct zt_radio_param {
+struct dahdi_radio_param {
 	unsigned short radpar;	/* param identifier */
 	unsigned short index;	/* tone number */
 	int data;		/* param */
@@ -1967,103 +1967,103 @@ struct zt_radio_param {
 
 
 /* Get current status IOCTL */
-#define	ZT_RADIO_GETSTAT	_IOR (ZT_CODE, 57, struct zt_radio_stat)
+#define	DAHDI_RADIO_GETSTAT	_IOR (DAHDI_CODE, 57, struct dahdi_radio_stat)
 /* Set a channel parameter IOCTL */
-#define	ZT_RADIO_SETPARAM	_IOW (ZT_CODE, 58, struct zt_radio_param)
+#define	DAHDI_RADIO_SETPARAM	_IOW (DAHDI_CODE, 58, struct dahdi_radio_param)
 /* Get a channel parameter IOCTL */
-#define	ZT_RADIO_GETPARAM	_IOR (ZT_CODE, 59, struct zt_radio_param)
+#define	DAHDI_RADIO_GETPARAM	_IOR (DAHDI_CODE, 59, struct dahdi_radio_param)
 
 
-/* Defines for Radio Status (zt_radio_stat.radstat) bits */
+/* Defines for Radio Status (dahdi_radio_stat.radstat) bits */
 
-#define	ZT_RADSTAT_RX	1	/* currently "receiving " */
-#define	ZT_RADSTAT_TX	2	/* currently "transmitting" */
-#define	ZT_RADSTAT_RXCT	4	/* currently receiving continuous tone with 
+#define	DAHDI_RADSTAT_RX	1	/* currently "receiving " */
+#define	DAHDI_RADSTAT_TX	2	/* currently "transmitting" */
+#define	DAHDI_RADSTAT_RXCT	4	/* currently receiving continuous tone with 
 				   current settings */
-#define	ZT_RADSTAT_RXCOR	8	/* currently receiving COR (irrelevant of COR
+#define	DAHDI_RADSTAT_RXCOR	8	/* currently receiving COR (irrelevant of COR
 				   ignore) */
-#define	ZT_RADSTAT_IGNCOR	16	/* currently ignoring COR */
-#define	ZT_RADSTAT_IGNCT	32	/* currently ignoring CTCSS/DCS decode */
-#define	ZT_RADSTAT_NOENCODE 64	/* currently blocking CTCSS/DCS encode */
+#define	DAHDI_RADSTAT_IGNCOR	16	/* currently ignoring COR */
+#define	DAHDI_RADSTAT_IGNCT	32	/* currently ignoring CTCSS/DCS decode */
+#define	DAHDI_RADSTAT_NOENCODE 64	/* currently blocking CTCSS/DCS encode */
 
-/* Defines for Radio Parameters (zt_radio_param.radpar) */
+/* Defines for Radio Parameters (dahdi_radio_param.radpar) */
 
-#define	ZT_RADPAR_INVERTCOR 1	/* invert the COR signal (0/1) */
-#define	ZT_RADPAR_IGNORECOR 2	/* ignore the COR signal (0/1) */
-#define	ZT_RADPAR_IGNORECT 3	/* ignore the CTCSS/DCS decode (0/1) */
-#define	ZT_RADPAR_NOENCODE 4	/* block the CTCSS/DCS encode (0/1) */
-#define	ZT_RADPAR_CORTHRESH 5	/* COR trigger threshold (0-7) */
+#define	DAHDI_RADPAR_INVERTCOR 1	/* invert the COR signal (0/1) */
+#define	DAHDI_RADPAR_IGNORECOR 2	/* ignore the COR signal (0/1) */
+#define	DAHDI_RADPAR_IGNORECT 3	/* ignore the CTCSS/DCS decode (0/1) */
+#define	DAHDI_RADPAR_NOENCODE 4	/* block the CTCSS/DCS encode (0/1) */
+#define	DAHDI_RADPAR_CORTHRESH 5	/* COR trigger threshold (0-7) */
 
-#define	ZT_RADPAR_EXTRXTONE 6	/* 0 means use internal decoder, 1 means UIOA
+#define	DAHDI_RADPAR_EXTRXTONE 6	/* 0 means use internal decoder, 1 means UIOA
 				   logic true is CT decode, 2 means UIOA logic
 				   false is CT decode */
-#define	ZT_RADPAR_NUMTONES	7	/* returns maximum tone index (curently 15) */
-#define	ZT_RADPAR_INITTONE	8	/* init all tone indexes to 0 (no tones) */
-#define	ZT_RADPAR_RXTONE	9	/* CTCSS tone, (1-32) or DCS tone (1-777),
+#define	DAHDI_RADPAR_NUMTONES	7	/* returns maximum tone index (curently 15) */
+#define	DAHDI_RADPAR_INITTONE	8	/* init all tone indexes to 0 (no tones) */
+#define	DAHDI_RADPAR_RXTONE	9	/* CTCSS tone, (1-32) or DCS tone (1-777),
 				   or 0 meaning no tone, set index also (1-15) */
-#define	ZT_RADPAR_RXTONECLASS 10	/* Tone class (0-65535), set index also (1-15) */
-#define	ZT_RADPAR_TXTONE 11	/* CTCSS tone (1-32) or DCS tone (1-777) or 0
+#define	DAHDI_RADPAR_RXTONECLASS 10	/* Tone class (0-65535), set index also (1-15) */
+#define	DAHDI_RADPAR_TXTONE 11	/* CTCSS tone (1-32) or DCS tone (1-777) or 0
 				   to indicate no tone, to transmit 
 				   for this tone index (0-32, 0 disables
 				   transmit CTCSS), set index also (0-15) */
-#define	ZT_RADPAR_DEBOUNCETIME 12	/* receive indication debounce time, 
+#define	DAHDI_RADPAR_DEBOUNCETIME 12	/* receive indication debounce time, 
 				   milliseconds (1-999) */
-#define	ZT_RADPAR_BURSTTIME 13	/* end of transmit with no CT tone in
+#define	DAHDI_RADPAR_BURSTTIME 13	/* end of transmit with no CT tone in
 				   milliseconds (0-999) */
 
 
-#define	ZT_RADPAR_UIODATA 14	/* read/write UIOA and UIOB data. Bit 0 is
+#define	DAHDI_RADPAR_UIODATA 14	/* read/write UIOA and UIOB data. Bit 0 is
 				   UIOA, bit 1 is UIOB */
-#define	ZT_RADPAR_UIOMODE 15	/* 0 means UIOA and UIOB are both outputs, 1
+#define	DAHDI_RADPAR_UIOMODE 15	/* 0 means UIOA and UIOB are both outputs, 1
 				   means UIOA is input, UIOB is output, 2 
 				   means UIOB is input and UIOA is output,
 				   3 means both UIOA and UIOB are inputs. Note
 				   mode for UIOA is overridden when in
 				   EXTRXTONE mode. */
 
-#define	ZT_RADPAR_REMMODE 16	/* Remote control data mode */
-	#define	ZT_RADPAR_REM_NONE 0 	/* no remote control data mode */
-	#define	ZT_RADPAR_REM_RBI1 1	/* Doug Hall RBI-1 data mode */
-	#define	ZT_RADPAR_REM_SERIAL 2	/* Serial Data, 9600 BPS */
-	#define	ZT_RADPAR_REM_SERIAL_ASCII 3	/* Serial Ascii Data, 9600 BPS */
+#define	DAHDI_RADPAR_REMMODE 16	/* Remote control data mode */
+	#define	DAHDI_RADPAR_REM_NONE 0 	/* no remote control data mode */
+	#define	DAHDI_RADPAR_REM_RBI1 1	/* Doug Hall RBI-1 data mode */
+	#define	DAHDI_RADPAR_REM_SERIAL 2	/* Serial Data, 9600 BPS */
+	#define	DAHDI_RADPAR_REM_SERIAL_ASCII 3	/* Serial Ascii Data, 9600 BPS */
 
-#define	ZT_RADPAR_REMCOMMAND 17	/* Remote conrtol write data block & do cmd */
+#define	DAHDI_RADPAR_REMCOMMAND 17	/* Remote conrtol write data block & do cmd */
 
 /* Data formats for capabilities and frames alike (from Asterisk) */
 /*! G.723.1 compression */
-#define ZT_FORMAT_G723_1	(1 << 0)
+#define DAHDI_FORMAT_G723_1	(1 << 0)
 /*! GSM compression */
-#define ZT_FORMAT_GSM		(1 << 1)
+#define DAHDI_FORMAT_GSM		(1 << 1)
 /*! Raw mu-law data (G.711) */
-#define ZT_FORMAT_ULAW		(1 << 2)
+#define DAHDI_FORMAT_ULAW		(1 << 2)
 /*! Raw A-law data (G.711) */
-#define ZT_FORMAT_ALAW		(1 << 3)
+#define DAHDI_FORMAT_ALAW		(1 << 3)
 /*! ADPCM (G.726, 32kbps) */
-#define ZT_FORMAT_G726		(1 << 4)
+#define DAHDI_FORMAT_G726		(1 << 4)
 /*! ADPCM (IMA) */
-#define ZT_FORMAT_ADPCM		(1 << 5)
+#define DAHDI_FORMAT_ADPCM		(1 << 5)
 /*! Raw 16-bit Signed Linear (8000 Hz) PCM */
-#define ZT_FORMAT_SLINEAR	(1 << 6)
+#define DAHDI_FORMAT_SLINEAR	(1 << 6)
 /*! LPC10, 180 samples/frame */
-#define ZT_FORMAT_LPC10		(1 << 7)
+#define DAHDI_FORMAT_LPC10		(1 << 7)
 /*! G.729A audio */
-#define ZT_FORMAT_G729A		(1 << 8)
+#define DAHDI_FORMAT_G729A		(1 << 8)
 /*! SpeeX Free Compression */
-#define ZT_FORMAT_SPEEX		(1 << 9)
+#define DAHDI_FORMAT_SPEEX		(1 << 9)
 /*! iLBC Free Compression */
-#define ZT_FORMAT_ILBC		(1 << 10)
+#define DAHDI_FORMAT_ILBC		(1 << 10)
 /*! Maximum audio format */
-#define ZT_FORMAT_MAX_AUDIO	(1 << 15)
+#define DAHDI_FORMAT_MAX_AUDIO	(1 << 15)
 /*! Maximum audio mask */
-#define ZT_FORMAT_AUDIO_MASK	((1 << 16) - 1)
+#define DAHDI_FORMAT_AUDIO_MASK	((1 << 16) - 1)
 
-#define	ZT_RADPAR_DEEMP 18 /* Audio De-empahsis (on or off) */ 
+#define	DAHDI_RADPAR_DEEMP 18 /* Audio De-empahsis (on or off) */ 
 
-#define	ZT_RADPAR_PREEMP 19 /* Audio Pre-empahsis (on or off) */ 
+#define	DAHDI_RADPAR_PREEMP 19 /* Audio Pre-empahsis (on or off) */ 
 
-#define	ZT_RADPAR_RXGAIN 20 /* Audio (In to system) Rx Gain */ 
+#define	DAHDI_RADPAR_RXGAIN 20 /* Audio (In to system) Rx Gain */ 
 
-#define	ZT_RADPAR_TXGAIN 21 /* Audio (Out from system) Tx Gain */ 
+#define	DAHDI_RADPAR_TXGAIN 21 /* Audio (Out from system) Tx Gain */ 
 
 struct torisa_debug {
 	unsigned int txerrors;
@@ -2076,7 +2076,7 @@ struct torisa_debug {
 };
 
 /* Special torisa ioctl */
-#define TORISA_GETDEBUG		_IOW (ZT_CODE, 60, struct torisa_debug)
+#define TORISA_GETDEBUG		_IOW (DAHDI_CODE, 60, struct torisa_debug)
 
 /*!
 	\brief Size-limited null-terminating string copy.