Move kernel stuff to under kernel/

(merged branch /zaptel/team/tzafrir/move )

Closes issue #7117.


git-svn-id: http://svn.digium.com/svn/zaptel/branches/1.4@3793 5390a7c7-147a-4af0-8ec9-7488f05a26cb

1 files changed, 0 insertions, 7451 deletions

diff --git a/zaptel-base.c b/zaptel-base.c
deleted file mode 100644
index 45b08f2..0000000
--- a/zaptel-base.c
+++ /dev/null
@@ -1,7451 +0,0 @@
-/*
- * Zapata Telephony Interface Driver
- *
- * Written by Mark Spencer <markster@digium.com>
- * Based on previous works, designs, and architectures conceived and
- * written by Jim Dixon <jim@lambdatel.com>.
- * 
- * Special thanks to Steve Underwood <steve@coppice.org>
- * for substantial contributions to signal processing functions 
- * in zaptel and the zapata library.
- *
- * Yury Bokhoncovich <byg@cf1.ru>
- * Adaptation for 2.4.20+ kernels (HDLC API was changed)
- * The work has been performed as a part of our move
- * from Cisco 3620 to IBM x305 here in F1 Group
- *
- * Copyright (C) 2001 Jim Dixon / Zapata Telephony.
- * Copyright (C) 2001 -2006 Digium, Inc.
- *
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- * 
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
- */
-
-
-#include "zconfig.h"
-#include "version.h"
-
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/module.h>
-#include <linux/proc_fs.h>
-#include <linux/pci.h>
-#include <linux/init.h>
-#include <linux/version.h>
-#include <linux/ctype.h>
-#include <linux/kmod.h>
-#ifdef CONFIG_DEVFS_FS
-#include <linux/devfs_fs_kernel.h>
-#endif /* CONFIG_DEVFS_FS */
-#ifdef CONFIG_ZAPATA_NET
-#include <linux/netdevice.h>
-#endif /* CONFIG_ZAPATA_NET */
-#include <linux/ppp_defs.h>
-#ifdef CONFIG_ZAPATA_PPP
-#include <linux/netdevice.h>
-#include <linux/if.h>
-#include <linux/if_ppp.h>
-#endif
-#include <asm/atomic.h>
-
-#ifndef CONFIG_OLD_HDLC_API
-#define NEW_HDLC_INTERFACE
-#endif
-
-#define __ECHO_STATE_MUTE			(1 << 8)
-#define ECHO_STATE_IDLE				(0)
-#define ECHO_STATE_PRETRAINING		(1 | (__ECHO_STATE_MUTE))
-#define ECHO_STATE_STARTTRAINING	(2 | (__ECHO_STATE_MUTE))
-#define ECHO_STATE_AWAITINGECHO		(3 | (__ECHO_STATE_MUTE))
-#define ECHO_STATE_TRAINING			(4 | (__ECHO_STATE_MUTE))
-#define ECHO_STATE_ACTIVE			(5)
-
-/* #define BUF_MUNGE */
-
-/* Grab fasthdlc with tables */
-#define FAST_HDLC_NEED_TABLES
-#include "fasthdlc.h"
-
-#include "zaptel.h"
-
-#ifdef LINUX26
-#include <linux/moduleparam.h>
-#endif
-
-/* Get helper arithmetic */
-#include "arith.h"
-#if defined(CONFIG_ZAPTEL_MMX) || defined(ECHO_CAN_FP)
-#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)
-#ifdef LINUX26
-#define ztchan_to_dev(h) ((h)->hdlcnetdev->netdev)
-#else
-#define ztchan_to_dev(h) (&((h)->hdlcnetdev->netdev.netdev))
-#endif
-
-/* macro-oni for determining a unit (channel) number */
-#define	UNIT(file) MINOR(file->f_dentry->d_inode->i_rdev)
-
-/* names of tx level settings */
-static char *zt_txlevelnames[] = {
-"0 db (CSU)/0-133 feet (DSX-1)",
-"133-266 feet (DSX-1)",
-"266-399 feet (DSX-1)",
-"399-533 feet (DSX-1)",
-"533-655 feet (DSX-1)",
-"-7.5db (CSU)",
-"-15db (CSU)",
-"-22.5db (CSU)"
-} ;
-
-EXPORT_SYMBOL(zt_transcode_fops);
-EXPORT_SYMBOL(zt_init_tone_state);
-EXPORT_SYMBOL(zt_dtmf_tone);
-EXPORT_SYMBOL(zt_register);
-EXPORT_SYMBOL(zt_unregister);
-EXPORT_SYMBOL(__zt_mulaw);
-EXPORT_SYMBOL(__zt_alaw);
-#ifdef CONFIG_CALC_XLAW
-EXPORT_SYMBOL(__zt_lineartoulaw);
-EXPORT_SYMBOL(__zt_lineartoalaw);
-#else
-EXPORT_SYMBOL(__zt_lin2mu);
-EXPORT_SYMBOL(__zt_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);
-
-#ifdef CONFIG_PROC_FS
-static struct proc_dir_entry *proc_entries[ZT_MAX_SPANS]; 
-#endif
-
-/* Here are a couple important little additions for devfs */
-#ifdef CONFIG_DEVFS_FS
-#define ZT_DEVFS_MODE (S_IFCHR|S_IRUGO|S_IWUGO)
-static devfs_handle_t zaptel_devfs_dir;
-static devfs_handle_t channel;
-static devfs_handle_t pseudo;
-static devfs_handle_t ctl;
-static devfs_handle_t timer;
-#endif
-
-/* udev necessary data structures.  Yeah! */
-#ifdef CONFIG_ZAP_UDEV
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
-#define CLASS_DEV_CREATE(class, devt, device, name) \
-        class_device_create(class, NULL, devt, device, name)
-#else
-#define CLASS_DEV_CREATE(class, devt, device, name) \
-        class_device_create(class, devt, device, name)
-#endif
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
-static struct class *zap_class = NULL;
-#else
-static struct class_simple *zap_class = NULL;
-#define class_create class_simple_create
-#define class_destroy class_simple_destroy
-#define class_device_create class_simple_device_add
-#define class_device_destroy(a, b) class_simple_device_remove(b)
-#endif
-
-#endif /* CONFIG_ZAP_UDEV */
-
-
-/* There is a table like this in the PPP driver, too */
-
-static int deftaps = 64;
-
-#if !defined(LINUX26)
-static 
-__u16 fcstab[256] =
-{
-	0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
-	0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
-	0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
-	0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
-	0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
-	0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
-	0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
-	0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
-	0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
-	0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
-	0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
-	0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
-	0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
-	0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
-	0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
-	0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
-	0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
-	0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
-	0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
-	0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
-	0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
-	0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
-	0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
-	0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
-	0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
-	0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
-	0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
-	0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
-	0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
-	0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
-	0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
-	0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
-};
-#endif
-
-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 short sumtype[ZT_MAX_CHUNKSIZE];
-
-static sumtype sums[(ZT_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 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
-{
-	int	src;	/* source conf number */
-	int	dst;	/* dst conf number */
-} conf_links[ZT_MAX_CONF + 1];
-
-
-/* There are three sets of conference sum accumulators. One for the current
-sample chunk (conf_sums), one for the next sample chunk (conf_sums_next), and
-one for the previous sample chunk (conf_sums_prev). The following routine 
-(rotate_sums) "rotates" the pointers to these accululator arrays as part
-of the events of sample chink processing as follows:
-
-The following sequence is designed to be looked at from the reference point
-of the receive routine of the master span.
-
-1. All (real span) receive chunks are processed (with putbuf). The last one
-to be processed is the master span. The data received is loaded into the
-accumulators for the next chunk (conf_sums_next), to be in alignment with
-current data after rotate_sums() is called (which immediately follows).
-Keep in mind that putbuf is *also* a transmit routine for the pseudo parts
-of channels that are in the REALANDPSEUDO conference mode. These channels
-are processed from data in the current sample chunk (conf_sums), being
-that this is a "transmit" function (for the pseudo part).
-
-2. rotate_sums() is called.
-
-3. All pseudo channel receive chunks are processed. This data is loaded into
-the current sample chunk accumulators (conf_sums).
-
-4. All conference links are processed (being that all receive data for this
-chunk has already been processed by now).
-
-5. All pseudo channel transmit chunks are processed. This data is loaded from
-the current sample chunk accumulators (conf_sums).
-
-6. All (real span) transmit chunks are processed (with getbuf).  This data is
-loaded from the current sample chunk accumulators (conf_sums). Keep in mind
-that getbuf is *also* a receive routine for the pseudo part of channels that
-are in the REALANDPSEUDO conference mode. These samples are loaded into
-the next sample chunk accumulators (conf_sums_next) to be processed as part
-of the next sample chunk's data (next time around the world).
-
-*/
-
-#define DIGIT_MODE_DTMF 	0
-#define DIGIT_MODE_MFV1		1
-#define DIGIT_MODE_PULSE	2
-
-#include "digits.h"
-
-static struct zt_dialparams global_dialparams = {
-	.dtmf_tonelen = DEFAULT_DTMF_LENGTH,
-	.mfv1_tonelen = DEFAULT_MFV1_LENGTH,
-};
-
-static int zt_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
-       a local version.  Somebody fix this! XXX */
-
-#ifndef LINUX26
-static inline void __save_init_fpu( struct task_struct *tsk )
-{
-	if ( cpu_has_fxsr ) {
-		asm volatile( "fxsave %0 ; fnclex"
-			      : "=m" (tsk->thread.i387.fxsave) );
-	} else {
-		asm volatile( "fnsave %0 ; fwait"
-			      : "=m" (tsk->thread.i387.fsave) );
-	}
-	tsk->flags &= ~PF_USEDFPU;
-}
-
-static inline void zt_kernel_fpu_begin(void)
-{
-	struct task_struct *tsk = current;
-	if (tsk->flags & PF_USEDFPU) {
-		__save_init_fpu(tsk);
-		return;
-	}
-	clts();
-}
-#else
-#define zt_kernel_fpu_begin kernel_fpu_begin
-#endif /* LINUX26 */
-#endif	
-
-static struct zt_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 */
-	wait_queue_head_t sel;
-} *zaptimers = NULL;
-
-#ifdef DEFINE_SPINLOCK
-static DEFINE_SPINLOCK(zaptimerlock);
-static DEFINE_SPINLOCK(bigzaplock);
-#else
-static spinlock_t zaptimerlock = SPIN_LOCK_UNLOCKED;
-static spinlock_t bigzaplock = SPIN_LOCK_UNLOCKED;
-#endif
-
-struct zt_zone {
-	atomic_t refcount;
-	char name[40];	/* Informational, only */
-	int ringcadence[ZT_MAX_CADENCE];
-	struct zt_tone *tones[ZT_TONE_MAX]; 
-	/* Each of these is a circular list
-	   of zt_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 mf[15];			/* MF tones for this zone, with desired length */
-	struct zt_tone mf_continuous[15];	/* MF tones for this zone, continuous play */
-};
-
-static struct zt_span *spans[ZT_MAX_SPANS];
-static struct zt_chan *chans[ZT_MAX_CHANNELS]; 
-
-static int maxspans = 0;
-static int maxchans = 0;
-static int maxconfs = 0;
-static int maxlinks = 0;
-
-static int default_zone = -1;
-
-short __zt_mulaw[256];
-short __zt_alaw[256];
-
-#ifndef CONFIG_CALC_XLAW
-u_char __zt_lin2mu[16384];
-
-u_char __zt_lin2a[16384];
-#endif
-
-static u_char defgain[256];
-
-#ifdef DEFINE_RWLOCK
-static DEFINE_RWLOCK(zone_lock);
-static DEFINE_RWLOCK(chan_lock);
-#else
-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];
-
-#define NUM_SIGS	10	
-
-
-/* Echo cancellation */
-#if defined(ECHO_CAN_HPEC)
-#include "hpec/hpec_zaptel.h"
-#elif defined(ECHO_CAN_STEVE)
-#include "sec.h"
-#elif defined(ECHO_CAN_STEVE2)
-#include "sec-2.h"
-#elif defined(ECHO_CAN_KB1)
-#include "kb1ec.h"
-#elif defined(ECHO_CAN_MG2)
-#include "mg2ec.h"
-#elif defined(ECHO_CAN_JP1)
-#include "jpah.h"
-#endif
-
-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);
-	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)
-{
-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) },
-	} ;
-
-	/* 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) || 
-		!chan->span->rbsbits) return(-1);
-	if (chan->sig == ZT_SIG_CAS)
-		return chan->idlebits;
-	for (x=0;x<NUM_SIGS;x++) {
-		if (in_sig[x][0] == chan->sig) return(in_sig[x][1]);
-	}	return(-1); /* not found -- error */
-}
-
-#ifdef CONFIG_PROC_FS
-static char *sigstr(int sig)
-{
-	switch (sig) {
-		case ZT_SIG_FXSLS:
-			return "FXSLS";
-		case ZT_SIG_FXSKS:
-			return "FXSKS";
-		case ZT_SIG_FXSGS:
-			return "FXSGS";
-		case ZT_SIG_FXOLS:
-			return "FXOLS";
-		case ZT_SIG_FXOKS:
-			return "FXOKS";
-		case ZT_SIG_FXOGS:
-			return "FXOGS";
-		case ZT_SIG_EM:
-			return "E&M";
-		case ZT_SIG_EM_E1:
-			return "E&M-E1";
-		case ZT_SIG_CLEAR:
-			return "Clear";
-		case ZT_SIG_HDLCRAW:
-			return "HDLCRAW";
-		case ZT_SIG_HDLCFCS:
-			return "HDLCFCS";
-		case ZT_SIG_HDLCNET:
-			return "HDLCNET";
-		case ZT_SIG_HARDHDLC:
-			return "Hardware-assisted HDLC";
-		case ZT_SIG_SLAVE:
-			return "Slave";
-		case ZT_SIG_CAS:
-			return "CAS";
-		case ZT_SIG_DACS:
-			return "DACS";
-		case ZT_SIG_DACS_RBS:
-			return "DACS+RBS";
-		case ZT_SIG_SF:
-			return "SF (ToneOnly)";
-		case ZT_SIG_NONE:
-		default:
-			return "Unconfigured";
-	}
-
-}
-
-static int zaptel_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data)
-{
-	int x, len = 0;
-	long span;
-
-	/* In Linux 2.6, this MUST NOT EXECEED 1024 bytes in one read! */
-
-	span = (long)data;
-
-	if (!span)
-		return 0;
-
-	if (spans[span]->name) 
-		len += sprintf(page + len, "Span %ld: %s ", span, spans[span]->name);
-	if (spans[span]->desc)
-		len += sprintf(page + len, "\"%s\"", spans[span]->desc);
-	else
-		len += sprintf(page + len, "\"\"");
-
-	if(spans[span] == master)
-		len += sprintf(page + len, " (MASTER)");
-
-	if (spans[span]->lineconfig) {
-		/* framing first */
-		if (spans[span]->lineconfig & ZT_CONFIG_B8ZS)
-			len += sprintf(page + len, " B8ZS/");
-		else if (spans[span]->lineconfig & ZT_CONFIG_AMI)
-			len += sprintf(page + len, " AMI/");
-		else if (spans[span]->lineconfig & ZT_CONFIG_HDB3)
-			len += sprintf(page + len, " HDB3/");
-		/* then coding */
-		if (spans[span]->lineconfig & ZT_CONFIG_ESF)
-			len += sprintf(page + len, "ESF");
-		else if (spans[span]->lineconfig & ZT_CONFIG_D4)
-			len += sprintf(page + len, "D4");
-		else if (spans[span]->lineconfig & ZT_CONFIG_CCS)
-			len += sprintf(page + len, "CCS");
-		/* E1's can enable CRC checking */
-		if (spans[span]->lineconfig & ZT_CONFIG_CRC4)
-			len += sprintf(page + len, "/CRC4");
-	}
-
-	len += sprintf(page + len, " ");
-
-	/* list alarms */
-	if (spans[span]->alarms && (spans[span]->alarms > 0)) {
-		if (spans[span]->alarms & ZT_ALARM_BLUE)
-			len += sprintf(page + len, "BLUE ");
-		if (spans[span]->alarms & ZT_ALARM_YELLOW)
-			len += sprintf(page + len, "YELLOW ");
-		if (spans[span]->alarms & ZT_ALARM_RED)
-			len += sprintf(page + len, "RED ");
-		if (spans[span]->alarms & ZT_ALARM_LOOPBACK)
-			len += sprintf(page + len, "LOOP ");
-		if (spans[span]->alarms & ZT_ALARM_RECOVER)
-			len += sprintf(page + len, "RECOVERING ");
-		if (spans[span]->alarms & ZT_ALARM_NOTOPEN)
-			len += sprintf(page + len, "NOTOPEN ");
-					
-	}
-	if (spans[span]->syncsrc && (spans[span]->syncsrc == spans[span]->spanno))
-		len += sprintf(page + len, "ClockSource ");
-	len += sprintf(page + len, "\n");
-	if (spans[span]->bpvcount)
-		len += sprintf(page + len, "\tBPV count: %d\n", spans[span]->bpvcount);
-	if (spans[span]->crc4count)
-		len += sprintf(page + len, "\tCRC4 error count: %d\n", spans[span]->crc4count);
-	if (spans[span]->ebitcount)
-		len += sprintf(page + len, "\tE-bit error count: %d\n", spans[span]->ebitcount);
-	if (spans[span]->fascount)
-		len += sprintf(page + len, "\tFAS error count: %d\n", spans[span]->fascount);
-	if (spans[span]->irqmisses)
-		len += sprintf(page + len, "\tIRQ misses: %d\n", spans[span]->irqmisses);
-	if (spans[span]->timingslips)
-		len += sprintf(page + len, "\tTiming slips: %d\n", spans[span]->timingslips);
-	len += sprintf(page + len, "\n");
-
-
-        for (x=1;x<ZT_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)
-						len += sprintf(page + len, "%s ", sigstr(chans[x]->master->sig));
-					else {
-						len += sprintf(page + len, "%s ", sigstr(chans[x]->sig));
-						if (chans[x]->nextslave && chans[x]->master->channo == x)
-							len += sprintf(page + len, "Master ");
-					}
-				}
-				if ((chans[x]->flags & ZT_FLAG_OPEN)) {
-					len += sprintf(page + len, "(In use) ");
-				}
-#ifdef	OPTIMIZE_CHANMUTE
-				if ((chans[x]->chanmute)) {
-					len += sprintf(page + len, "(no pcm) ");
-				}
-#endif
-				len += sprintf(page + len, "\n");
-			}
-			if (len <= off) { /* If everything printed so far is before beginning of request */
-				off -= len;
-				len = 0;
-			}
-			if (len > off+count) /* stop if we've already generated enough */
-				break;
-		}
-	}
-	if (len <= off) { /* If everything printed so far is before beginning of request */
-		off -= len;
-		len = 0;
-	}
-	*start = page + off;
-	len -= off;     /* un-count any remaining offset */
-	if (len > count) len = count;   /* don't return bytes not asked for */
-	return len;
-}
-#endif
-
-static int zt_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++) {
-		if (!confrev[x])
-			return x;
-	}
-	return -1;
-}
-
-static void recalc_maxconfs(void)
-{
-	int x;
-	for (x=ZT_MAX_CONF-1;x>0;x--) {
-		if (confrev[x]) {
-			maxconfs = x+1;
-			return;
-		}
-	}
-	maxconfs = 0;
-}
-
-static void recalc_maxlinks(void)
-{
-	int x;
-	for (x=ZT_MAX_CONF-1;x>0;x--) {
-		if (conf_links[x].src || conf_links[x].dst) {
-			maxlinks = x+1;
-			return;
-		}
-	}
-	maxlinks = 0;
-}
-
-static int zt_first_empty_conference(void)
-{
-	/* Find the first conference which has no alias */
-	int x;
-	for (x=ZT_MAX_CONF-1;x>0;x--) {
-		if (!confalias[x])
-			return x;
-	}
-	return -1;
-}
-
-static int zt_get_conf_alias(int x)
-{
-	int a;
-	if (confalias[x]) {
-		return confalias[x];
-	}
-
-	/* Allocate an alias */
-	a = zt_first_empty_alias();
-	confalias[x] = a;
-	confrev[a] = x;
-
-	/* Highest conference may have changed */
-	recalc_maxconfs();
-	return a;
-}
-
-static void zt_check_conf(int x)
-{
-	int y;
-
-	/* return if no valid conf number */
-	if (x <= 0) return;
-	/* Return if there is no alias */
-	if (!confalias[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))
-			return;
-	}
-	/* If we get here, nobody is in the conference anymore.  Clear it out
-	   both forward and reverse */
-	confrev[confalias[x]] = 0;
-	confalias[x] = 0;
-
-	/* Highest conference may have changed */
-	recalc_maxconfs();
-}
-
-/* enqueue an event on a channel */
-static void __qevent(struct zt_chan *chan, int event)
-{
-
-	  /* if full, ignore */
-	if ((chan->eventoutidx == 0) && (chan->eventinidx == (ZT_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;
-	  /* wake em all up */
-	if (chan->iomask & ZT_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)
-{
-	__qevent(chan, event);
-}
-
-void zt_qevent_lock(struct zt_chan *chan, int event)
-{
-	unsigned long flags;
-	spin_lock_irqsave(&chan->lock, flags);
-	__qevent(chan, event);
-	spin_unlock_irqrestore(&chan->lock, flags);
-}
-
-/* sleep in user space until woken up. Equivilant of tsleep() in BSD */
-static int schluffen(wait_queue_head_t *q)
-{
-	DECLARE_WAITQUEUE(wait, current);
-	add_wait_queue(q, &wait);
-	current->state = TASK_INTERRUPTIBLE;
-	if (!signal_pending(current)) schedule();
-	current->state = TASK_RUNNING;
-	remove_wait_queue(q, &wait);
-	if (signal_pending(current)) {
-		return -ERESTARTSYS;
-	}
-	return(0);
-}
-
-static inline void calc_fcs(struct zt_chan *ss, int inwritebuf)
-{
-	int x;
-	unsigned int fcs=PPP_INITFCS;
-	unsigned char *data = ss->writebuf[inwritebuf];
-	int len = ss->writen[inwritebuf];
-	/* Not enough space to do FCS calculation */
-	if (len < 2)
-		return;
-	for (x=0;x<len-2;x++)
-		fcs = PPP_FCS(fcs, data[x]);
-	fcs ^= 0xffff;
-	/* Send out the FCS */
-	data[len-2] = (fcs & 0xff);
-	data[len-1] = (fcs >> 8) & 0xff;
-}
-
-static int zt_reallocbufs(struct zt_chan *ss, int j, int numbufs)
-{
-	unsigned char *newbuf, *oldbuf;
-	unsigned long flags;
-	int x;
-	/* Check numbufs */
-	if (numbufs < 2)
-		numbufs = 2;
-	if (numbufs > ZT_MAX_NUM_BUFS)
-		numbufs = ZT_MAX_NUM_BUFS;
-	/* We need to allocate our buffers now */
-	if (j) {
-		newbuf = kmalloc(j * 2 * numbufs, GFP_KERNEL);
-		if (!newbuf) 
-			return (-ENOMEM);
-	} else
-		newbuf = NULL;
-	  /* Now that we've allocated our new buffer, we can safely
-	     move things around... */
-	spin_lock_irqsave(&ss->lock, flags);
-	ss->blocksize = j; /* set the blocksize */
-	oldbuf = ss->readbuf[0]; /* Keep track of the old buffer */
-	ss->readbuf[0] = NULL;
-	if (newbuf) {
-		for (x=0;x<numbufs;x++) {
-			ss->readbuf[x] = newbuf + x * j;
-			ss->writebuf[x] = newbuf + (numbufs + x) * j;
-		}
-	} else {
-		for (x=0;x<numbufs;x++) {
-			ss->readbuf[x] = NULL;
-			ss->writebuf[x] = NULL;
-		}
-	}
-	/* Mark all buffers as empty */
-	for (x=0;x<numbufs;x++) 
-		ss->writen[x] = 
-		ss->writeidx[x]=
-		ss->readn[x]=
-		ss->readidx[x] = 0;
-	
-	/* Keep track of where our data goes (if it goes
-	   anywhere at all) */
-	if (newbuf) {
-		ss->inreadbuf = 0;
-		ss->inwritebuf = 0;
-	} else {
-		ss->inreadbuf = -1;
-		ss->inwritebuf = -1;
-	}
-	ss->outreadbuf = -1;
-	ss->outwritebuf = -1;
-	ss->numbufs = numbufs;
-	if (ss->txbufpolicy == ZT_POLICY_WHEN_FULL)
-		ss->txdisable = 1;
-	else
-		ss->txdisable = 0;
-
-	if (ss->rxbufpolicy == ZT_POLICY_WHEN_FULL)
-		ss->rxdisable = 1;
-	else
-		ss->rxdisable = 0;
-
-	spin_unlock_irqrestore(&ss->lock, flags);
-	if (oldbuf)
-		kfree(oldbuf);
-	return 0;
-}
-
-static int zt_hangup(struct zt_chan *chan);
-static void zt_set_law(struct zt_chan *chan, int law);
-
-/* Pull a ZT_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)
-{
-	int oldoutbuf = q->outbuf;
-	/* Ain't nuffin to read */
-	if (q->outbuf < 0) {
-		if (data)
-			memset(data, ZT_LIN2X(0,c), ZT_CHUNKSIZE);
-		return -1;
-	}
-	if (data)
-		memcpy(data, q->buf[q->outbuf], ZT_CHUNKSIZE);
-	q->outbuf = (q->outbuf + 1) % ZT_CB_SIZE;
-
-	/* Won't be nuffin next time */
-	if (q->outbuf == q->inbuf) {
-		q->outbuf = -1;
-	}
-
-	/* If they thought there was no space then
-	   there is now where we just read */
-	if (q->inbuf < 0) 
-		q->inbuf = oldoutbuf;
-	return 0;
-}
-
-/* Returns a place to put stuff, or NULL if there is
-   no room */
-
-static u_char *__buf_pushpeek(struct confq *q)
-{
-	if (q->inbuf < 0)
-		return NULL;
-	return q->buf[q->inbuf];
-}
-
-static u_char *__buf_peek(struct confq *q)
-{
-	if (q->outbuf < 0)
-		return NULL;
-	return q->buf[q->outbuf];
-}
-
-#ifdef BUF_MUNGE
-static u_char *__buf_cpush(struct confq *q)
-{
-	int pos;
-	/* If we have no space, return where the
-	   last space that we *did* have was */
-	if (q->inbuf > -1)
-		return NULL;
-	pos = q->outbuf - 1;
-	if (pos < 0)
-		pos += ZT_CB_SIZE;
-	return q->buf[pos];
-}
-
-static void __buf_munge(struct zt_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);
-	}
-}
-#endif
-/* Push something onto the queue, or assume what
-   is there is valid if data is NULL */
-static int __buf_push(struct confq *q, u_char *data, char *label)
-{
-	int oldinbuf = q->inbuf;
-	if (q->inbuf < 0) {
-		return -1;
-	}
-	if (data)
-		/* Copy in the data */
-		memcpy(q->buf[q->inbuf], data, ZT_CHUNKSIZE);
-
-	/* Advance the inbuf pointer */
-	q->inbuf = (q->inbuf + 1) % ZT_CB_SIZE;
-
-	if (q->inbuf == q->outbuf) {
-		/* No space anymore... */	
-		q->inbuf = -1;
-	}
-	/* If they don't think data is ready, let
-	   them know it is now */
-	if (q->outbuf < 0) {
-		q->outbuf = oldinbuf;
-	}
-	return 0;
-}
-
-static void reset_conf(struct zt_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;
-	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;
-	chan->confout.inbuf = 0;
-	chan->confout.outbuf = -1;
-}
-
-
-static void close_channel(struct zt_chan *chan)
-{
-	unsigned long flags;
-	void *rxgain = NULL;
-	struct echo_can_state *ec = NULL;
-	int oldconf;
-	short *readchunkpreec;
-#ifdef CONFIG_ZAPATA_PPP
-	struct ppp_channel *ppp;
-#endif
-
-	/* XXX Buffers should be send out before reallocation!!! XXX */
-	if (!(chan->flags & ZT_FLAG_NOSTDTXRX))
-		zt_reallocbufs(chan, 0, 0); 
-	spin_lock_irqsave(&chan->lock, flags);
-#ifdef CONFIG_ZAPATA_PPP
-	ppp = chan->ppp;
-	chan->ppp = NULL;
-#endif
-	ec = chan->ec;
-	chan->ec = NULL;
-	readchunkpreec = chan->readchunkpreec;
-	chan->readchunkpreec = NULL;
-	chan->curtone = NULL;
-	if (chan->curzone)
-		atomic_dec(&chan->curzone->refcount);
-	chan->curzone = NULL;
-	chan->cadencepos = 0;
-	chan->pdialcount = 0;
-	zt_hangup(chan); 
-	chan->itimerset = chan->itimer = 0;
-	chan->pulsecount = 0;
-	chan->pulsetimer = 0;
-	chan->ringdebtimer = 0;
-	init_waitqueue_head(&chan->sel);
-	init_waitqueue_head(&chan->readbufq);
-	init_waitqueue_head(&chan->writebufq);
-	init_waitqueue_head(&chan->eventbufq);
-	init_waitqueue_head(&chan->txstateq);
-	chan->txdialbuf[0] = '\0';
-	chan->digitmode = DIGIT_MODE_DTMF;
-	chan->dialing = 0;
-	chan->afterdialingtimer = 0;
-	  /* initialize IO MUX mask */
-	chan->iomask = 0;
-	/* save old conf number, if any */
-	oldconf = chan->confna;
-	  /* initialize conference variables */
-	chan->_confn = 0;
-	if ((chan->sig & __ZT_SIG_DACS) != __ZT_SIG_DACS) {
-		chan->confna = 0;
-		chan->confmode = 0;
-	}
-	chan->confmute = 0;
-	/* release conference resource, if any to release */
-	if (oldconf) zt_check_conf(oldconf);
-	chan->gotgs = 0;
-	reset_conf(chan);
-	
-	if (chan->gainalloc && chan->rxgain)
-		rxgain = chan->rxgain;
-
-	chan->rxgain = defgain;
-	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);
-
-	zt_set_law(chan,0);
-
-	memset(chan->conflast, 0, sizeof(chan->conflast));
-	memset(chan->conflast1, 0, sizeof(chan->conflast1));
-	memset(chan->conflast2, 0, sizeof(chan->conflast2));
-
-	if (chan->span && chan->span->dacs && oldconf)
-		chan->span->dacs(chan, NULL);
-
-	spin_unlock_irqrestore(&chan->lock, flags);
-
-	if (chan->span && chan->span->echocan)
-		chan->span->echocan(chan, 0);
-
-	if (rxgain)
-		kfree(rxgain);
-	if (ec)
-		echo_can_free(ec);
-	if (readchunkpreec)
-		kfree(readchunkpreec);
-
-#ifdef CONFIG_ZAPATA_PPP
-	if (ppp) {
-		tasklet_kill(&chan->ppp_calls);
-		skb_queue_purge(&chan->ppp_rq);
-		ppp_unregister_channel(ppp);
-		kfree(ppp);
-	}
-#endif
-
-}
-
-static int free_tone_zone(int num)
-{
-	struct zt_zone *z;
-
-	if ((num >= ZT_TONE_ZONE_MAX) || (num < 0))
-		return -EINVAL;
-
-	write_lock(&zone_lock);
-	z = tone_zones[num];
-	tone_zones[num] = NULL;
-	write_unlock(&zone_lock);
-	if (!z)
-		return 0;
-
-	if (atomic_read(&z->refcount)) {
-		/* channels are still using this zone so put it back */
-		write_lock(&zone_lock);
-		tone_zones[num] = z;
-		write_unlock(&zone_lock);
-
-		return -EBUSY;
-	} else {
-		kfree(z);
-
-		return 0;
-	}
-}
-
-static int zt_register_tone_zone(int num, struct zt_zone *zone)
-{
-	int res = 0;
-
-	if ((num >= ZT_TONE_ZONE_MAX) || (num < 0))
-		return -EINVAL;
-
-	write_lock(&zone_lock);
-	if (tone_zones[num]) {
-		res = -EINVAL;
-	} else {
-		res = 0;
-		tone_zones[num] = zone;
-	}
-	write_unlock(&zone_lock);
-
-	if (!res)
-		printk(KERN_INFO "Registered tone zone %d (%s)\n", num, zone->name);
-
-	return res;
-}
-
-static int start_tone(struct zt_chan *chan, int tone)
-{
-	int res = -EINVAL;
-
-	/* Stop the current tone, no matter what */
-	chan->tonep = 0;
-	chan->curtone = NULL;
-	chan->pdialcount = 0;
-	chan->txdialbuf[0] = '\0';
-	chan->dialing = 0;
-
-	if (tone == -1) {
-		/* Just stop the current tone */
-		res = 0;
-	} else if ((tone >= 0 && tone <= ZT_TONE_MAX)) {
-		if (chan->curzone) {
-			/* Have a tone zone */
-			if (chan->curzone->tones[tone]) {
-				chan->curtone = chan->curzone->tones[tone];
-				res = 0;
-			} else	/* Indicate that zone is loaded but no such tone exists */
-				res = -ENOSYS;
-		} else	/* Note that no tone zone exists at the moment */
-			res = -ENODATA;
-	} else if (tone >= ZT_TONE_DTMF_BASE && tone <= ZT_TONE_DTMF_MAX) {
-		/* ZT_SENDTONE should never be used on a channel configured for pulse dialing */
-		chan->dialing = 1;
-		res = 0;
-		if ((chan->digitmode == DIGIT_MODE_DTMF) &&
-		    (tone >= ZT_TONE_DTMF_BASE) &&
-		    (tone <= ZT_TONE_DTMF_MAX))
-			chan->curtone = &chan->curzone->dtmf_continuous[tone - ZT_TONE_DTMF_BASE];
-		else if ((chan->digitmode == DIGIT_MODE_MFV1) &&
-			 (tone >= ZT_TONE_MF_BASE) &&
-			 (tone <= ZT_TONE_MF_MAX))
-			chan->curtone = &chan->curzone->mf_continuous[tone - ZT_TONE_MF_BASE];
-		else {
-			chan->dialing = 0;
-			res = -EINVAL;
-		}
-	}
-
-	if (chan->curtone)
-		zt_init_tone_state(&chan->ts, chan->curtone);
-	
-	return res;
-}
-
-static int set_tone_zone(struct zt_chan *chan, int zone)
-{
-	int res = 0;
-	struct zt_zone *z;
-	unsigned long flags;
-
-	/* Do not call with the channel locked. */
-
-	if (zone == -1)
-		zone = default_zone;
-
-	if ((zone >= ZT_TONE_ZONE_MAX) || (zone < 0))
-		return -EINVAL;
-
-	read_lock(&zone_lock);
-
-	if ((z = tone_zones[zone])) {
-		spin_lock_irqsave(&chan->lock, flags);
-		if (chan->curzone)
-			atomic_dec(&chan->curzone->refcount);
-
-		atomic_inc(&z->refcount);
-		chan->curzone = z;
-		chan->tonezone = zone;
-		memcpy(chan->ringcadence, z->ringcadence, sizeof(chan->ringcadence));
-		spin_unlock_irqrestore(&chan->lock, flags);
-	} else {
-		res = -ENODATA;
-	}
-
-	read_unlock(&zone_lock);
-
-	return res;
-}
-
-static void zt_set_law(struct zt_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;
-	}
-	if (law == ZT_LAW_ALAW) {
-		chan->xlaw = __zt_alaw;
-#ifdef CONFIG_CALC_XLAW
-		chan->lineartoxlaw = __zt_lineartoalaw;
-#else
-		chan->lin2x = __zt_lin2a;
-#endif
-	} else {
-		chan->xlaw = __zt_mulaw;
-#ifdef CONFIG_CALC_XLAW
-		chan->lineartoxlaw = __zt_lineartoulaw;
-#else
-		chan->lin2x = __zt_lin2mu;
-#endif
-	}
-}
-
-#ifdef CONFIG_DEVFS_FS
-static devfs_handle_t register_devfs_channel(struct zt_chan *chan, devfs_handle_t dir)
-{
-	char path[100];
-	char link[100];
-	char buf[50];
-	char tmp[100];
-	int link_offset = 0;
-	int tmp_offset = 0;
-	int path_offset = 0;
-	int err = 0;
-	devfs_handle_t chan_dev;
-	umode_t mode = S_IFCHR|S_IRUGO|S_IWUGO;
-	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);
-	if (!chan_dev) {
-		printk("zaptel: Something really bad happened.  Unable to register devfs entry\n");
-		return NULL;
-	}
-
-	/* Set up the path of the destination of the link */
-	link_offset = devfs_generate_path(chan_dev, link, sizeof(link) - 1);
-	/* Now we need to strip off the leading "zap/".  If we don't, then we build a broken symlink */
-	path_offset = devfs_generate_path(zaptel_devfs_dir, path, sizeof(path) - 1); /* We'll just "borrow" path for a second */
-	path_offset = strlen(path+path_offset);
-	link_offset += path_offset; /* Taking out the "zap" */
-	link_offset++; /* Add one more place for the '/'.  The path generated does not contain the '/' we need to strip */
-	
-	/* Set up the path of the file/link itself */
-	tmp_offset = devfs_generate_path(zaptel_devfs_dir, tmp, sizeof(tmp) - 1);
-	sprintf(buf, "/%d", chan->channo);
-	strncpy(path, tmp+tmp_offset, sizeof(path) - 1);
-	strncat(path, buf, sizeof(path) - 1);
-
-	err = devfs_mk_symlink(NULL, path, DEVFS_FL_DEFAULT, link+link_offset, &chan->fhandle_symlink, NULL);
-	if (err != 0) {
-		printk("Problem with making devfs symlink: %d\n", err);
-	}
-
-	return chan_dev;
-}
-#endif /* CONFIG_DEVFS_FS */
-
-static int zt_chan_reg(struct zt_chan *chan)
-{
-	int x;
-	int res=0;
-	unsigned long flags;
-	
-	write_lock_irqsave(&chan_lock, flags);
-	for (x=1;x<ZT_MAX_CHANNELS;x++) {
-		if (!chans[x]) {
-			spin_lock_init(&chan->lock);
-			chans[x] = chan;
-			if (maxchans < x + 1)
-				maxchans = x + 1;
-			chan->channo = x;
-			if (!chan->master)
-				chan->master = chan;
-			if (!chan->readchunk)
-				chan->readchunk = chan->sreadchunk;
-			if (!chan->writechunk)
-				chan->writechunk = chan->swritechunk;
-			zt_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;
-			res = 0;
-			break;
-		}
-	}
-	write_unlock_irqrestore(&chan_lock, flags);	
-	if (x >= ZT_MAX_CHANNELS)
-		printk(KERN_ERR "No more channels available\n");
-	return res;
-}
-
-char *zt_lboname(int x)
-{
-	if ((x < 0) || ( x > 7))
-		return "Unknown";
-	return zt_txlevelnames[x];
-}
-
-#if defined(CONFIG_ZAPATA_NET) || defined(CONFIG_ZAPATA_PPP)
-#endif
-
-#ifdef CONFIG_ZAPATA_NET
-#ifdef NEW_HDLC_INTERFACE
-static int zt_net_open(struct net_device *dev)
-{
-#ifdef LINUX26
-	int res = hdlc_open(dev);
-	struct zt_chan *ms = dev_to_ztchan(dev);
-#else
-	hdlc_device *hdlc = dev_to_hdlc(dev);
-	struct zt_chan *ms = hdlc_to_ztchan(hdlc);
-	int res = hdlc_open(hdlc);
-#endif	
-	                                                                                                                             
-/*	if (!dev->hard_start_xmit) return res; is this really necessary? --byg */
-	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)
-{
-	struct zt_chan *ms = hdlc_to_ztchan(hdlc);
-	int res;
-#endif
-	if (!ms) {
-		printk("zt_net_open: nothing??\n");
-		return -EINVAL;
-	}
-	if (ms->flags & ZT_FLAG_OPEN) {
-		printk("%s is already open!\n", ms->name);
-		return -EBUSY;
-	}
-	if (!(ms->flags & ZT_FLAG_NETDEV)) {
-		printk("%s is not a net device!\n", ms->name);
-		return -EINVAL;
-	}
-	ms->txbufpolicy = ZT_POLICY_IMMEDIATE;
-	ms->rxbufpolicy = ZT_POLICY_IMMEDIATE;
-
-	res = zt_reallocbufs(ms, ZT_DEFAULT_MTU_MRU, ZT_DEFAULT_NUM_BUFS);
-	if (res) 
-		return res;
-
-	fasthdlc_init(&ms->rxhdlc);
-	fasthdlc_init(&ms->txhdlc);
-	ms->infcs = PPP_INITFCS;
-
-	netif_start_queue(ztchan_to_dev(ms));
-
-#ifndef LINUX26
-	MOD_INC_USE_COUNT;
-#endif	
-#ifdef CONFIG_ZAPATA_DEBUG
-	printk("ZAPNET: Opened channel %d name %s\n", ms->channo, ms->name);
-#endif
-	return 0;
-}
-
-#ifdef LINUX26
-static int zt_register_hdlc_device(struct net_device *dev, const char *dev_name)
-{
-	int result;
-
-	if (dev_name && *dev_name) {
-		if ((result = dev_alloc_name(dev, dev_name)) < 0)
-			return result;
-	}
-	result = register_netdev(dev);
-	if (result != 0)
-		return -EIO;
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,14)
-	if (netif_carrier_ok(dev))
-		netif_carrier_off(dev); /* no carrier until DCD goes up */
-#endif
-	return 0;
-}
-#endif
-
-#ifdef NEW_HDLC_INTERFACE
-static int zt_net_stop(struct net_device *dev)
-{
-#ifdef LINUX26
-    hdlc_device *h = dev_to_hdlc(dev);
-    struct zt_hdlc *hdlc = h->priv;
-#else
-    hdlc_device *hdlc = dev_to_hdlc(dev);
-#endif
-
-#else
-static void zt_net_close(hdlc_device *hdlc)
-{
-#endif
-	struct zt_chan *ms = hdlc_to_ztchan(hdlc);
-	if (!ms) {
-#ifdef NEW_HDLC_INTERFACE
-		printk("zt_net_stop: nothing??\n");
-		return 0;
-#else
-		printk("zt_net_close: nothing??\n");
-		return;
-#endif
-	}
-	if (!(ms->flags & ZT_FLAG_NETDEV)) {
-#ifdef NEW_HDLC_INTERFACE
-		printk("zt_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);
-		return;
-#endif
-	}
-	/* Not much to do here.  Just deallocate the buffers */
-        netif_stop_queue(ztchan_to_dev(ms));
-	zt_reallocbufs(ms, 0, 0);
-#ifdef LINUX26
-	hdlc_close(dev);
-#else
-#ifndef CONFIG_OLD_HDLC_API
-	hdlc_close(hdlc);
-#endif
-#endif	
-#ifndef LINUX26
-	MOD_DEC_USE_COUNT;
-#endif	
-#ifdef NEW_HDLC_INTERFACE
-	return 0;
-#else
-	return;
-#endif
-}
-
-#ifdef NEW_HDLC_INTERFACE
-/* kernel 2.4.20+ has introduced attach function, dunno what to do,
- 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,
-        unsigned short parity)
-#else		
-static int zt_net_attach(hdlc_device *hdlc, unsigned short encoding,
-        unsigned short parity)
-#endif
-{
-/*        struct net_device *dev = hdlc_to_dev(hdlc);
-        struct dscc4_dev_priv *dpriv = dscc4_priv(dev);
-
-        if (encoding != ENCODING_NRZ &&
-            encoding != ENCODING_NRZI &&
-            encoding != ENCODING_FM_MARK &&
-            encoding != ENCODING_FM_SPACE &&
-            encoding != ENCODING_MANCHESTER)
-                return -EINVAL;
-
-        if (parity != PARITY_NONE &&
-            parity != PARITY_CRC16_PR0_CCITT &&
-            parity != PARITY_CRC16_PR1_CCITT &&
-            parity != PARITY_CRC32_PR0_CCITT &&
-            parity != PARITY_CRC32_PR1_CCITT)
-                return -EINVAL;
-
-        dpriv->encoding = encoding;
-        dpriv->parity = parity;*/
-        return 0;
-}
-#endif
-																								 
-static struct zt_hdlc *zt_hdlc_alloc(void)
-{
-	struct zt_hdlc *tmp;
-	tmp = kmalloc(sizeof(struct zt_hdlc), GFP_KERNEL);
-	if (tmp) {
-		memset(tmp, 0, sizeof(struct zt_hdlc));
-	}
-	return tmp;
-}
-
-#ifdef NEW_HDLC_INTERFACE
-static int zt_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));*/
-#ifdef LINUX26
-	struct zt_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 net_device_stats *stats = &ss->hdlcnetdev->netdev.stats;
-#endif	
-
-#else
-static int zt_xmit(hdlc_device *hdlc, struct sk_buff *skb)
-{
-	struct zt_chan *ss = hdlc_to_ztchan(hdlc);
-	struct net_device *dev = &ss->hdlcnetdev->netdev.netdev;
-	struct net_device_stats *stats = &ss->hdlcnetdev->netdev.stats;
-#endif
-	int retval = 1;
-	int x,oldbuf;
-	unsigned int fcs;
-	unsigned char *data;
-	unsigned long flags;
-	/* 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);
-		stats->tx_dropped++;
-		retval = 0;
-	} else if (ss->inwritebuf >= 0) {
-		/* We have a place to put this packet */
-		/* XXX We should keep the SKB and avoid the memcpy XXX */
-		data = ss->writebuf[ss->inwritebuf];
-		memcpy(data, skb->data, skb->len);
-		ss->writen[ss->inwritebuf] = skb->len;
-		ss->writeidx[ss->inwritebuf] = 0;
-		/* Calculate the FCS */
-		fcs = PPP_INITFCS;
-		for (x=0;x<skb->len;x++)
-			fcs = PPP_FCS(fcs, data[x]);
-		/* Invert it */
-		fcs ^= 0xffff;
-		/* Send it out LSB first */
-		data[ss->writen[ss->inwritebuf]++] = (fcs & 0xff);
-		data[ss->writen[ss->inwritebuf]++] = (fcs >> 8) & 0xff;
-		/* Advance to next window */
-		oldbuf = ss->inwritebuf;
-		ss->inwritebuf = (ss->inwritebuf + 1) % ss->numbufs;
-
-		if (ss->inwritebuf == ss->outwritebuf) {
-			/* Whoops, no more space.  */
-		    ss->inwritebuf = -1;
-
-		    netif_stop_queue(ztchan_to_dev(ss));
-		}
-		if (ss->outwritebuf < 0) {
-			/* Let the interrupt handler know there's
-			   some space for us */
-			ss->outwritebuf = oldbuf;
-		}
-		dev->trans_start = jiffies;
-		stats->tx_packets++;
-		stats->tx_bytes += ss->writen[oldbuf];
-#ifdef CONFIG_ZAPATA_DEBUG
-		printk("Buffered %d bytes to go out in buffer %d\n", ss->writen[oldbuf], oldbuf);
-		for (x=0;x<ss->writen[oldbuf];x++)
-		     printk("%02x ", ss->writebuf[oldbuf][x]);
-		printk("\n");
-#endif
-		retval = 0;
-		/* Free the SKB */
-		dev_kfree_skb_any(skb);
-	}
-	spin_unlock_irqrestore(&ss->lock, flags);
-	return retval;
-}
-
-#ifdef NEW_HDLC_INTERFACE
-static int zt_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)
-{
-	return -EIO;
-}
-#endif
-
-#endif
-
-#ifdef CONFIG_ZAPATA_PPP
-
-static int zt_ppp_xmit(struct ppp_channel *ppp, struct sk_buff *skb)
-{
-
-	/* 
-	 * If we can't handle the packet right now, return 0.  If we
-	 * 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;
-	int x,oldbuf;
-	unsigned int fcs;
-	unsigned char *data;
-	long flags;
-	int retval = 0;
-
-	/* See if we have any buffers */
-	spin_lock_irqsave(&ss->lock, flags);
-	if (!(ss->flags & ZT_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);
-		retval = 1;
-	} else if (ss->inwritebuf >= 0) {
-		/* We have a place to put this packet */
-		/* XXX We should keep the SKB and avoid the memcpy XXX */
-		data = ss->writebuf[ss->inwritebuf];
-		/* Start with header of two bytes */
-		/* Add "ALL STATIONS" and "UNNUMBERED" */
-		data[0] = 0xff;
-		data[1] = 0x03;
-		ss->writen[ss->inwritebuf] = 2;
-
-		/* Copy real data and increment amount written */
-		memcpy(data + 2, skb->data, skb->len);
-
-		ss->writen[ss->inwritebuf] += skb->len;
-
-		/* Re-set index back to zero */
-		ss->writeidx[ss->inwritebuf] = 0;
-
-		/* Calculate the FCS */
-		fcs = PPP_INITFCS;
-		for (x=0;x<skb->len + 2;x++)
-			fcs = PPP_FCS(fcs, data[x]);
-		/* Invert it */
-		fcs ^= 0xffff;
-
-		/* Point past the real data now */
-		data += (skb->len + 2);
-
-		/* Send FCS out LSB first */
-		data[0] = (fcs & 0xff);
-		data[1] = (fcs >> 8) & 0xff;
-
-		/* Account for FCS length */
-		ss->writen[ss->inwritebuf]+=2;
-
-		/* Advance to next window */
-		oldbuf = ss->inwritebuf;
-		ss->inwritebuf = (ss->inwritebuf + 1) % ss->numbufs;
-
-		if (ss->inwritebuf == ss->outwritebuf) {
-			/* Whoops, no more space.  */
-			ss->inwritebuf = -1;
-		}
-		if (ss->outwritebuf < 0) {
-			/* Let the interrupt handler know there's
-			   some space for us */
-			ss->outwritebuf = oldbuf;
-		}
-#ifdef CONFIG_ZAPATA_DEBUG
-		printk("Buffered %d bytes (skblen = %d) to go out in buffer %d\n", ss->writen[oldbuf], skb->len, oldbuf);
-		for (x=0;x<ss->writen[oldbuf];x++)
-		     printk("%02x ", ss->writebuf[oldbuf][x]);
-		printk("\n");
-#endif
-		retval = 1;
-	}
-	spin_unlock_irqrestore(&ss->lock, flags);
-	if (retval) {
-		/* Get rid of the SKB if we're returning non-zero */
-		/* N.B. this is called in process or BH context so
-		   dev_kfree_skb is OK. */
-		dev_kfree_skb(skb);
-	}
-	return retval;
-}
-
-static int zt_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,
-};
-
-#endif
-
-static void zt_chan_unreg(struct zt_chan *chan)
-{
-	int x;
-	unsigned long flags;
-#ifdef CONFIG_ZAPATA_NET
-	if (chan->flags & ZT_FLAG_NETDEV) {
-#ifdef LINUX26
-		unregister_hdlc_device(chan->hdlcnetdev->netdev);
-		free_netdev(chan->hdlcnetdev->netdev);
-#else
-		unregister_hdlc_device(&chan->hdlcnetdev->netdev);
-#endif
-		kfree(chan->hdlcnetdev);
-		chan->hdlcnetdev = NULL;
-	}
-#endif
-	write_lock_irqsave(&chan_lock, flags);
-	if (chan->flags & ZT_FLAG_REGISTERED) {
-		chans[chan->channo] = NULL;
-		chan->flags &= ~ZT_FLAG_REGISTERED;
-	}
-#ifdef CONFIG_ZAPATA_PPP
-	if (chan->ppp) {
-		printk("HUH???  PPP still attached??\n");
-	}
-#endif
-	maxchans = 0;
-	for (x=1;x<ZT_MAX_CHANNELS;x++) 
-		if (chans[x]) {
-			maxchans = x + 1;
-			/* Remove anyone pointing to us as master
-			   and make them their own thing */
-			if (chans[x]->master == 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)) {
-				/* Take them out of conference with us */
-				/* release conference resource if any */
-				if (chans[x]->confna) {
-					zt_check_conf(chans[x]->confna);
-					if (chans[x]->span && chans[x]->span->dacs)
-						chans[x]->span->dacs(chans[x], NULL);
-				}
-				chans[x]->confna = 0;
-				chans[x]->_confn = 0;
-				chans[x]->confmode = 0;
-			}
-		}
-	chan->channo = -1;
-	write_unlock_irqrestore(&chan_lock, flags);
-}
-
-static ssize_t zt_chan_read(struct file *file, char *usrbuf, size_t count, int unit)
-{
-	struct zt_chan *chan = chans[unit];
-	int amnt;
-	int res, rv;
-	int oldbuf,x;
-	unsigned long flags;
-	/* Make sure count never exceeds 65k, and make sure it's unsigned */
-	count &= 0xffff;
-	if (!chan) 
-		return -EINVAL;
-	if (count < 1)
-		return -EINVAL;
-	for(;;) {
-		spin_lock_irqsave(&chan->lock, flags);
-		if (chan->eventinidx != chan->eventoutidx) {
-			spin_unlock_irqrestore(&chan->lock, flags);
-			return -ELAST /* - chan->eventbuf[chan->eventoutidx]*/;
-		}
-		res = chan->outreadbuf;
-		if (chan->rxdisable)
-			res = -1;
-		spin_unlock_irqrestore(&chan->lock, flags);
-		if (res >= 0) break;
-		if (file->f_flags & O_NONBLOCK)
-			return -EAGAIN;
-		rv = schluffen(&chan->readbufq);
-		if (rv) return (rv);
-	}
-	amnt = count;
-/* added */
-#if 0
-	if ((unit == 24) || (unit == 48) || (unit == 16) || (unit == 47)) { 
-		int myamnt = amnt;
-		int x;
-		if (amnt > chan->readn[res])
-			myamnt = chan->readn[res];
-		printk("zt_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 (amnt > (chan->readn[res] << 1))
-			amnt = chan->readn[res] << 1;
-		if (amnt) {
-			/* There seems to be a max stack size, so we have
-			   to do this in smaller pieces */
-			short lindata[128];
-			int left = amnt >> 1; /* amnt is in bytes */
-			int pos = 0;
-			int pass;
-			while(left) {
-				pass = left;
-				if (pass > 128)
-					pass = 128;
-				for (x=0;x<pass;x++)
-					lindata[x] = ZT_XLAW(chan->readbuf[res][x + pos], chan);
-				if (copy_to_user(usrbuf + (pos << 1), lindata, pass << 1))
-					return -EFAULT;
-				left -= pass;
-				pos += pass;
-			}
-		}
-	} else {
-		if (amnt > chan->readn[res])
-			amnt = chan->readn[res];
-		if (amnt) {
-			if (copy_to_user(usrbuf, chan->readbuf[res], amnt))
-				return -EFAULT;
-		}
-	}
-	spin_lock_irqsave(&chan->lock, flags);
-	chan->readidx[res] = 0;
-	chan->readn[res] = 0;
-	oldbuf = res;
-	chan->outreadbuf = (res + 1) % chan->numbufs;
-	if (chan->outreadbuf == chan->inreadbuf) {
-		/* Out of stuff */
-		chan->outreadbuf = -1;
-		if (chan->rxbufpolicy == ZT_POLICY_WHEN_FULL)
-			chan->rxdisable = 1;
-	}
-	if (chan->inreadbuf < 0) {
-		/* Notify interrupt handler that we have some space now */
-		chan->inreadbuf = oldbuf;
-	}
-	spin_unlock_irqrestore(&chan->lock, flags);
-	
-	return amnt;
-}
-
-static ssize_t zt_chan_write(struct file *file, const char *usrbuf, size_t count, int unit)
-{
-	unsigned long flags;
-	struct zt_chan *chan = chans[unit];
-	int res, amnt, oldbuf, rv,x;
-	/* Make sure count never exceeds 65k, and make sure it's unsigned */
-	count &= 0xffff;
-	if (!chan) 
-		return -EINVAL;
-	if (count < 1)
-		return -EINVAL;
-	for(;;) {
-		spin_lock_irqsave(&chan->lock, flags);
-		if ((chan->curtone || chan->pdialcount) && !(chan->flags & ZT_FLAG_PSEUDO)) {
-			chan->curtone = NULL;
-			chan->tonep = 0;
-			chan->dialing = 0;
-			chan->txdialbuf[0] = '\0';
-			chan->pdialcount = 0;
-		}
-		if (chan->eventinidx != chan->eventoutidx) {
-			spin_unlock_irqrestore(&chan->lock, flags);
-			return -ELAST;
-		}
-		res = chan->inwritebuf;
-		spin_unlock_irqrestore(&chan->lock, flags);
-		if (res >= 0) 
-			break;
-		if (file->f_flags & O_NONBLOCK)
-			return -EAGAIN;
-		/* Wait for something to be available */
-		rv = schluffen(&chan->writebufq);
-		if (rv)
-			return rv;
-	}
-
-	amnt = count;
-	if (chan->flags & ZT_FLAG_LINEAR) {
-		if (amnt > (chan->blocksize << 1))
-			amnt = chan->blocksize << 1;
-	} else {
-		if (amnt > chan->blocksize)
-			amnt = chan->blocksize;
-	}
-
-#ifdef CONFIG_ZAPATA_DEBUG
-	printk("zt_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",
- 			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");
- 	}
-#endif
-
-	if (amnt) {
-		if (chan->flags & ZT_FLAG_LINEAR) {
-			/* There seems to be a max stack size, so we have
-			   to do this in smaller pieces */
-			short lindata[128];
-			int left = amnt >> 1; /* amnt is in bytes */
-			int pos = 0;
-			int pass;
-			while(left) {
-				pass = left;
-				if (pass > 128)
-					pass = 128;
-				if (copy_from_user(lindata, usrbuf + (pos << 1), pass << 1))
-					return -EFAULT;
-				left -= pass;
-				for (x=0;x<pass;x++)
-					chan->writebuf[res][x + pos] = ZT_LIN2X(lindata[x], chan);
-				pos += pass;
-			}
-			chan->writen[res] = amnt >> 1;
-		} else {
-			if (copy_from_user(chan->writebuf[res], usrbuf, amnt))
-				return -EFAULT;
-			chan->writen[res] = amnt;
-		}
-		chan->writeidx[res] = 0;
-		if (chan->flags & ZT_FLAG_FCS)
-			calc_fcs(chan, res);
-		oldbuf = res;
-		spin_lock_irqsave(&chan->lock, flags);
-		chan->inwritebuf = (res + 1) % chan->numbufs;
-		if (chan->inwritebuf == chan->outwritebuf) {
-			/* Don't stomp on the transmitter, just wait for them to 
-			   wake us up */
-			chan->inwritebuf = -1;
-			/* Make sure the transmitter is transmitting in case of POLICY_WHEN_FULL */
-			chan->txdisable = 0;
-		}
-		if (chan->outwritebuf < 0) {
-			/* Okay, the interrupt handler has been waiting for us.  Give them a buffer */
-			chan->outwritebuf = oldbuf;
-		}
-		spin_unlock_irqrestore(&chan->lock, flags);
-
-		if (chan->flags & ZT_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)
-{
-	/* Nothing to do, really */
-#ifndef LINUX26
-	MOD_INC_USE_COUNT;
-#endif
-	return 0;
-}
-
-static int zt_chan_open(struct inode *inode, struct file *file)
-{
-	/* Nothing to do here for now either */
-#ifndef LINUX26
-	MOD_INC_USE_COUNT;
-#endif
-	return 0;
-}
-
-static int zt_ctl_release(struct inode *inode, struct file *file)
-{
-	/* Nothing to do */
-#ifndef LINUX26
-	MOD_DEC_USE_COUNT;
-#endif
-	return 0;
-}
-
-static int zt_chan_release(struct inode *inode, struct file *file)
-{
-	/* Nothing to do for now */
-#ifndef LINUX26
-	MOD_DEC_USE_COUNT;
-#endif
-	return 0;
-}
-
-static void set_txtone(struct zt_chan *ss,int fac, int init_v2, int init_v3)
-{
-	if (fac == 0)
-	{
-		ss->v2_1 = 0;
-		ss->v3_1 = 0;
-		return;
-	}
-	ss->txtone = fac;
-	ss->v1_1 = 0;
-	ss->v2_1 = init_v2;
-	ss->v3_1 = init_v3;
-	return;
-}
-
-static void zt_rbs_sethook(struct zt_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
-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, 
-#ifdef CONFIG_CAC_GROUNDSTART
-		ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT, 0, 0 }, /* FXS Groundstart (CAC-style) */
-#else
-		ZT_ABIT | ZT_BBIT | ZT_CBIT | ZT_DBIT, ZT_ABIT | ZT_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 */
-	} ;
-	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);
-		return;
-	}
-	if ((txsig > 3) || (txsig < 0)) {
-		printk("zt_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",
-			txsig, chan->name, chan->span->name);
-		return;
-	}
-	/* Don't do anything for RBS */
-	if (chan->sig == ZT_SIG_DACS_RBS)
-		return;
-	chan->txstate = txstate;
-	
-	/* if tone signalling */
-	if (chan->sig == ZT_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))) 
-			{
-				set_txtone(chan,chan->txtone,chan->tx_v2,chan->tx_v3);
-			}
-			else
-			{
-				set_txtone(chan,0,0,0);
-			}
-		}
-		chan->otimer = timeout * ZT_CHUNKSIZE;			/* Otimer is timer in samples */
-		return;
-	}
-	if (chan->span->hooksig) {
-		if (chan->txhooksig != txsig) {
-			chan->txhooksig = txsig;
-			chan->span->hooksig(chan, txsig);
-		}
-		chan->otimer = timeout * ZT_CHUNKSIZE;			/* Otimer is timer in samples */
-		return;
-	} else {
-		for (x=0;x<NUM_SIGS;x++) {
-			if (outs[x][0] == chan->sig) {
-#ifdef CONFIG_ZAPATA_DEBUG
-				printk("Setting bits to %d for channel %s state %d in %d signalling\n", outs[x][txsig + 1], chan->name, txsig, chan->sig);
-#endif
-				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 */
-				return;
-			}
-		}
-	}
-	printk("zt_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)
-{
-	/* if no span, return as error */
-	if (!chan->span) return -1;
-	if (chan->span->rbsbits) {
-		chan->txsig = bits;
-		chan->span->rbsbits(chan, bits);
-	} else {
-		printk("Huh?  CAS setbits, but no RBS bits function\n");
-	}
-	return 0;
-}
-
-static int zt_hangup(struct zt_chan *chan)
-{
-	int x,res=0;
-
-	/* Can't hangup pseudo channels */
-	if (!chan->span)
-		return 0;
-	/* Can't hang up a clear channel */
-	if (chan->flags & (ZT_FLAG_CLEAR | ZT_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->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)) {
-			/* Do RBS signalling on the channel's behalf */
-			zt_rbs_sethook(chan, ZT_TXSIG_KEWL, ZT_TXSTATE_KEWL, ZT_KEWLTIME);
-		} else
-			zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_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);
-			} else
-				res = 0;
-		}
-	}
-	/* if not registered yet, just return here */
-	if (!(chan->flags & ZT_FLAG_REGISTERED)) return res;
-	/* Mark all buffers as empty */
-	for (x = 0;x < chan->numbufs;x++) {
-		chan->writen[x] = 
-		chan->writeidx[x]=
-		chan->readn[x]=
-		chan->readidx[x] = 0;
-	}	
-	if (chan->readbuf[0]) {
-		chan->inreadbuf = 0;
-		chan->inwritebuf = 0;
-	} else {
-		chan->inreadbuf = -1;
-		chan->inwritebuf = -1;
-	}
-	chan->outreadbuf = -1;
-	chan->outwritebuf = -1;
-	chan->dialing = 0;
-	chan->afterdialingtimer = 0;
-	chan->curtone = NULL;
-	chan->pdialcount = 0;
-	chan->cadencepos = 0;
-	chan->txdialbuf[0] = 0;
-	return res;
-}
-
-static int initialize_channel(struct zt_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)))
-		return res;
-
-	spin_lock_irqsave(&chan->lock, flags);
-
-	chan->rxbufpolicy = ZT_POLICY_IMMEDIATE;
-	chan->txbufpolicy = ZT_POLICY_IMMEDIATE;
-
-	/* Free up the echo canceller if there is one */
-	ec = chan->ec;
-	chan->ec = NULL;
-	chan->echocancel = 0;
-	chan->echostate = ECHO_STATE_IDLE;
-	chan->echolastupdate = 0;
-	chan->echotimer = 0;
-
-	chan->txdisable = 0;
-	chan->rxdisable = 0;
-
-	chan->digitmode = DIGIT_MODE_DTMF;
-	chan->dialing = 0;
-	chan->afterdialingtimer = 0;
-
-	chan->cadencepos = 0;
-	chan->firstcadencepos = 0; /* By default loop back to first cadence position */
-
-	/* HDLC & FCS stuff */
-	fasthdlc_init(&chan->rxhdlc);
-	fasthdlc_init(&chan->txhdlc);
-	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;
-	
-	if (chan->sig & __ZT_SIG_FXO)
-		chan->starttime = ZT_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;
-	
-	/* Initialize RBS timers */
-	chan->itimerset = chan->itimer = chan->otimer = 0;
-	chan->ringdebtimer = 0;		
-
-	init_waitqueue_head(&chan->sel);
-	init_waitqueue_head(&chan->readbufq);
-	init_waitqueue_head(&chan->writebufq);
-	init_waitqueue_head(&chan->eventbufq);
-	init_waitqueue_head(&chan->txstateq);
-
-	/* Reset conferences */
-	reset_conf(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) {
-		chan->confna = 0;
-		chan->confmode = 0;
-		if (chan->span && chan->span->dacs)
-			chan->span->dacs(chan, NULL);
-	}
-	chan->_confn = 0;
-	memset(chan->conflast, 0, sizeof(chan->conflast));
-	memset(chan->conflast1, 0, sizeof(chan->conflast1));
-	memset(chan->conflast2, 0, sizeof(chan->conflast2));
-	chan->confmute = 0;
-	chan->gotgs = 0;
-	chan->curtone = NULL;
-	chan->tonep = 0;
-	chan->pdialcount = 0;
-	if (chan->gainalloc && chan->rxgain)
-		rxgain = chan->rxgain;
-	chan->rxgain = defgain;
-	chan->txgain = defgain;
-	chan->gainalloc = 0;
-	chan->eventinidx = chan->eventoutidx = 0;
-	zt_set_law(chan,0);
-	zt_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 == ZT_SIG_CLEAR) || (chan->sig == ZT_SIG_HARDHDLC))
-		chan->flags &= ~(ZT_FLAG_PPP | ZT_FLAG_FCS | ZT_FLAG_HDLC);
-
-	chan->flags &= ~ZT_FLAG_LINEAR;
-	if (chan->curzone) {
-		/* Take cadence from tone zone */
-		memcpy(chan->ringcadence, chan->curzone->ringcadence, sizeof(chan->ringcadence));
-	} else {
-		/* Do a default */
-		memset(chan->ringcadence, 0, sizeof(chan->ringcadence));
-		chan->ringcadence[0] = chan->starttime;
-		chan->ringcadence[1] = ZT_RINGOFFTIME;
-	}
-
-	spin_unlock_irqrestore(&chan->lock, flags);
-	set_tone_zone(chan, -1);
-
-	if (chan->span && chan->span->echocan)
-		chan->span->echocan(chan, 0);
-
-	if (rxgain)
-		kfree(rxgain);
-	if (ec)
-		echo_can_free(ec);
-	return 0;
-}
-
-static int zt_timing_open(struct inode *inode, struct file *file)
-{
-	struct zt_timer *t;
-	unsigned long flags;
-	t = kmalloc(sizeof(struct zt_timer), GFP_KERNEL);
-	if (!t)
-		return -ENOMEM;
-	/* Allocate a new timer */
-	memset(t, 0, sizeof(struct zt_timer));
-	init_waitqueue_head(&t->sel);
-	file->private_data = t;
-#ifndef LINUX26
-	MOD_INC_USE_COUNT;
-#endif
-	spin_lock_irqsave(&zaptimerlock, flags);
-	t->next = zaptimers;
-	zaptimers = t;
-	spin_unlock_irqrestore(&zaptimerlock, flags);
-	return 0;
-}
-
-static int zt_timer_release(struct inode *inode, struct file *file)
-{
-	struct zt_timer *t, *cur, *prev;
-	unsigned long flags;
-	t = file->private_data;
-	if (t) {
-		spin_lock_irqsave(&zaptimerlock, flags);
-		prev = NULL;
-		cur = zaptimers;
-		while(cur) {
-			if (t == cur)
-				break;
-			prev = cur;
-			cur = cur->next;
-		}
-		if (cur) {
-			if (prev)
-				prev->next = cur->next;
-			else
-				zaptimers = cur->next;
-		}
-		spin_unlock_irqrestore(&zaptimerlock, flags);
-		if (!cur) {
-			printk("Zap Timer: Not on list??\n");
-			return 0;
-		}
-		kfree(t);
-#ifndef LINUX26
-		MOD_DEC_USE_COUNT;
-#endif		
-	}
-	return 0;
-}
-
-static int zt_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_OPEN) 
-			res = -EBUSY;
-		else if (chans[unit]->flags & ZT_FLAG_NETDEV)
-			res = -EBUSY;
-		else if (chans[unit]->master != chans[unit])
-			res = -EBUSY;
-		else if ((chans[unit]->sig & __ZT_SIG_DACS) == __ZT_SIG_DACS)
-			res = -EBUSY;
-		else {
-			unsigned long flags;
-			/* Assume everything is going to be okay */
-			res = initialize_channel(chans[unit]);
-			spin_lock_irqsave(&chans[unit]->lock, flags);
-			if (chans[unit]->flags & ZT_FLAG_PSEUDO) 
-				chans[unit]->flags |= ZT_FLAG_AUDIO;
-			if (chans[unit]->span && chans[unit]->span->open) {
-				res = chans[unit]->span->open(chans[unit]);
-			}
-			if (!res) {
-				chans[unit]->file = file;
-#ifndef LINUX26
-				if (inc)
-					MOD_INC_USE_COUNT;
-#endif					
-				chans[unit]->flags |= ZT_FLAG_OPEN;
-				spin_unlock_irqrestore(&chans[unit]->lock, flags);
-			} else {
-				spin_unlock_irqrestore(&chans[unit]->lock, flags);
-				close_channel(chans[unit]);
-			}
-		}
-	} else
-		res = -ENXIO;
-	return res;
-}
-
-static int zt_specchan_release(struct inode *node, struct file *file, int unit)
-{
-	int res=0;
-	if (chans[unit]) {
-		unsigned long flags;
-		spin_lock_irqsave(&chans[unit]->lock, flags);
-		chans[unit]->flags &= ~ZT_FLAG_OPEN;
-		spin_unlock_irqrestore(&chans[unit]->lock, flags);
-		chans[unit]->file = NULL;
-		close_channel(chans[unit]);
-		if (chans[unit]->span && chans[unit]->span->close)
-			res = chans[unit]->span->close(chans[unit]);
-	} else
-		res = -ENXIO;
-#ifndef LINUX26
-	MOD_DEC_USE_COUNT;
-#endif
-	return res;
-}
-
-static struct zt_chan *zt_alloc_pseudo(void)
-{
-	struct zt_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);
-	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;
-	spin_lock_irqsave(&bigzaplock, flags);
-	if (zt_chan_reg(pseudo)) {
-		kfree(pseudo);
-		pseudo = NULL;
-	} else
-		sprintf(pseudo->name, "Pseudo/%d", pseudo->channo);
-	spin_unlock_irqrestore(&bigzaplock, flags);
-	return pseudo;	
-}
-
-static void zt_free_pseudo(struct zt_chan *pseudo)
-{
-	unsigned long flags;
-	if (pseudo) {
-		spin_lock_irqsave(&bigzaplock, flags);
-		zt_chan_unreg(pseudo);
-		spin_unlock_irqrestore(&bigzaplock, flags);
-		kfree(pseudo);
-	}
-}
-
-static int zt_open(struct inode *inode, struct file *file)
-{
-	int unit = UNIT(file);
-	int ret = -ENXIO;
-	struct zt_chan *chan;
-	/* Minor 0: Special "control" descriptor */
-	if (!unit) 
-		return zt_ctl_open(inode, file);
-	if (unit == 250) {
-		if (!zt_transcode_fops)
-			request_module("zttranscode");
-		if (zt_transcode_fops && zt_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);
-#else
-			if (try_module_get(zt_transcode_fops->owner)) {
-#endif
-				ret = zt_transcode_fops->open(inode, file);
-				if (ret)
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-					__MOD_DEC_USE_COUNT (zt_transcode_fops->owner);
-#else
-					module_put(zt_transcode_fops->owner);
-#endif
-			}
-			return ret;
-		}
-		return -ENXIO;
-	}
-	if (unit == 253) {
-		if (maxspans) {
-			return zt_timing_open(inode, file);
-		} else {
-			return -ENXIO;
-		}
-	}
-	if (unit == 254)
-		return zt_chan_open(inode, file);
-	if (unit == 255) {
-		if (maxspans) {
-			chan = zt_alloc_pseudo();
-			if (chan) {
-				file->private_data = chan;
-				return zt_specchan_open(inode, file, chan->channo, 1);
-			} else {
-				return -ENXIO;
-			}
-		} else
-			return -ENXIO;
-	}
-	return zt_specchan_open(inode, file, unit, 1);
-}
-
-#if 0
-static int zt_open(struct inode *inode, struct file *file)
-{
-	int res;
-	unsigned long flags;
-	spin_lock_irqsave(&bigzaplock, flags);
-	res = __zt_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)
-{
-	int unit = UNIT(file);
-	struct zt_chan *chan;
-
-	/* Can't read from control */
-	if (!unit) {
-		return -EINVAL;
-	}
-	
-	if (unit == 253) 
-		return -EINVAL;
-	
-	if (unit == 254) {
-		chan = file->private_data;
-		if (!chan)
-			return -EINVAL;
-		return zt_chan_read(file, usrbuf, count, chan->channo);
-	}
-	
-	if (unit == 255) {
-		chan = file->private_data;
-		if (!chan) {
-			printk("No pseudo channel structure to read?\n");
-			return -EINVAL;
-		}
-		return zt_chan_read(file, usrbuf, count, chan->channo);
-	}
-	if (count < 0)
-		return -EINVAL;
-
-	return zt_chan_read(file, usrbuf, count, unit);
-}
-
-static ssize_t zt_write(struct file *file, const char *usrbuf, size_t count, loff_t *ppos)
-{
-	int unit = UNIT(file);
-	struct zt_chan *chan;
-	/* Can't read from control */
-	if (!unit)
-		return -EINVAL;
-	if (count < 0)
-		return -EINVAL;
-	if (unit == 253)
-		return -EINVAL;
-	if (unit == 254) {
-		chan = file->private_data;
-		if (!chan)
-			return -EINVAL;
-		return zt_chan_write(file, usrbuf, count, chan->channo);
-	}
-	if (unit == 255) {
-		chan = file->private_data;
-		if (!chan) {
-			printk("No pseudo channel structure to read?\n");
-			return -EINVAL;
-		}
-		return zt_chan_write(file, usrbuf, count, chan->channo);
-	}
-	return zt_chan_write(file, usrbuf, count, unit);
-	
-}
-
-/* No bigger than 32k for everything per tone zone */
-#define MAX_SIZE 32768
-/* No more than 128 subtones */
-#define MAX_TONES 128
-
-/* The tones to be loaded can (will) be a mix of regular tones,
-   DTMF tones and MF tones. We need to load DTMF and MF tones
-   a bit differently than regular tones because their storage
-   format is much simpler (an array structure field of the zone
-   structure, rather an array of pointers).
-*/
-static int ioctl_load_zone(unsigned long data)
-{
-	struct zt_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;
-	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)))
-		return -EFAULT;
-
-	data += sizeof(th);
-
-	if ((th.count < 0) || (th.count > MAX_TONES)) {
-		printk("Too many tones included\n");
-		return -EINVAL;
-	}
-
-	space = size = sizeof(*z) + th.count * sizeof(*t);
-
-	if (size > MAX_SIZE)
-		return -E2BIG;
-
-	if (!(z = ptr = slab = kmalloc(size, GFP_KERNEL)))
-		return -ENOMEM;
-
-	memset(slab, 0, size);
-
-	ptr += sizeof(*z);
-	space -= sizeof(*z);
-
-	strncpy(z->name, th.name, sizeof(z->name) - 1);
-
-	for (x = 0; x < ZT_MAX_CADENCE; x++)
-		z->ringcadence[x] = th.ringcadence[x];
-
-	atomic_set(&z->refcount, 0);
-
-	for (x = 0; x < th.count; x++) {
-		enum {
-			REGULAR_TONE,
-			DTMF_TONE,
-			MF_TONE,
-		} tone_type;
-
-		if (space < sizeof(*t)) {
-			kfree(slab);
-			printk("Insufficient tone zone space\n");
-			return -EINVAL;
-		}
-
-		if (copy_from_user(&td, (struct zt_tone_def *) data, sizeof(td))) {
-			kfree(slab);
-			return -EFAULT;
-		}
-
-		data += sizeof(td);
-
-		if ((td.tone >= 0) && (td.tone < ZT_TONE_MAX)) {
-			tone_type = REGULAR_TONE;
-
-			t = samples[x] = ptr;
-
-			space -= sizeof(*t);
-			ptr += sizeof(*t);
-
-			/* Remember which sample is next */
-			next[x] = td.next;
-			
-			/* Make sure the "next" one is sane */
-			if ((next[x] >= th.count) || (next[x] < 0)) {
-				printk("Invalid 'next' pointer: %d\n", next[x]);
-				kfree(slab);
-				return -EINVAL;
-			}
-		} else if ((td.tone >= ZT_TONE_DTMF_BASE) &&
-			   (td.tone <= ZT_TONE_DTMF_MAX)) {
-			tone_type = DTMF_TONE;
-
-			td.tone -= ZT_TONE_DTMF_BASE;
-			t = &z->dtmf[td.tone];
-		} else if ((td.tone >= ZT_TONE_MF_BASE) &&
-			   (td.tone <= ZT_TONE_MF_MAX)) {
-			tone_type = MF_TONE;
-
-			td.tone -= ZT_TONE_MF_BASE;
-			t = &z->mf[td.tone];
-		} else {
-			printk("Invalid tone (%d) defined\n", td.tone);
-			kfree(slab);
-			return -EINVAL;
-		}
-
-		t->fac1 = td.fac1;
-		t->init_v2_1 = td.init_v2_1;
-		t->init_v3_1 = td.init_v3_1;
-		t->fac2 = td.fac2;
-		t->init_v2_2 = td.init_v2_2;
-		t->init_v3_2 = td.init_v3_2;
-		t->modulate = td.modulate;
-
-		switch (tone_type) {
-		case REGULAR_TONE:
-			t->tonesamples = td.samples;
-			if (!z->tones[td.tone])
-				z->tones[td.tone] = t;
-			break;
-		case DTMF_TONE:
-			t->tonesamples = global_dialparams.dtmf_tonelen;
-			t->next = &dtmf_silence;
-			z->dtmf_continuous[td.tone] = *t;
-			z->dtmf_continuous[td.tone].next = &z->dtmf_continuous[td.tone];
-			break;
-		case MF_TONE:
-			t->tonesamples = global_dialparams.mfv1_tonelen;
-			t->next = &mfv1_silence;
-			/* Special case for K/P tone */
-			if (td.tone == 10)
-				t->tonesamples *= 5 / 3;
-			z->mf_continuous[td.tone] = *t;
-			z->mf_continuous[td.tone].next = &z->mf_continuous[td.tone];
-			break;
-		}
-	}
-
-	for (x = 0; x < th.count; x++) {
-		if (samples[x])
-			samples[x]->next = samples[next[x]];
-	}
-
-	if ((res = zt_register_tone_zone(th.zone, z)))
-		kfree(slab);
-
-	return res;
-}
-
-void zt_init_tone_state(struct zt_tone_state *ts, struct zt_tone *zt)
-{
-	ts->v1_1 = 0;
-	ts->v2_1 = zt->init_v2_1;
-	ts->v3_1 = zt->init_v3_1;
-	ts->v1_2 = 0;
-	ts->v2_2 = zt->init_v2_2;
-	ts->v3_2 = zt->init_v3_2;
-	ts->modulate = zt->modulate;
-}
-
-struct zt_tone *zt_dtmf_tone(const struct zt_chan *chan, char digit)
-{
-	struct zt_tone *z;
-
-	switch (chan->digitmode) {
-	case DIGIT_MODE_DTMF:
-		z = &chan->curzone->dtmf[0];
-		break;
-	case DIGIT_MODE_MFV1:
-		z = &chan->curzone->mf[0];
-		break;
-	default:
-		z = NULL;
-	}
-
-	switch (digit) {
-	case '0':
-	case '1':
-	case '2':
-	case '3':
-	case '4':
-	case '5':
-	case '6':
-	case '7':
-	case '8':
-	case '9':
-		return z + (digit - '0');
-	case '*':
-		return z + 10;
-	case '#':
-		return z + 11;
-	case 'A':
-	case 'B':
-	case 'C':
-		return z + (digit + 12 - 'A');
-	case 'D':
-		if (chan->digitmode == DIGIT_MODE_MFV1)
-			return NULL;
-		else
-			return z + (digit + 12 - 'A');
-	case 'W':
-		return &tone_pause;
-	}
-
-	return NULL;
-}
-
-static void __do_dtmf(struct zt_chan *chan)
-{
-	char c;
-
-	/* Called with chan->lock held */
-	while ((c = chan->txdialbuf[0])) {
-		memmove(chan->txdialbuf, chan->txdialbuf + 1, sizeof(chan->txdialbuf) - 1);
-		switch (c) {
-		case 'T':
-			chan->digitmode = DIGIT_MODE_DTMF;
-			chan->tonep = 0;
-			break;
-		case 'M':
-			chan->digitmode = DIGIT_MODE_MFV1;
-			chan->tonep = 0;
-			break;
-		case 'P':
-			chan->digitmode = DIGIT_MODE_PULSE;
-			chan->tonep = 0;
-			break;
-		default:
-			if ((c != 'W') && (chan->digitmode == DIGIT_MODE_PULSE)) {
-				if ((c >= '0') && (c <= '9') && (chan->txhooksig == ZT_TXSIG_OFFHOOK)) {
-					chan->pdialcount = (c == '0') ? 10 : c - '0';
-					zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_PULSEBREAK,
-						       chan->pulsebreaktime);
-					return;
-				}
-			} else {
-				chan->curtone = zt_dtmf_tone(chan, c);
-				chan->tonep = 0;
-				if (chan->curtone) {
-					zt_init_tone_state(&chan->ts, chan->curtone);
-					return;
-				}
-			}
-		}
-	}
-
-	/* Notify userspace process if there is nothing left */
-	chan->dialing = 0;
-	__qevent(chan, ZT_EVENT_DIALCOMPLETE);
-}
-
-static int zt_release(struct inode *inode, struct file *file)
-{
-	int unit = UNIT(file);
-	int res;
-	struct zt_chan *chan;
-
-	if (!unit) 
-		return zt_ctl_release(inode, file);
-	if (unit == 253) {
-		return zt_timer_release(inode, file);
-	}
-	if (unit == 250) {
-		res = zt_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);
-#else
-		module_put(zt_transcode_fops->owner);
-#endif
-		return res;
-	}
-	if (unit == 254) {
-		chan = file->private_data;
-		if (!chan)
-			return zt_chan_release(inode, file);
-		else
-			return zt_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);
-		} else {
-			printk("Pseudo release and no private data??\n");
-			res = 0;
-		}
-		return res;
-	}
-	return zt_specchan_release(inode, file, unit);
-}
-
-#if 0
-static int zt_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);
-	spin_unlock_irqrestore(&bigzaplock, flags);
-	return res;
-}
-#endif
-
-
-void zt_alarm_channel(struct zt_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);
-	}
-	spin_unlock_irqrestore(&chan->lock, flags);
-}
-
-void zt_alarm_notify(struct zt_span *span)
-{
-	int x;
-
-	span->alarms &= ~ZT_ALARM_LOOPBACK;
-	/* Determine maint status */
-	if (span->maintstat || span->mainttimer)
-		span->alarms |= ZT_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)) */
-	/* if change in general state */
-	if ((!span->alarms) != (!span->lastalarms)) {
-		span->lastalarms = span->alarms;
-		for (x = 0; x < span->channels; x++)
-			zt_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(master != spans[x])
-					printk("Zaptel: Master changed to %s\n", spans[x]->name);
-				master = spans[x];
-				break;
-			}
-		}
-	}
-}
-
-#define VALID_SPAN(j) do { \
-	if ((j >= ZT_MAX_SPANS) || (j < 1)) \
-		return -EINVAL; \
-	if (!spans[j]) \
-		return -ENXIO; \
-} while(0)
-
-#define CHECK_VALID_SPAN(j) do { \
-	/* Start a given span */ \
-	if (get_user(j, (int *)data)) \
-		return -EFAULT; \
-	VALID_SPAN(j); \
-} while(0)
-
-#define VALID_CHANNEL(j) do { \
-	if ((j >= ZT_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)
-{
-	int j;
-	unsigned long flags;
-	switch(cmd) {
-	case ZT_TIMERCONFIG:
-		get_user(j, (int *)data);
-		if (j < 0)
-			j = 0;
-		spin_lock_irqsave(&zaptimerlock, flags);
-		timer->ms = timer->pos = j;
-		spin_unlock_irqrestore(&zaptimerlock, flags);
-		break;
-	case ZT_TIMERACK:
-		get_user(j, (int *)data);
-		spin_lock_irqsave(&zaptimerlock, flags);
-		if ((j < 1) || (j > timer->tripped))
-			j = timer->tripped;
-		timer->tripped -= j;
-		spin_unlock_irqrestore(&zaptimerlock, flags);
-		break;
-	case ZT_GETEVENT:  /* Get event on queue */
-		j = ZT_EVENT_NONE;
-		spin_lock_irqsave(&zaptimerlock, flags);
-		  /* set up for no event */
-		if (timer->tripped)
-			j = ZT_EVENT_TIMER_EXPIRED;
-		if (timer->ping)
-			j = ZT_EVENT_TIMER_PING;
-		spin_unlock_irqrestore(&zaptimerlock, flags);
-		put_user(j,(int *)data);
-		break;
-	case ZT_TIMERPING:
-		spin_lock_irqsave(&zaptimerlock, flags);
-		timer->ping = 1;
-		wake_up_interruptible(&timer->sel);
-		spin_unlock_irqrestore(&zaptimerlock, flags);
-		break;
-	case ZT_TIMERPONG:
-		spin_lock_irqsave(&zaptimerlock, flags);
-		timer->ping = 0;
-		spin_unlock_irqrestore(&zaptimerlock, flags);
-		break;
-	default:
-		return -ENOTTY;
-	}
-	return 0;
-}
-
-static int zt_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;
-	} stack;
-	struct zt_chan *chan;
-	unsigned long flags;
-	unsigned char *txgain, *rxgain;
-	struct zt_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))
-			return -EFAULT;
-
-		/* check to see if the caller wants to receive our master channel number */
-		if (stack.param.channo & ZT_GET_PARAMS_RETURN_MASTER) {
-			return_master = 1;
-			stack.param.channo &= ~ZT_GET_PARAMS_RETURN_MASTER;
-		}
-
-		/* Pick the right channo's */
-		if (!stack.param.channo || unit) {
-			stack.param.channo = unit;
-		}
-		/* Check validity of channel */
-		VALID_CHANNEL(stack.param.channo);
-		chan = chans[stack.param.channo];
-
-		/* point to relevant structure */
-		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); 
-			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));
-			}
-		} else if ((chan->txstate == ZT_TXSTATE_KEWL) || (chan->txstate == ZT_TXSTATE_AFTERKEWL))
-			stack.param.rxisoffhook = 1;
-		else
-			stack.param.rxisoffhook = 0;
-		if (chan->span && chan->span->rbsbits && !(chan->sig & ZT_SIG_CLEAR)) {
-			stack.param.rxbits = chan->rxsig;
-			stack.param.txbits = chan->txsig;
-			stack.param.idlebits = chan->idlebits;
-		} else {
-			stack.param.rxbits = -1;
-			stack.param.txbits = -1;
-			stack.param.idlebits = 0;
-		}
-		if (chan->span && (chan->span->rbsbits || chan->span->hooksig) && 
-			!(chan->sig & ZT_SIG_CLEAR)) {
-			stack.param.rxhooksig = chan->rxhooksig;
-			stack.param.txhooksig = chan->txhooksig;
-		} else {
-			stack.param.rxhooksig = -1;
-			stack.param.txhooksig = -1;
-		}
-		stack.param.prewinktime = chan->prewinktime; 
-		stack.param.preflashtime = chan->preflashtime;		
-		stack.param.winktime = chan->winktime;
-		stack.param.flashtime = chan->flashtime;
-		stack.param.starttime = chan->starttime;
-		stack.param.rxwinktime = chan->rxwinktime;
-		stack.param.rxflashtime = chan->rxflashtime;
-		stack.param.debouncetime = chan->debouncetime;
-		stack.param.channo = chan->channo;
-		stack.param.chan_alarms = chan->chan_alarms;
-
-		/* if requested, put the master channel number in the top 16 bits of the result */
-		if (return_master)
-			stack.param.channo |= chan->master->channo << 16;
-
-		stack.param.pulsemaketime = chan->pulsemaketime;
-		stack.param.pulsebreaktime = chan->pulsebreaktime;
-		stack.param.pulseaftertime = chan->pulseaftertime;
-		if (chan->span) stack.param.spanno = chan->span->spanno;
-			else stack.param.spanno = 0;
-		strncpy(stack.param.name, chan->name, sizeof(stack.param.name) - 1);
-		stack.param.chanpos = chan->chanpos;
-		stack.param.sigcap = chan->sigcap;
-		/* Return current law */
-		if (chan->xlaw == __zt_alaw)
-			stack.param.curlaw = ZT_LAW_ALAW;
-		else
-			stack.param.curlaw = ZT_LAW_MULAW;
-
-		if (copy_to_user((struct zt_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 
-		 * 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)))
-			return -EFAULT;
-
-		stack.param.chan_alarms = 0; /* be explicit about the above */
-
-		/* Pick the right channo's */
-		if (!stack.param.channo || unit) {
-			stack.param.channo = unit;
-		}
-		/* Check validity of channel */
-		VALID_CHANNEL(stack.param.channo);
-		chan = chans[stack.param.channo];
-		  /* point to relevant structure */
-		/* NOTE: sigtype is *not* included in this */
-		  /* get timing stack.paramters */
-		chan->prewinktime = stack.param.prewinktime;
-		chan->preflashtime = stack.param.preflashtime;
-		chan->winktime = stack.param.winktime;
-		chan->flashtime = stack.param.flashtime;
-		chan->starttime = stack.param.starttime;
-		/* Update ringtime if not using a tone zone */
-		if (!chan->curzone)
-			chan->ringcadence[0] = chan->starttime;
-		chan->rxwinktime = stack.param.rxwinktime;
-		chan->rxflashtime = stack.param.rxflashtime;
-		chan->debouncetime = stack.param.debouncetime;
-		chan->pulsemaketime = stack.param.pulsemaketime;
-		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)))
-			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);
-		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)))
-			return -EFAULT;
-		break;
-	case ZT_SETGAINS:  /* set gain stuff */
-		if (copy_from_user(&stack.gain,(struct zt_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);
-
-		rxgain = kmalloc(512, GFP_KERNEL);
-		if (!rxgain)
-			return -ENOMEM;
-
-		stack.gain.chan = i; /* put the span # in here */
-		txgain = rxgain + 256;
-
-		for (j=0;j<256;j++) {
-			rxgain[j] = stack.gain.rxgain[j];
-			txgain[j] = stack.gain.txgain[j];
-		}
-
-		if (!memcmp(rxgain, defgain, 256) && 
-		    !memcmp(txgain, defgain, 256)) {
-			if (rxgain)
-				kfree(rxgain);
-			spin_lock_irqsave(&chans[i]->lock, flags);
-			if (chans[i]->gainalloc)
-				kfree(chans[i]->rxgain);
-			chans[i]->gainalloc = 0;
-			chans[i]->rxgain = defgain;
-			chans[i]->txgain = defgain;
-			spin_unlock_irqrestore(&chans[i]->lock, flags);
-		} else {
-			/* This is a custom gain setting */
-			spin_lock_irqsave(&chans[i]->lock, flags);
-			if (chans[i]->gainalloc)
-				kfree(chans[i]->rxgain);
-			chans[i]->gainalloc = 1;
-			chans[i]->rxgain = rxgain;
-			chans[i]->txgain = txgain;
-			spin_unlock_irqrestore(&chans[i]->lock, flags);
-		}
-		if (copy_to_user((struct zt_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))
-			return -EFAULT;
-		i = stack.spaninfo.spanno; /* get specified span number */
-		if ((i < 0) || (i >= maxspans)) return(-EINVAL);  /* if bad span no */
-		if (i == 0) {
-			/* if to figure it out for this chan */
-			if (!chans[unit])
-				return -EINVAL;
-			i = chans[unit]->span->spanno;
-		}
-		if (!spans[i])
-			return -EINVAL;
-		stack.spaninfo.spanno = i; /* put the span # in here */
-		stack.spaninfo.totalspans = 0;
-		if (maxspans) stack.spaninfo.totalspans = maxspans - 1; /* put total number of spans here */
-		strncpy(stack.spaninfo.desc, spans[i]->desc, sizeof(stack.spaninfo.desc) - 1);
-		strncpy(stack.spaninfo.name, spans[i]->name, sizeof(stack.spaninfo.name) - 1);
-		stack.spaninfo.alarms = spans[i]->alarms;		/* get alarm status */
-		stack.spaninfo.bpvcount = spans[i]->bpvcount;	/* get BPV count */
-		stack.spaninfo.rxlevel = spans[i]->rxlevel;	/* get rx level */
-		stack.spaninfo.txlevel = spans[i]->txlevel;	/* get tx level */
-		stack.spaninfo.crc4count = spans[i]->crc4count;	/* get CRC4 error count */
-		stack.spaninfo.ebitcount = spans[i]->ebitcount;	/* get E-bit error count */
-		stack.spaninfo.fascount = spans[i]->fascount;	/* get FAS error count */
-		stack.spaninfo.irqmisses = spans[i]->irqmisses;	/* get IRQ miss count */
-		stack.spaninfo.syncsrc = spans[i]->syncsrc;	/* get active sync source */
-		stack.spaninfo.totalchans = spans[i]->channels;
-		stack.spaninfo.numchans = 0;
-		for (j = 0; j < spans[i]->channels; j++) {
-			if (spans[i]->chans[j].sig)
-				stack.spaninfo.numchans++;
-		}
-		/* version 2 fields */
-		stack.spaninfo.lbo = spans[i]->lbo;
-		stack.spaninfo.lineconfig = spans[i]->lineconfig;
-		/* version 3 fields */
-		stack.spaninfo.irq = spans[i]->irq;
-		stack.spaninfo.linecompat = spans[i]->linecompat;
-		strncpy(stack.spaninfo.lboname, zt_lboname(spans[i]->lbo), sizeof(stack.spaninfo.lboname) - 1);
-		if (spans[i]->manufacturer)
-			strncpy(stack.spaninfo.manufacturer, spans[i]->manufacturer,
-				sizeof(stack.spaninfo.manufacturer) - 1);
-		if (spans[i]->devicetype)
-			strncpy(stack.spaninfo.devicetype, spans[i]->devicetype, sizeof(stack.spaninfo.devicetype) - 1);
-		strncpy(stack.spaninfo.location, spans[i]->location, sizeof(stack.spaninfo.location) - 1);
-		if (spans[i]->spantype)
-			strncpy(stack.spaninfo.spantype, spans[i]->spantype, sizeof(stack.spaninfo.spantype) - 1);
-		
-		if (copy_to_user((struct zt_spaninfo *) data, &stack.spaninfo, size_to_copy))
-			return -EFAULT;
-		break;
-	case ZT_CHANDIAG:
-		get_user(j, (int *)data); /* get channel number from user */
-		/* make sure its a valid channel number */
-		if ((j < 1) || (j >= maxchans))
-			return -EINVAL;
-		/* if channel not mapped, not there */
-		if (!chans[j]) 
-			return -EINVAL;
-
-		if (!(mychan = kmalloc(sizeof(*mychan), GFP_KERNEL)))
-			return -ENOMEM;
-
-		/* lock channel */
-		spin_lock_irqsave(&chans[j]->lock, flags);
-		/* make static copy of channel */
-		memcpy(mychan, chans[j], sizeof(*mychan));
-		/* release it. */
-		spin_unlock_irqrestore(&chans[j]->lock, flags);
-
-		printk(KERN_INFO "Dump of Zaptel Channel %d (%s,%d,%d):\n\n",j,
-			mychan->name,mychan->channo,mychan->chanpos);
-		printk(KERN_INFO "flags: %x hex, writechunk: %08lx, readchunk: %08lx\n",
-			mychan->flags, (long) mychan->writechunk, (long) mychan->readchunk);
-		printk(KERN_INFO "rxgain: %08lx, txgain: %08lx, gainalloc: %d\n",
-			(long) mychan->rxgain, (long)mychan->txgain, mychan->gainalloc);
-		printk(KERN_INFO "span: %08lx, sig: %x hex, sigcap: %x hex\n",
-			(long)mychan->span, mychan->sig, mychan->sigcap);
-		printk(KERN_INFO "inreadbuf: %d, outreadbuf: %d, inwritebuf: %d, outwritebuf: %d\n",
-			mychan->inreadbuf, mychan->outreadbuf, mychan->inwritebuf, mychan->outwritebuf);
-		printk(KERN_INFO "blocksize: %d, numbufs: %d, txbufpolicy: %d, txbufpolicy: %d\n",
-			mychan->blocksize, mychan->numbufs, mychan->txbufpolicy, mychan->rxbufpolicy);
-		printk(KERN_INFO "txdisable: %d, rxdisable: %d, iomask: %d\n",
-			mychan->txdisable, mychan->rxdisable, mychan->iomask);
-		printk(KERN_INFO "curzone: %08lx, tonezone: %d, curtone: %08lx, tonep: %d\n",
-			(long) mychan->curzone, mychan->tonezone, (long) mychan->curtone, mychan->tonep);
-		printk(KERN_INFO "digitmode: %d, txdialbuf: %s, dialing: %d, aftdialtimer: %d, cadpos. %d\n",
-			mychan->digitmode, mychan->txdialbuf, mychan->dialing,
-				mychan->afterdialingtimer, mychan->cadencepos);
-		printk(KERN_INFO "confna: %d, confn: %d, confmode: %d, confmute: %d\n",
-			mychan->confna, mychan->_confn, mychan->confmode, mychan->confmute);
-		printk(KERN_INFO "ec: %08lx, echocancel: %d, deflaw: %d, xlaw: %08lx\n",
-			(long) mychan->ec, mychan->echocancel, mychan->deflaw, (long) mychan->xlaw);
-		printk(KERN_INFO "echostate: %02x, echotimer: %d, echolastupdate: %d\n",
-			(int) mychan->echostate, mychan->echotimer, mychan->echolastupdate);
-		printk(KERN_INFO "itimer: %d, otimer: %d, ringdebtimer: %d\n\n",
-			mychan->itimer, mychan->otimer, mychan->ringdebtimer);
-#if 0
-		if (mychan->ec) {
-			int x;
-			/* Dump the echo canceller parameters */
-			for (x=0;x<mychan->ec->taps;x++) {
-				printk(KERN_INFO "tap %d: %d\n", x, mychan->ec->fir_taps[x]);
-			}
-		}
-#endif
-		kfree(mychan);
-		break;
-	default:
-		return -ENOTTY;
-	}
-	return 0;
-}
-
-static int (*zt_dynamic_ioctl)(unsigned int cmd, unsigned long data);
-
-void zt_set_dynamic_ioctl(int (*func)(unsigned int cmd, unsigned long data)) 
-{
-	zt_dynamic_ioctl = func;
-}
-
-static void recalc_slaves(struct zt_chan *chan)
-{
-	int x;
-	struct zt_chan *last = chan;
-
-	/* Makes no sense if you don't have a span */
-	if (!chan->span)
-		return;
-
-#ifdef CONFIG_ZAPATA_DEBUG
-	printk("Recalculating slaves on %s\n", chan->name);
-#endif
-
-	/* Link all slaves appropriately */
-	for (x=chan->chanpos;x<chan->span->channels;x++)
-		if (chan->span->chans[x].master == chan) {
-#ifdef CONFIG_ZAPATA_DEBUG
-			printk("Channel %s, slave to %s, last is %s, its next will be %d\n", 
-			       chan->span->chans[x].name, chan->name, last->name, x);
-#endif
-			last->nextslave = x;
-			last = &chan->span->chans[x];
-		}
-	/* Terminate list */
-	last->nextslave = 0;
-#ifdef CONFIG_ZAPATA_DEBUG
-	printk("Done Recalculating slaves on %s (last is %s)\n", chan->name, last->name);
-#endif
-}
-
-static int zt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data)
-{
-	/* I/O CTL's for control interface */
-	int i,j;
-	struct zt_lineconfig lc;
-	struct zt_chanconfig ch;
-	struct zt_sfconfig sf;
-	int sigcap;
-	int res = 0;
-	int x,y;
-	struct zt_chan *newmaster;
-	struct zt_dialparams tdp;
-	struct zt_maintinfo maint;
-	struct zt_indirect_data ind;
-	struct zt_versioninfo vi;
-	unsigned long flags;
-	int rv;
-	switch(cmd) {
-	case ZT_INDIRECT:
-		if (copy_from_user(&ind, (struct zt_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);
-	case ZT_SPANCONFIG:
-		if (copy_from_user(&lc, (struct zt_lineconfig *)data, sizeof(lc)))
-			return -EFAULT;
-		VALID_SPAN(lc.span);
-		if ((lc.lineconfig & 0x07f0 & spans[lc.span]->linecompat) != (lc.lineconfig & 0x07f0))
-			return -EINVAL;
-		if (spans[lc.span]->spanconfig) {
-			spans[lc.span]->lineconfig = lc.lineconfig;
-			spans[lc.span]->lbo = lc.lbo;
-			spans[lc.span]->txlevel = lc.lbo;
-			spans[lc.span]->rxlevel = 0;
-
-			return spans[lc.span]->spanconfig(spans[lc.span], &lc);
-		}
-		return 0;
-	case ZT_STARTUP:
-		CHECK_VALID_SPAN(j);
-		if (spans[j]->flags & ZT_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;
-			for (x=0;x<spans[j]->channels;x++) {
-				y = zt_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]);
-				spin_unlock_irqrestore(&spans[j]->chans[x].lock, flags);
-				spans[j]->chans[x].rxhooksig = ZT_RXSIG_INITIAL;
-			}
-		}
-		return 0;
-	case ZT_SHUTDOWN:
-		CHECK_VALID_SPAN(j);
-		if (spans[j]->shutdown)
-			res =  spans[j]->shutdown(spans[j]);
-		spans[j]->flags &= ~ZT_FLAG_RUNNING;
-		return 0;
-	case ZT_CHANCONFIG:
-		if (copy_from_user(&ch, (struct zt_chanconfig *)data, sizeof(ch)))
-			return -EFAULT;
-		VALID_CHANNEL(ch.chan);
-		if (ch.sigtype == ZT_SIG_SLAVE) {
-			/* We have to use the master's sigtype */
-			if ((ch.master < 1) || (ch.master >= ZT_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) {
-			newmaster = chans[ch.chan];
-			if ((ch.idlebits < 1) || (ch.idlebits >= ZT_MAX_CHANNELS))
-				return -EINVAL;
-			if (!chans[ch.idlebits])
-				return -EINVAL;
-		} else {
-			newmaster = chans[ch.chan];
-		}
-		spin_lock_irqsave(&chans[ch.chan]->lock, flags);
-#ifdef CONFIG_ZAPATA_NET
-		if (chans[ch.chan]->flags & ZT_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);
-				return -EBUSY;
-			}
-#ifdef LINUX26
-			spin_unlock_irqrestore(&chans[ch.chan]->lock, flags);
-			unregister_hdlc_device(chans[ch.chan]->hdlcnetdev->netdev);
-			spin_lock_irqsave(&chans[ch.chan]->lock, flags);
-			free_netdev(chans[ch.chan]->hdlcnetdev->netdev);
-#else
-			unregister_hdlc_device(&chans[ch.chan]->hdlcnetdev->netdev);
-#endif			
-			kfree(chans[ch.chan]->hdlcnetdev);
-			chans[ch.chan]->hdlcnetdev = NULL;
-			chans[ch.chan]->flags &= ~ZT_FLAG_NETDEV;
-		}
-#else
-		if (ch.sigtype == ZT_SIG_HDLCNET) {
-				spin_unlock_irqrestore(&chans[ch.chan]->lock, flags);
-				printk(KERN_WARNING "Zaptel networking not supported by this build.\n");
-				return -ENOSYS;
-		}
-#endif		
-		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 & ch.sigtype) != ch.sigtype)
-			res =  -EINVAL;	
-		
-		if (!res && chans[ch.chan]->span->chanconfig)
-			res = chans[ch.chan]->span->chanconfig(chans[ch.chan], ch.sigtype);
-		if (chans[ch.chan]->master) {
-			/* Clear the master channel */
-			recalc_slaves(chans[ch.chan]->master);
-			chans[ch.chan]->nextslave = 0;
-		}
-		if (!res) {
-			chans[ch.chan]->sig = ch.sigtype;
-			if (chans[ch.chan]->sig == ZT_SIG_CAS)
-				chans[ch.chan]->idlebits = ch.idlebits;
-			else
-				chans[ch.chan]->idlebits = 0;
-			if ((ch.sigtype & ZT_SIG_CLEAR) == ZT_SIG_CLEAR) {
-				/* Set clear channel flag if appropriate */
-				chans[ch.chan]->flags &= ~ZT_FLAG_AUDIO;
-				chans[ch.chan]->flags |= ZT_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;
-			}
-			if ((ch.sigtype & ZT_SIG_HDLCRAW) == ZT_SIG_HDLCRAW) {
-				/* Set the HDLC flag */
-				chans[ch.chan]->flags |= ZT_FLAG_HDLC;
-			} else {
-				/* Clear the HDLC flag */
-				chans[ch.chan]->flags &= ~ZT_FLAG_HDLC;
-			}
-			if ((ch.sigtype & ZT_SIG_HDLCFCS) == ZT_SIG_HDLCFCS) {
-				/* Set FCS to be calculated if appropriate */
-				chans[ch.chan]->flags |= ZT_FLAG_FCS;
-			} else {
-				/* Clear FCS flag */
-				chans[ch.chan]->flags &= ~ZT_FLAG_FCS;
-			}
-			if ((ch.sigtype & __ZT_SIG_DACS) == __ZT_SIG_DACS) {
-				/* Setup conference properly */
-				chans[ch.chan]->confmode = ZT_CONF_DIGITALMON;
-				chans[ch.chan]->confna = ch.idlebits;
-				if (chans[ch.chan]->span && 
-				    chans[ch.chan]->span->dacs && 
-					chans[ch.idlebits] && 
-					chans[ch.chan]->span && 
-					(chans[ch.chan]->span->dacs == chans[ch.idlebits]->span->dacs)) 
-					chans[ch.chan]->span->dacs(chans[ch.chan], chans[ch.idlebits]);
-			} else if (chans[ch.chan]->span && chans[ch.chan]->span->dacs)
-				chans[ch.chan]->span->dacs(chans[ch.chan], NULL);
-			chans[ch.chan]->master = newmaster;
-			/* Note new slave if we are not our own master */
-			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;
-			} else
-				chans[ch.chan]->flags &= ~ZT_FLAG_NOSTDTXRX;
-		}
-#ifdef CONFIG_ZAPATA_NET
-		if (!res && 
-			(newmaster == chans[ch.chan]) && 
-		        (chans[ch.chan]->sig == ZT_SIG_HDLCNET)) {
-			chans[ch.chan]->hdlcnetdev = zt_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 */
-#ifdef LINUX26
-				chans[ch.chan]->hdlcnetdev->netdev = alloc_hdlcdev(chans[ch.chan]->hdlcnetdev);
-				if (chans[ch.chan]->hdlcnetdev->netdev) {
-					chans[ch.chan]->hdlcnetdev->chan = chans[ch.chan];
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-					SET_MODULE_OWNER(chans[ch.chan]->hdlcnetdev->netdev);
-#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;
-					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);
-					spin_lock_irqsave(&chans[ch.chan]->lock, flags);
-				} else {
-					printk("Unable to allocate hdlc: *shrug*\n");
-					res = -1;
-				}
-#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;
-#endif
-				chans[ch.chan]->hdlcnetdev->netdev.netdev.do_ioctl = zt_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;
-#else
-				chans[ch.chan]->hdlcnetdev->netdev.open = zt_net_open;
-				chans[ch.chan]->hdlcnetdev->netdev.close = zt_net_close;
-				chans[ch.chan]->hdlcnetdev->netdev.set_mode = NULL;
-				chans[ch.chan]->hdlcnetdev->netdev.xmit = zt_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;
-			} else {
-				printk("Unable to allocate netdev: out of memory\n");
-				res = -1;
-			}
-		}
-#endif		
-		if ((chans[ch.chan]->sig == ZT_SIG_HDLCNET) && 
-		    (chans[ch.chan] == newmaster) &&
-		    !(chans[ch.chan]->flags & ZT_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)))
-				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;
-			if (y >= 0) chans[ch.chan]->rxsig = (unsigned char)y;
-			chans[ch.chan]->rxhooksig = ZT_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);
-#endif		
-		spin_unlock_irqrestore(&chans[ch.chan]->lock, flags);
-		return res;
-	case ZT_SFCONFIG:
-		if (copy_from_user(&sf, (struct zt_chanconfig *)data, sizeof(sf)))
-			return -EFAULT;
-		VALID_CHANNEL(sf.chan);
-		if (chans[sf.chan]->sig != ZT_SIG_SF) return -EINVAL;
-		spin_lock_irqsave(&chans[sf.chan]->lock, flags);
-		chans[sf.chan]->rxp1 = sf.rxp1;
-		chans[sf.chan]->rxp2 = sf.rxp2;
-		chans[sf.chan]->rxp3 = sf.rxp3;
-		chans[sf.chan]->txtone = sf.txtone;
-		chans[sf.chan]->tx_v2 = sf.tx_v2;
-		chans[sf.chan]->tx_v3 = sf.tx_v3;
-		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))) 
-			{
-				set_txtone(chans[sf.chan],sf.txtone,sf.tx_v2,sf.tx_v3);
-			}
-			else
-			{
-				set_txtone(chans[sf.chan],0,0,0);
-			}
-		}
-		spin_unlock_irqrestore(&chans[sf.chan]->lock, flags);
-		return res;
-	case ZT_DEFAULTZONE:
-		if (get_user(j,(int *)data))
-			return -EFAULT;
-		if ((j < 0) || (j >= ZT_TONE_ZONE_MAX))
-			return -EINVAL;
-		write_lock(&zone_lock);
-		if (!tone_zones[j]) {
-			write_unlock(&zone_lock);
-			return -EINVAL;
-		}
-		if ((default_zone != -1) && tone_zones[default_zone])
-			atomic_dec(&tone_zones[default_zone]->refcount);
-		atomic_inc(&tone_zones[j]->refcount);
-		default_zone = j;
-		write_unlock(&zone_lock);
-		break;
-	case ZT_LOADZONE:
-		return ioctl_load_zone(data);
-	case ZT_FREEZONE:
-		get_user(j, (int *) data);
-		return free_tone_zone(j);
-	case ZT_SET_DIALPARAMS:
-		if (copy_from_user(&tdp, (struct zt_dialparams *) data, sizeof(tdp)))
-			return -EFAULT;
-		if ((tdp.dtmf_tonelen > 4000) || (tdp.dtmf_tonelen < 10))
-			return -EINVAL;
-		if ((tdp.mfv1_tonelen > 4000) || (tdp.mfv1_tonelen < 10))
-			return -EINVAL;
-
-		global_dialparams = tdp;
-
-		/* 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];
-
-			if (!z)
-				continue;
-
-			for (i = 0; i < sizeof(z->dtmf) / sizeof(z->dtmf[0]); i++)
-				z->dtmf[i].tonesamples = tdp.dtmf_tonelen * ZT_CHUNKSIZE;
-
-			for (i = 0; i < sizeof(z->mf) / sizeof(z->mf[0]); i++)
-				z->mf[i].tonesamples = tdp.mfv1_tonelen * ZT_CHUNKSIZE;
-
-			/* Special case for K/P tone */
-			z->mf[10].tonesamples *= 5 / 3;
-		}
-		write_unlock(&zone_lock);
-
-		dtmf_silence.tonesamples = tdp.dtmf_tonelen * ZT_CHUNKSIZE;
-		mfv1_silence.tonesamples = tdp.mfv1_tonelen * ZT_CHUNKSIZE;
-
-		break;
-	case ZT_GET_DIALPARAMS:
-		tdp = global_dialparams;
-		if (copy_to_user((struct zt_dialparams *) data, &tdp, sizeof(tdp)))
-			return -EFAULT;
-		break;
-	case ZT_GETVERSION:
-		memset(&vi, 0, sizeof(vi));
-		strncpy(vi.version, ZAPTEL_VERSION, sizeof(vi.version) - 1);
-		echo_can_identify(vi.echo_canceller, sizeof(vi.echo_canceller) - 1);
-		if (copy_to_user((struct zt_versioninfo *) data, &vi, sizeof(vi)))
-			return -EFAULT;
-		break;
-	case ZT_MAINT:  /* do maintenance stuff */
-		  /* get struct from user */
-		if (copy_from_user(&maint,(struct zt_maintinfo *) data, sizeof(maint)))
-			return -EFAULT;
-		/* must be valid span number */
-		if ((maint.spanno < 1) || (maint.spanno > ZT_MAX_SPANS) || (!spans[maint.spanno]))
-			return -EINVAL;
-		if (!spans[maint.spanno]->maint)
-			return -ENOSYS;
-		spin_lock_irqsave(&spans[maint.spanno]->lock, flags);
-		  /* save current maint state */
-		i = spans[maint.spanno]->maintstat;
-		  /* set maint mode */
-		spans[maint.spanno]->maintstat = maint.command;
-		switch(maint.command) {
-		case ZT_MAINT_NONE:
-		case ZT_MAINT_LOCALLOOP:
-		case ZT_MAINT_REMOTELOOP:
-			/* if same, ignore it */
-			if (i == maint.command) break;
-			rv = spans[maint.spanno]->maint(spans[maint.spanno], maint.command);
-			spin_unlock_irqrestore(&spans[maint.spanno]->lock, flags);
-			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;
-			rv = spans[maint.spanno]->maint(spans[maint.spanno], maint.command);
-			spin_unlock_irqrestore(&spans[maint.spanno]->lock, flags);
-			if (rv) return rv;
-			rv = schluffen(&spans[maint.spanno]->maintq);
-			if (rv) return rv;
-			spin_lock_irqsave(&spans[maint.spanno]->lock, flags);
-			break;
-		default:
-			printk("zaptel: Unknown maintenance event: %d\n", maint.command);
-		}
-		zt_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);
-		else {
-			request_module("ztdynamic");
-			if (zt_dynamic_ioctl)
-				return zt_dynamic_ioctl(cmd, data);
-		}
-		return -ENOSYS;
-#if defined(ECHO_CAN_HPEC)
-	case ZT_EC_LICENSE_CHALLENGE:
-	case ZT_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 0;
-}
-
-static int zt_chanandpseudo_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit)
-{
-	struct zt_chan *chan = chans[unit];
-	union {
-		struct zt_dialoperation tdo;
-		struct zt_bufferinfo bi;
-		struct zt_confinfo conf;
-		struct zt_ring_cadence cad;
-	} stack;
-	unsigned long flags, flagso;
-	int i, j, k, rv;
-	int ret, c;
-	char *s;
-	
-	if (!chan)
-		return -EINVAL;
-	switch(cmd) {
-	case ZT_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:
-		if (copy_from_user(&stack.tdo, (struct zt_dialoperation *)data, sizeof(stack.tdo)))
-			return -EFAULT;
-		rv = 0;
-		/* Force proper NULL termination and uppercase entry */
-		stack.tdo.dialstr[ZT_MAX_DTMF_BUF - 1] = '\0';
-		for (s = stack.tdo.dialstr; *s; s++)
-			*s = toupper(*s);
-		spin_lock_irqsave(&chan->lock, flags);
-		switch (stack.tdo.op) {
-		case ZT_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:
-			strcpy(chan->txdialbuf, stack.tdo.dialstr);
-			chan->dialing = 1;
-			__do_dtmf(chan);
-			break;
-		case ZT_DIAL_OP_APPEND:
-			if (strlen(stack.tdo.dialstr) + strlen(chan->txdialbuf) >= (ZT_MAX_DTMF_BUF - 1)) {
-				rv = -EBUSY;
-				break;
-			}
-			strncpy(chan->txdialbuf + strlen(chan->txdialbuf), stack.tdo.dialstr, ZT_MAX_DTMF_BUF - strlen(chan->txdialbuf) - 1);
-			if (!chan->dialing) {
-				chan->dialing = 1;
-				__do_dtmf(chan);
-			}
-			break;
-		default:
-			rv = -EINVAL;
-		}
-		spin_unlock_irqrestore(&chan->lock, flags);
-		return rv;
-	case ZT_GET_BUFINFO:
-		stack.bi.rxbufpolicy = chan->rxbufpolicy;
-		stack.bi.txbufpolicy = chan->txbufpolicy;
-		stack.bi.numbufs = chan->numbufs;
-		stack.bi.bufsize = chan->blocksize;
-		/* XXX FIXME! XXX */
-		stack.bi.readbufs = -1;
-		stack.bi.writebufs = -1;
-		if (copy_to_user((struct zt_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)))
-			return -EFAULT;
-		if (stack.bi.bufsize > ZT_MAX_BLOCKSIZE)
-			return -EINVAL;
-		if (stack.bi.bufsize < 16)
-			return -EINVAL;
-		if (stack.bi.bufsize * stack.bi.numbufs > ZT_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)))
-			return (rv);
-		break;
-	case ZT_GET_BLOCKSIZE:  /* get blocksize */
-		put_user(chan->blocksize,(int *)data); /* return block size */
-		break;
-	case ZT_SET_BLOCKSIZE:  /* set blocksize */
-		get_user(j,(int *)data);
-		  /* cannot be larger than max amount */
-		if (j > ZT_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)))
-			return (rv);
-		break;
-	case ZT_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) */
-		   {
-			  /* initialize read buffers and pointers */
-			chan->inreadbuf = 0;
-			chan->outreadbuf = -1;
-			for (j=0;j<chan->numbufs;j++) {
-				/* Do we need this? */
-				chan->readn[j] = 0;
-				chan->readidx[j] = 0;
-			}
-			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) */
-		   {
-			  /* initialize write buffers and pointers */
-			chan->outwritebuf = -1;
-			chan->inwritebuf = 0;
-			for (j=0;j<chan->numbufs;j++) {
-				/* Do we need this? */
-				chan->writen[j] = 0;
-				chan->writeidx[j] = 0;
-			}
-			wake_up_interruptible(&chan->writebufq); /* wake_up_interruptible waiting on write */
-			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)
-				wake_up_interruptible(&chan->eventbufq); /* wake_up_interruptible waiting on IOMUX */
-		   }
-		if (i & ZT_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 */
-		for(;;)  /* loop forever */
-		   {
-			spin_lock_irqsave(&chan->lock, flags);
-			  /* Know if there is a write pending */
-			i = (chan->outwritebuf > -1);
-			spin_unlock_irqrestore(&chan->lock, flags);
-			if (!i) break; /* skip if none */
-			rv = schluffen(&chan->writebufq);
-			if (rv) return(rv);
-		   }
-		break;
-	case ZT_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 */
-		   {
-			  /* has to have SOME mask */
-			ret = 0;  /* start with empty return value */
-			spin_lock_irqsave(&chan->lock, flags);
-			  /* if looking for read */
-			if (chan->iomask & ZT_IOMUX_READ)
-			   {
-				/* if read available */
-				if ((chan->outreadbuf > -1)  && !chan->rxdisable)
-					ret |= ZT_IOMUX_READ;
-			   }
-			  /* if looking for write avail */
-			if (chan->iomask & ZT_IOMUX_WRITE)
-			   {
-				if (chan->inwritebuf > -1)
-					ret |= ZT_IOMUX_WRITE;
-			   }
-			  /* if looking for write empty */
-			if (chan->iomask & ZT_IOMUX_WRITEEMPTY)
-			   {
-				  /* if everything empty -- be sure the transmitter is enabled */
-				chan->txdisable = 0;
-				if (chan->outwritebuf < 0)
-					ret |= ZT_IOMUX_WRITEEMPTY;
-			   }
-			  /* if looking for signalling event */
-			if (chan->iomask & ZT_IOMUX_SIGEVENT)
-			   {
-				  /* if event */
-				if (chan->eventinidx != chan->eventoutidx)
-					ret |= ZT_IOMUX_SIGEVENT;
-			   }
-			spin_unlock_irqrestore(&chan->lock, flags);
-			  /* if something to return, or not to wait */
-			if (ret || (chan->iomask & ZT_IOMUX_NOWAIT))
-			   {
-				  /* set return value */
-				put_user(ret,(int *)data);
-				break; /* get out of loop */
-			   }
-			rv = schluffen(&chan->eventbufq);
-			if (rv) return(rv);
-		   }
-		  /* clear IO MUX mask */
-		chan->iomask = 0;
-		break;
-	case ZT_GETEVENT:  /* Get event on queue */
-		  /* set up for no event */
-		j = ZT_EVENT_NONE;
-		spin_lock_irqsave(&chan->lock, flags);
-		  /* if some event in queue */
-		if (chan->eventinidx != chan->eventoutidx)
-		   {
-			j = chan->eventbuf[chan->eventoutidx++];
-			  /* get the data, bump index */
-			  /* if index overflow, set to beginning */
-			if (chan->eventoutidx >= ZT_MAX_EVENTSIZE)
-				chan->eventoutidx = 0;
-		   }		
-		spin_unlock_irqrestore(&chan->lock, flags);
-		put_user(j,(int *)data);
-		break;
-	case ZT_CONFMUTE:  /* set confmute flag */
-		get_user(j,(int *)data);  /* get conf # */
-		if (!(chan->flags & ZT_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);
-		j = chan->confmute;
-		put_user(j,(int *)data);  /* get conf # */
-		rv = 0;
-		break;
-	case ZT_SETTONEZONE:
-		get_user(j, (int *) data);
-		rv = set_tone_zone(chan, j);
-		return rv;
-	case ZT_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:
-		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)))
-			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);
-		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)))
-			return -EFAULT;
-		break;
-	case ZT_SETCONF:  /* set conf stuff */
-		if (copy_from_user(&stack.conf,(struct zt_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) {
-			/* Monitor mode -- it's a channel */
-			if ((stack.conf.confno < 0) || (stack.conf.confno >= ZT_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 taking off of any conf, must have 0 mode */
-		if ((!stack.conf.confno) && stack.conf.confmode) return(-EINVAL);
-		  /* likewise if 0 mode must have no conf */
-		if ((!stack.conf.confmode) && stack.conf.confno) return (-EINVAL);
-		stack.conf.chan = i;  /* return with real channel # */
-		spin_lock_irqsave(&bigzaplock, flagso);
-		spin_lock_irqsave(&chan->lock, flags);
-		if (stack.conf.confno == -1) 
-			stack.conf.confno = zt_first_empty_conference();
-		if ((stack.conf.confno < 1) && (stack.conf.confmode)) {
-			/* No more empty conferences */
-			spin_unlock_irqrestore(&chan->lock, flags);
-			spin_unlock_irqrestore(&bigzaplock, flagso);
-			return -EBUSY;
-		}
-		  /* 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);
-		}
-		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);
-		if (chans[i]->span && chans[i]->span->dacs) {
-			if (((stack.conf.confmode & ZT_CONF_MODE_MASK) == ZT_CONF_DIGITALMON) &&
-			    chans[stack.conf.confno]->span &&
-			    chans[stack.conf.confno]->span->dacs == chans[i]->span->dacs &&
-			    chans[i]->txgain == defgain &&
-			    chans[i]->rxgain == defgain &&
-			    chans[stack.conf.confno]->txgain == defgain &&
-			    chans[stack.conf.confno]->rxgain == defgain) {
-				chans[i]->span->dacs(chans[i], chans[stack.conf.confno]);
-			} else {
-				chans[i]->span->dacs(chans[i], NULL);
-			}
-		}
-		/* 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)) {
-			/* Get alias */
-			chans[i]->_confn = zt_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);
-			else {
-				if (chans[stack.conf.confno]->readchunkpreec) {
-					kfree(chans[stack.conf.confno]->readchunkpreec);
-					chans[stack.conf.confno]->readchunkpreec = NULL;
-				}
-			}
-		}
-
-		spin_unlock_irqrestore(&chan->lock, flags);
-		spin_unlock_irqrestore(&bigzaplock, flagso);
-		if (copy_to_user((struct zt_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)))
-			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);
-		  /* cant listen to self!! */
-		if (stack.conf.chan && (stack.conf.chan == stack.conf.confno)) return(-EINVAL);
-		spin_lock_irqsave(&bigzaplock, flagso);
-		spin_lock_irqsave(&chan->lock, flags);
-		  /* if to clear all links */
-		if ((!stack.conf.chan) && (!stack.conf.confno))
-		   {
-			   /* clear all the links */
-			memset(conf_links,0,sizeof(conf_links));
-			recalc_maxlinks();
-			spin_unlock_irqrestore(&chan->lock, flags);
-			spin_unlock_irqrestore(&bigzaplock, flagso);
-			break;
-		   }
-		rv = 0;  /* clear return value */
-		/* look for already existant specified combination */
-		for(i = 1; i <= ZT_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 (!stack.conf.confmode) /* if to remove link */
-			   {
-				conf_links[i].src = conf_links[i].dst = 0;
-			   }
-			else /* if to add and already there, error */
-			   {
-				rv = -EEXIST;
-			   }
-		   }
-		else  /* if not found */
-		   {
-			if (stack.conf.confmode) /* if to add link */
-			   {
-				/* look for empty location */
-				for(i = 1; i <= ZT_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)
-				   {
-					conf_links[i].src = stack.conf.chan;
-					conf_links[i].dst = stack.conf.confno;
-				   }
-				else /* if no empties -- error */
-				   {
-					rv = -ENOSPC;
-				   }
-			   }
-			else /* if to remove, and not found -- error */
-			   {
-				rv = -ENOENT;
-			   }
-		   }
-		recalc_maxlinks();
-		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);
-		get_user(j,(int *)data);  /* get conf # */
- 		  /* loop thru the interesting ones */
-		for(i = ((j) ? j : 1); i <= ((j) ? j : ZT_MAX_CONF); i++)
-		   {
-			c = 0;
-			for(k = 1; k < ZT_MAX_CHANNELS; k++)
-			   {
-				  /* skip if no pointer */
-				if (!chans[k]) continue;
-				  /* skip if not in this conf */
-				if (chans[k]->confna != i) continue;
-				if (!c) printk("Conf #%d:\n",i);
-				c = 1;
-				printk("chan %d, mode %x\n",
-					k,chans[k]->confmode);
-			   }
-			rv = 0;
-			for(k = 1; k <= ZT_MAX_CONF; k++)
-			   {
-				if (conf_links[k].dst == i)
-				   {
-					if (!c) printk("Conf #%d:\n",i);
-					c = 1;
-					if (!rv) printk("Snooping on:\n");
-					rv = 1;
-					printk("conf %d\n",conf_links[k].src);
-				   }
-			   }
-			if (c) printk("\n");
-		   }
-		break;
-	case ZT_CHANNO:  /* get channel number of stream */
-		put_user(unit,(int *)data); /* return unit/channel number */
-		break;
-	case ZT_SETLAW:
-		get_user(j, (int *)data);
-		if ((j < 0) || (j > ZT_LAW_ALAW))
-			return -EINVAL;
-		zt_set_law(chan, j);
-		break;
-	case ZT_SETLINEAR:
-		get_user(j, (int *)data);
-		/* Makes no sense on non-audio channels */
-		if (!(chan->flags & ZT_FLAG_AUDIO))
-			return -EINVAL;
-
-		if (j)
-			chan->flags |= ZT_FLAG_LINEAR;
-		else
-			chan->flags &= ~ZT_FLAG_LINEAR;
-		break;
-	case ZT_SETCADENCE:
-		if (data) {
-			/* Use specific ring cadence */
-			if (copy_from_user(&stack.cad, (struct zt_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 ) {
-				if (chan->ringcadence[i]<0) {
-					chan->ringcadence[i] *= -1;
-					chan->firstcadencepos = i;
-					break;
-				}
-			}
-		} else {
-			/* Reset to default */
-			chan->firstcadencepos = 0;
-			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 ) {
-					if (chan->ringcadence[i]<0) {
-						chan->ringcadence[i] *= -1;
-						chan->firstcadencepos = i;
-						break;
-					}
-				}
-			} else {
-				memset(chan->ringcadence, 0, sizeof(chan->ringcadence));
-				chan->ringcadence[0] = chan->starttime;
-				chan->ringcadence[1] = ZT_RINGOFFTIME;
-			}
-		}
-		break;
-	default:
-		/* Check for common ioctl's and private ones */
-		rv = zt_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) 
-			rv = chan->span->ioctl(chan, cmd, data);
-		return rv;
-		
-	}
-	return 0;
-}
-
-#ifdef CONFIG_ZAPATA_PPP
-/*
- * This is called at softirq (BH) level when there are calls
- * we need to make to the ppp_generic layer.  We do it this
- * way because the ppp_generic layer functions may not be called
- * at interrupt level.
- */
-static void do_ppp_calls(unsigned long data)
-{
-	struct zt_chan *chan = (struct zt_chan *) data;
-	struct sk_buff *skb;
-
-	if (!chan->ppp)
-		return;
-	if (chan->do_ppp_wakeup) {
-		chan->do_ppp_wakeup = 0;
-		ppp_output_wakeup(chan->ppp);
-	}
-	while ((skb = skb_dequeue(&chan->ppp_rq)) != NULL)
-		ppp_input(chan->ppp, skb);
-	if (chan->do_ppp_error) {
-		chan->do_ppp_error = 0;
-		ppp_input_error(chan->ppp, 0);
-	}
-}
-#endif
-
-static int ioctl_echocancel(struct zt_chan *chan, struct zt_echocanparams *ecp, void *data)
-{
-	struct echo_can_state *ec = NULL, *tec;
-	struct zt_echocanparam params[ZT_MAX_ECHOCANPARAMS];
-	int ret;
-	unsigned long flags;
-
-	if (ecp->param_count > ZT_MAX_ECHOCANPARAMS)
-		return -E2BIG;
-
-	if (ecp->tap_length == 0) {
-		/* disable mode, don't need to inspect params */
-		spin_lock_irqsave(&chan->lock, flags);
-		tec = chan->ec;
-		chan->ec = NULL;
-		chan->echocancel = 0;
-		chan->echostate = ECHO_STATE_IDLE;
-		chan->echolastupdate = 0;
-		chan->echotimer = 0;
-		spin_unlock_irqrestore(&chan->lock, flags);
-
-		/* Make sure this is zero if we're disabling echo can */
-		ecp->param_count = 0;
-
-		if (chan->span) {
-			if (chan->span->echocan_with_params)
-				chan->span->echocan_with_params(chan, ecp, NULL);
-			else if (chan->span->echocan)
-				chan->span->echocan(chan, 0);
-		}
-		
-		if (tec)
-			echo_can_free(tec);
-
-		return 0;
-	}
-
-	/* if parameters were supplied and this channel's span provides an echocan,
-	   but not one that takes params, then we must punt here and return an error */
-	if (ecp->param_count && chan->span && chan->span->echocan &&
-	    !chan->span->echocan_with_params)
-		return -EINVAL;
-	
-	/* enable mode, need the params */
-	
-	if (copy_from_user(params, (struct zt_echocanparam *) data, sizeof(params[0]) * ecp->param_count))
-		return -EFAULT;
-	
-	spin_lock_irqsave(&chan->lock, flags);
-	tec = chan->ec;
-	chan->ec = NULL;
-	spin_unlock_irqrestore(&chan->lock, flags);
-	
-	if (tec)
-		echo_can_free(tec);
-
-	ret = -ENODEV;
-	
-	/* attempt to use the span's echo canceler; fall back to built-in
-	   if it fails (but not if an error occurs) */
-	if (chan->span) {
-		if (ecp->param_count) {
-			if (chan->span->echocan_with_params)
-				ret = chan->span->echocan_with_params(chan, ecp, params);
-		} else if (chan->span->echocan) {
-			ret = chan->span->echocan(chan, ecp->tap_length);
-		} else if (chan->span->echocan_with_params) {
-			ret = chan->span->echocan_with_params(chan, ecp, NULL);
-		}
-	}
-	
-	if (ret == -ENODEV) {
-		switch (ecp->tap_length) {
-		case 32:
-		case 64:
-		case 128:
-		case 256:
-		case 512:
-		case 1024:
-			break;
-		default:
-			ecp->tap_length = deftaps;
-		}
-		
-		if ((ret = echo_can_create(ecp, params, &ec)))
-			return ret;
-		
-		spin_lock_irqsave(&chan->lock, flags);
-		chan->echocancel = ecp->tap_length;
-		chan->ec = ec;
-		chan->echostate = ECHO_STATE_IDLE;
-		chan->echolastupdate = 0;
-		chan->echotimer = 0;
-		echo_can_disable_detector_init(&chan->txecdis);
-		echo_can_disable_detector_init(&chan->rxecdis);
-		spin_unlock_irqrestore(&chan->lock, flags);
-	}
-
-	return ret;
-}
-
-static int zt_chan_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit)
-{
-	struct zt_chan *chan = chans[unit];
-	unsigned long flags;
-	int j, rv;
-	int ret;
-	int oldconf;
-	void *rxgain=NULL;
-	struct echo_can_state *ec;
-	struct zt_echocanparams ecp;
-
-	if (!chan)
-		return -ENOSYS;
-
-	switch(cmd) {
-	case ZT_SIGFREEZE:
-		get_user(j, (int *)data);
-		spin_lock_irqsave(&chan->lock, flags);
-		if (j) {
-			chan->flags |= ZT_FLAG_SIGFREEZE;
-		} else {
-			chan->flags &= ~ZT_FLAG_SIGFREEZE;
-		}
-		spin_unlock_irqrestore(&chan->lock, flags);
-		break;
-	case ZT_GETSIGFREEZE:
-		spin_lock_irqsave(&chan->lock, flags);
-		if (chan->flags & ZT_FLAG_SIGFREEZE)
-			j = 1;
-		else
-			j = 0;
-		spin_unlock_irqrestore(&chan->lock, flags);
-		put_user(j, (int *)data);
-		break;
-	case ZT_AUDIOMODE:
-		/* Only literal clear channels can be put in  */
-		if (chan->sig != ZT_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);
-			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;
-			/* save old conf number, if any */
-			oldconf = chan->confna;
-			  /* initialize conference variables */
-			chan->_confn = 0;
-			chan->confna = 0;
-			if (chan->span && chan->span->dacs)
-				chan->span->dacs(chan, NULL);
-			chan->confmode = 0;
-			chan->confmute = 0;
-			memset(chan->conflast, 0, sizeof(chan->conflast));
-			memset(chan->conflast1, 0, sizeof(chan->conflast1));
-			memset(chan->conflast2, 0, sizeof(chan->conflast2));
-			ec = chan->ec;
-			chan->ec = NULL;
-			/* release conference resource, if any to release */
-			reset_conf(chan);
-			if (chan->gainalloc && chan->rxgain)
-				rxgain = chan->rxgain;
-			else
-				rxgain = NULL;
-
-			chan->rxgain = defgain;
-			chan->txgain = defgain;
-			chan->gainalloc = 0;
-			/* Disable any native echo cancellation as well */
-			spin_unlock_irqrestore(&chan->lock, flags);
-
-			if (chan->span && chan->span->echocan)
-				chan->span->echocan(chan, 0);
-
-			if (rxgain)
-				kfree(rxgain);
-			if (ec)
-				echo_can_free(ec);
-			if (oldconf) zt_check_conf(oldconf);
-		}
-		break;
-	case ZT_HDLCPPP:
-#ifdef CONFIG_ZAPATA_PPP
-		if (chan->sig != ZT_SIG_CLEAR) return (-EINVAL);
-		get_user(j, (int *)data);
-		if (j) {
-			if (!chan->ppp) {
-				chan->ppp = kmalloc(sizeof(struct ppp_channel), GFP_KERNEL);
-				if (chan->ppp) {
-					struct echo_can_state *tec;
-					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->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))) {
-						kfree(chan->ppp);
-						chan->ppp = NULL;
-						return ret;
-					}
-						
-					if ((ret = ppp_register_channel(chan->ppp))) {
-						kfree(chan->ppp);
-						chan->ppp = NULL;
-						return ret;
-					}
-					tec = chan->ec;
-					chan->ec = NULL;
-					chan->echocancel = 0;
-					chan->echostate = ECHO_STATE_IDLE;
-					chan->echolastupdate = 0;
-					chan->echotimer = 0;
-					/* Make sure there's no gain */
-					if (chan->gainalloc)
-						kfree(chan->rxgain);
-					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);
-					if (chan->span && chan->span->echocan)
-						chan->span->echocan(chan, 0);
-					if (tec)
-						echo_can_free(tec);
-				} else
-					return -ENOMEM;
-			}
-		} else {
-			chan->flags &= ~(ZT_FLAG_PPP | ZT_FLAG_HDLC | ZT_FLAG_FCS);
-			if (chan->ppp) {
-				struct ppp_channel *ppp = chan->ppp;
-				chan->ppp = NULL;
-				tasklet_kill(&chan->ppp_calls);
-				skb_queue_purge(&chan->ppp_rq);
-				ppp_unregister_channel(ppp);
-				kfree(ppp);
-			}
-		}
-#else
-		printk("Zaptel: Zaptel PPP support not compiled in\n");
-		return -ENOSYS;
-#endif
-		break;
-	case ZT_HDLCRAWMODE:
-		if (chan->sig != ZT_SIG_CLEAR)	return (-EINVAL);
-		get_user(j, (int *)data);
-		chan->flags &= ~(ZT_FLAG_AUDIO | ZT_FLAG_HDLC | ZT_FLAG_FCS);
-		if (j) {
-			chan->flags |= ZT_FLAG_HDLC;
-			fasthdlc_init(&chan->rxhdlc);
-			fasthdlc_init(&chan->txhdlc);
-		}
-		break;
-	case ZT_HDLCFCSMODE:
-		if (chan->sig != ZT_SIG_CLEAR)	return (-EINVAL);
-		get_user(j, (int *)data);
-		chan->flags &= ~(ZT_FLAG_AUDIO | ZT_FLAG_HDLC | ZT_FLAG_FCS);
-		if (j) {
-			chan->flags |= ZT_FLAG_HDLC | ZT_FLAG_FCS;
-			fasthdlc_init(&chan->rxhdlc);
-			fasthdlc_init(&chan->txhdlc);
-		}
-		break;
-	case ZT_ECHOCANCEL_PARAMS:
-		if (!(chan->flags & ZT_FLAG_AUDIO))
-			return -EINVAL;
-		if (copy_from_user(&ecp, (struct zt_echocanparams *) data, sizeof(ecp)))
-			return -EFAULT;
-		data += sizeof(ecp);
-		if ((ret = ioctl_echocancel(chan, &ecp, (void *) data)))
-			return ret;
-		break;
-	case ZT_ECHOCANCEL:
-		if (!(chan->flags & ZT_FLAG_AUDIO))
-			return -EINVAL;
-		get_user(j, (int *) data);
-		ecp.tap_length = j;
-		ecp.param_count = 0;
-		if ((ret = ioctl_echocancel(chan, &ecp, NULL)))
-			return ret;
-		break;
-	case ZT_ECHOTRAIN:
-		get_user(j, (int *)data); /* get pre-training time from user */
-		if ((j < 0) || (j >= ZT_MAX_PRETRAINING))
-			return -EINVAL;
-		j <<= 3;
-		if (chan->ec) {
-			/* Start pretraining stage */
-			chan->echostate = ECHO_STATE_PRETRAINING;
-			chan->echotimer = j;
-		} else
-			return -EINVAL;
-		break;
-	case ZT_SETTXBITS:
-		if (chan->sig != ZT_SIG_CAS)
-			return -EINVAL;
-		get_user(j,(int *)data);
-		zt_cas_setbits(chan, j);
-		rv = 0;
-		break;
-	case ZT_GETRXBITS:
-		put_user(chan->rxsig, (int *)data);
-		rv = 0;
-		break;
-	case ZT_LOOPBACK:
-		get_user(j, (int *)data);
-		spin_lock_irqsave(&chan->lock, flags);
-		if (j)
-			chan->flags |= ZT_FLAG_LOOPED;
-		else
-			chan->flags &= ~ZT_FLAG_LOOPED;
-		spin_unlock_irqrestore(&chan->lock, flags);
-		rv = 0;
-		break;
-	case ZT_HOOK:
-		get_user(j,(int *)data);
-		if (chan->flags & ZT_FLAG_CLEAR)
-			return -EINVAL;
-		if (chan->sig == ZT_SIG_CAS) 
-			return -EINVAL;
-		/* if no span, just do nothing */
-		if (!chan->span) return(0);
-		spin_lock_irqsave(&chan->lock, flags);
-		/* if dialing, stop it */
-		chan->curtone = NULL;
-		chan->dialing = 0;
-		chan->txdialbuf[0] = '\0';
-		chan->tonep = 0;
-		chan->pdialcount = 0;
-		spin_unlock_irqrestore(&chan->lock, flags);
-		if (chan->span->flags & ZT_FLAG_RBS) {
-			switch (j) {
-			case ZT_ONHOOK:
-				spin_lock_irqsave(&chan->lock, flags);
-				zt_hangup(chan);
-				spin_unlock_irqrestore(&chan->lock, flags);
-				break;
-			case ZT_OFFHOOK:
-				spin_lock_irqsave(&chan->lock, flags);
-				if ((chan->txstate == ZT_TXSTATE_KEWL) ||
-				  (chan->txstate == ZT_TXSTATE_AFTERKEWL)) {
-					spin_unlock_irqrestore(&chan->lock, flags);
-					return -EBUSY;
-				}
-				zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_DEBOUNCE, chan->debouncetime);
-				spin_unlock_irqrestore(&chan->lock, flags);
-				break;
-			case ZT_RING:
-			case ZT_START:
-				spin_lock_irqsave(&chan->lock, flags);
-				if (chan->txstate != ZT_TXSTATE_ONHOOK) {
-					spin_unlock_irqrestore(&chan->lock, flags);
-					return -EBUSY;
-				}
-				if (chan->sig & __ZT_SIG_FXO) {
-					ret = 0;
-					chan->cadencepos = 0;
-					ret = chan->ringcadence[0];
-					zt_rbs_sethook(chan, ZT_TXSIG_START, ZT_TXSTATE_RINGON, ret);
-				} else
-					zt_rbs_sethook(chan, ZT_TXSIG_START, ZT_TXSTATE_START, chan->starttime);
-				spin_unlock_irqrestore(&chan->lock, flags);
-				if (file->f_flags & O_NONBLOCK)
-					return -EINPROGRESS;
-#if 0
-				rv = schluffen(&chan->txstateq);
-				if (rv) return rv;
-#endif				
-				rv = 0;
-				break;
-			case ZT_WINK:
-				spin_lock_irqsave(&chan->lock, flags);
-				if (chan->txstate != ZT_TXSTATE_ONHOOK) {
-					spin_unlock_irqrestore(&chan->lock, flags);
-					return -EBUSY;
-				}
-				zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_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:
-				spin_lock_irqsave(&chan->lock, flags);
-				if (chan->txstate != ZT_TXSTATE_OFFHOOK) {
-					spin_unlock_irqrestore(&chan->lock, flags);
-					return -EBUSY;
-				}
-				zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_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:
-				spin_lock_irqsave(&chan->lock, flags);
-				zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_ONHOOK, 0);
-				spin_unlock_irqrestore(&chan->lock, flags);
-				break;
-			default:
-				return -EINVAL;
-			}
-		} else if (chan->span->sethook) {
-			if (chan->txhooksig != j) {
-				chan->txhooksig = j;
-				chan->span->sethook(chan, j);
-			}
-		} else
-			return -ENOSYS;
-		break;
-#ifdef CONFIG_ZAPATA_PPP
-	case PPPIOCGCHAN:
-		if (chan->flags & ZT_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)
-			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 0;
-}
-
-static int zt_prechan_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit)
-{
-	struct zt_chan *chan = file->private_data;
-	int channo;
-	int res;
-
-	if (chan) {
-		printk("Huh?  Prechan already has private data??\n");
-	}
-	switch(cmd) {
-	case ZT_SPECIFY:
-		get_user(channo,(int *)data);
-		if (channo < 1)
-			return -EINVAL;
-		if (channo > ZT_MAX_CHANNELS)
-			return -EINVAL;
-		res = zt_specchan_open(inode, file, channo, 0);
-		if (!res) {
-			/* Setup the pointer for future stuff */
-			chan = chans[channo];
-			file->private_data = chan;
-			/* Return success */
-			return 0;
-		}
-		return res;
-	default:
-		return -ENOSYS;
-	}
-	return 0;
-}
-
-static int zt_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;
-
-	if (!unit)
-		return zt_ctl_ioctl(inode, file, cmd, data);
-
-	if (unit == 250)
-		return zt_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);
-		else
-			return -EINVAL;
-	}
-	if (unit == 254) {
-		chan = file->private_data;
-		if (chan)
-			return zt_chan_ioctl(inode, file, cmd, data, chan->channo);
-		else
-			return zt_prechan_ioctl(inode, file, cmd, data, unit);
-	}
-	if (unit == 255) {
-		chan = file->private_data;
-		if (!chan) {
-			printk("No pseudo channel structure to read?\n");
-			return -EINVAL;
-		}
-		return zt_chanandpseudo_ioctl(inode, file, cmd, data, chan->channo);
-	}
-	return zt_chan_ioctl(inode, file, cmd, data, unit);
-}
-
-int zt_register(struct zt_span *span, int prefmaster)
-{
-	int x;
-
-#ifdef CONFIG_PROC_FS
-	char tempfile[17];
-#endif
-	if (!span)
-		return -EINVAL;
-	if (span->flags & ZT_FLAG_REGISTERED) {
-		printk(KERN_ERR "Span %s already appears to be registered\n", span->name);
-		return -EBUSY;
-	}
-	for (x=1;x<maxspans;x++)
-		if (spans[x] == span) {
-			printk(KERN_ERR "Span %s already in list\n", span->name);
-			return -EBUSY;
-		}
-	for (x=1;x<ZT_MAX_SPANS;x++)
-		if (!spans[x])
-			break;
-	if (x < ZT_MAX_SPANS) {
-		spans[x] = span;
-		if (maxspans < x + 1)
-			maxspans = x + 1;
-	} else {
-		printk(KERN_ERR "Too many zapata spans registered\n");
-		return -EBUSY;
-	}
-	span->flags |= ZT_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;
-	}
-
-	for (x=0;x<span->channels;x++) {
-		span->chans[x].span = span;
-		zt_chan_reg(&span->chans[x]); 
-	}
-
-#ifdef CONFIG_PROC_FS
-			sprintf(tempfile, "zaptel/%d", span->spanno);
-			proc_entries[span->spanno] = create_proc_read_entry(tempfile, 0444, NULL , zaptel_proc_read, (int *)(long)span->spanno);
-#endif
-
-#ifdef CONFIG_DEVFS_FS
-	{
-		char span_name[50];
-		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];
-			chan->fhandle = register_devfs_channel(chan, chan->span->dhandle); /* Register our stuff with devfs */
-		}
-	}
-#endif /* CONFIG_DEVFS_FS */
-
-#ifdef CONFIG_ZAP_UDEV
-	for (x = 0; x < span->channels; x++) {
-		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);
-		}
-	}
-#endif /* CONFIG_ZAP_UDEV */
-
-	if (debug)
-		printk("Registered Span %d ('%s') with %d channels\n", span->spanno, span->name, span->channels);
-	if (!master || prefmaster) {
-		master = span;
-		if (debug)
-			printk("Span ('%s') is new master\n", span->name);
-	}
-	return 0;
-}
-
-int zt_unregister(struct zt_span *span)
-{
-	int x;
-	int new_maxspans;
-	static struct zt_span *new_master;
-
-#ifdef CONFIG_PROC_FS
-	char tempfile[17];
-#endif /* CONFIG_PROC_FS */
-
-	if (!(span->flags & ZT_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->shutdown)
-			span->shutdown(span);
-			
-	if (spans[span->spanno] != span) {
-		printk(KERN_ERR "Span %s has spanno %d which is something else\n", span->name, span->spanno);
-		return -1;
-	}
-	if (debug)
-		printk("Unregistering Span '%s' with %d channels\n", span->name, span->channels);
-#ifdef CONFIG_PROC_FS
-	sprintf(tempfile, "zaptel/%d", span->spanno);
-        remove_proc_entry(tempfile, NULL);
-#endif /* CONFIG_PROC_FS */
-#ifdef CONFIG_DEVFS_FS
-	for (x = 0; x < span->channels; x++) {
-		devfs_unregister(span->chans[x].fhandle);
-		devfs_unregister(span->chans[x].fhandle_symlink);
-	}
-	devfs_unregister(span->dhandle);
-#endif /* CONFIG_DEVFS_FS */
-
-#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));
-	}
-#endif /* CONFIG_ZAP_UDEV */
-
-	spans[span->spanno] = NULL;
-	span->spanno = 0;
-	span->flags &= ~ZT_FLAG_REGISTERED;
-	for (x=0;x<span->channels;x++)
-		zt_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++) {
-		if (spans[x]) {
-			new_maxspans = x+1;
-			if (!new_master)
-				new_master = spans[x];
-		}
-	}
-	maxspans = new_maxspans;
-	if (master != new_master)
-		if (debug)
-			printk("%s: Span ('%s') is new master\n", __FUNCTION__, 
-				(new_master)? new_master->name: "no master");
-	master = new_master;
-
-	return 0;
-}
-
-/*
-** This routine converts from linear to ulaw
-**
-** Craig Reese: IDA/Supercomputing Research Center
-** Joe Campbell: Department of Defense
-** 29 September 1989
-**
-** References:
-** 1) CCITT Recommendation G.711  (very difficult to follow)
-** 2) "A New Digital Technique for Implementation of Any
-**     Continuous PCM Companding Law," Villeret, Michel,
-**     et al. 1973 IEEE Int. Conf. on Communications, Vol 1,
-**     1973, pg. 11.12-11.17
-** 3) MIL-STD-188-113,"Interoperability and Performance Standards
-**     for Analog-to_Digital Conversion Techniques,"
-**     17 February 1987
-**
-** Input: Signed 16 bit linear sample
-** Output: 8 bit ulaw sample
-*/
-
-#define ZEROTRAP    /* turn on the trap as per the MIL-STD */
-#define BIAS 0x84   /* define the add-in bias for 16 bit samples */
-#define CLIP 32635
-
-#ifdef CONFIG_CALC_XLAW
-unsigned char
-#else
-static unsigned char  __init
-#endif
-__zt_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,
-                             5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-                             5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-                             6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-                             6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-                             6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-                             6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-                             7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-                             7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-                             7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-                             7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-                             7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-                             7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-                             7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-                             7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};
-  int sign, exponent, mantissa;
-  unsigned char ulawbyte;
-
-  /* Get the sample into sign-magnitude. */
-  sign = (sample >> 8) & 0x80;          /* set aside the sign */
-  if (sign != 0) sample = -sample;              /* get magnitude */
-  if (sample > CLIP) sample = CLIP;             /* clip the magnitude */
-
-  /* Convert from 16 bit linear to ulaw. */
-  sample = sample + BIAS;
-  exponent = exp_lut[(sample >> 7) & 0xFF];
-  mantissa = (sample >> (exponent + 3)) & 0x0F;
-  ulawbyte = ~(sign | (exponent << 4) | mantissa);
-#ifdef ZEROTRAP
-  if (ulawbyte == 0) ulawbyte = 0x02;   /* optional CCITT trap */
-#endif
-  if (ulawbyte == 0xff) ulawbyte = 0x7f;   /* never return 0xff */
-  return(ulawbyte);
-}
-
-#define AMI_MASK 0x55
-
-#ifdef CONFIG_CALC_XLAW
-unsigned char
-#else
-static inline unsigned char __init
-#endif
-__zt_lineartoalaw (short linear)
-{
-    int mask;
-    int seg;
-    int pcm_val;
-    static int seg_end[8] =
-    {
-         0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF
-    };
-    
-    pcm_val = linear;
-    if (pcm_val >= 0)
-    {
-        /* Sign (7th) bit = 1 */
-        mask = AMI_MASK | 0x80;
-    }
-    else
-    {
-        /* Sign bit = 0 */
-        mask = AMI_MASK;
-        pcm_val = -pcm_val;
-    }
-
-    /* Convert the scaled magnitude to segment number. */
-    for (seg = 0;  seg < 8;  seg++)
-    {
-        if (pcm_val <= seg_end[seg])
-	    break;
-    }
-    /* Combine the sign, segment, and quantization bits. */
-    return  ((seg << 4) | ((pcm_val >> ((seg)  ?  (seg + 3)  :  4)) & 0x0F)) ^ mask;
-}
-/*- End of function --------------------------------------------------------*/
-
-static inline short int __init alaw2linear (uint8_t alaw)
-{
-    int i;
-    int seg;
-
-    alaw ^= AMI_MASK;
-    i = ((alaw & 0x0F) << 4);
-    seg = (((int) alaw & 0x70) >> 4);
-    if (seg)
-        i = (i + 0x100) << (seg - 1);
-    return (short int) ((alaw & 0x80)  ?  i  :  -i);
-}
-/*- End of function --------------------------------------------------------*/
-static void  __init zt_conv_init(void)
-{
-	int i;
-
-	/* 
-	 *  Set up mu-law conversion table
-	 */
-	for(i = 0;i < 256;i++)
-	   {
-		short mu,e,f,y;
-		static short etab[]={0,132,396,924,1980,4092,8316,16764};
-
-		mu = 255-i;
-		e = (mu & 0x70)/16;
-		f = mu & 0x0f;
-		y = f * (1 << (e + 3));
-		y += etab[e];
-		if (mu & 0x80) y = -y;
-	        __zt_mulaw[i] = y;
-		__zt_alaw[i] = alaw2linear(i);
-		/* Default (0.0 db) gain table */
-		defgain[i] = i;
-	   }
-#ifndef CONFIG_CALC_XLAW
-	  /* 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);
-	   }
-#endif
-}
-
-static inline void __zt_process_getaudio_chunk(struct zt_chan *ss, unsigned char *txb)
-{
-	/* We transmit data from our master channel */
-	/* Called with ss->lock held */
-	struct zt_chan *ms = ss->master;
-	/* Linear representation */
-	short getlin[ZT_CHUNKSIZE], k[ZT_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);
-#ifndef NO_ECHOCAN_DISABLE
-	if (ms->ec) {
-		for (x=0;x<ZT_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);
-				ms->echocancel = 0;
-				ms->echostate = ECHO_STATE_IDLE;
-				ms->echolastupdate = 0;
-				ms->echotimer = 0;
-				echo_can_free(ms->ec);
-				ms->ec = NULL;
-				__qevent(ss, ZT_EVENT_EC_DISABLED);
-				break;
-			}
-		}
-	}
-#endif
-	if ((!ms->confmute && !ms->dialing) || (ms->flags & ZT_FLAG_PSEUDO)) {
-		/* Handle conferencing on non-clear channel and non-HDLC channels */
-		switch(ms->confmode & ZT_CONF_MODE_MASK) {
-		case ZT_CONF_NORMAL:
-			/* Do nuffin */
-			break;
-		case ZT_CONF_MONITOR:	/* Monitor a channel's rx mode */
-			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO) break;
-			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_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);
-			break;
-		case ZT_CONF_MONITORTX: /* Monitor a channel's tx mode */
-			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO) break;
-			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_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);
-			break;
-		case ZT_CONF_MONITORBOTH: /* monitor a channel's rx and tx mode */
-			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_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);
-			break;
-		case ZT_CONF_MONITOR_RX_PREECHO:	/* Monitor a channel's rx mode */
-			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO)
-				break;
-
-			if (!chans[ms->confna]->readchunkpreec)
-				break;
-
-			/* Add monitored channel */
-			ACSS(getlin, chans[ms->confna]->flags & ZT_FLAG_PSEUDO ?
-			     chans[ms->confna]->readchunkpreec : chans[ms->confna]->putlin);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
-
-			break;
-		case ZT_CONF_MONITOR_TX_PREECHO: /* Monitor a channel's tx mode */
-			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO)
-				break;
-
-			if (!chans[ms->confna]->readchunkpreec)
-				break;
-
-			/* Add monitored channel */
-			ACSS(getlin, chans[ms->confna]->flags & ZT_FLAG_PSEUDO ?
-			     chans[ms->confna]->putlin : chans[ms->confna]->readchunkpreec);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				txb[x] = ZT_LIN2X(getlin[x], ms);
-
-			break;
-		case ZT_CONF_MONITORBOTH_PREECHO: /* monitor a channel's rx and tx mode */
-			  /* if a pseudo-channel, ignore */
-			if (ms->flags & ZT_FLAG_PSEUDO)
-				break;
-
-			if (!chans[ms->confna]->readchunkpreec)
-				break;
-
-			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);
-
-			break;
-		case ZT_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) {
-				/* Store temp value */
-				memcpy(k, getlin, ZT_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));
-				/*  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(getlin, 0, ZT_CHUNKSIZE * sizeof(short));
-			txb[0] = ZT_LIN2X(0, ms);
-			memset(txb + 1, txb[0], ZT_CHUNKSIZE - 1);
-			/* fall through to normal conf mode */
-		case ZT_CONF_CONF:	/* Normal conference mode */
-			if (ms->flags & ZT_FLAG_PSEUDO) /* if pseudo-channel */
-			   {
-				  /* if to talk on conf */
-				if (ms->confmode & ZT_CONF_TALKER) {
-					/* Store temp value */
-					memcpy(k, getlin, ZT_CHUNKSIZE * sizeof(short));
-					/* Add conf value */
-					ACSS(k, conf_sums[ms->_confn]);
-					/*  get amount actually added */
-					memcpy(ms->conflast, k, ZT_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));
-				memcpy(getlin, ms->getlin, ZT_CHUNKSIZE * sizeof(short));
-				txb[0] = ZT_LIN2X(0, ms);
-				memset(txb + 1, txb[0], ZT_CHUNKSIZE - 1);
-				break;
-		 	   }
-			/* fall through */
-		case ZT_CONF_CONFMON:	/* Conference monitor mode */
-			if (ms->confmode & ZT_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);
-			break;
-		case ZT_CONF_CONFANN:
-		case ZT_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));
-			/* If a listener on the conf... */
-			if (ms->confmode & ZT_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);
-			break;
-		case ZT_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 (ms->ec) {
-					for (x=0;x<ZT_CHUNKSIZE;x++)
-						txb[x] = ZT_LIN2X(chans[ms->confna]->getlin[x], ms);
-				} else {
-					memcpy(txb, chans[ms->confna]->getraw, ZT_CHUNKSIZE);
-				}
-			} else {
-				if (ms->ec) {
-					for (x=0;x<ZT_CHUNKSIZE;x++)
-						txb[x] = ZT_LIN2X(chans[ms->confna]->putlin[x], ms);
-				} else {
-					memcpy(txb, chans[ms->confna]->putraw, ZT_CHUNKSIZE);
-				}
-			}
-			for (x=0;x<ZT_CHUNKSIZE;x++)
-				getlin[x] = ZT_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);
-		if (ms->echostate == ECHO_STATE_STARTTRAINING) {
-			/* Transmit impulse now */
-			txb[0] = ZT_LIN2X(16384, ms);
-			ms->echostate = ECHO_STATE_AWAITINGECHO;
-		}
-	}
-	/* save value from last chunk */
-	memcpy(ms->getlin_lastchunk, ms->getlin, ZT_CHUNKSIZE * sizeof(short));
-	/* save value from current */
-	memcpy(ms->getlin, getlin, ZT_CHUNKSIZE * sizeof(short));
-	/* save value from current */
-	memcpy(ms->getraw, txb, ZT_CHUNKSIZE);
-	/* if to make tx tone */
-	if (ms->v1_1 || ms->v2_1 || ms->v3_1)
-	{
-		for (x=0;x<ZT_CHUNKSIZE;x++)
-		{
-			getlin[x] += zt_txtone_nextsample(ms);
-			txb[x] = ZT_LIN2X(getlin[x], ms);
-		}
-	}
-	/* This is what to send (after having applied gain) */
-	for (x=0;x<ZT_CHUNKSIZE;x++)
-		txb[x] = ms->txgain[txb[x]];
-}
-
-static inline void __zt_getbuf_chunk(struct zt_chan *ss, unsigned char *txb)
-{
-	/* Called with ss->lock held */
-	/* We transmit data from our master channel */
-	struct zt_chan *ms = ss->master;
-	/* Buffer we're using */
-	unsigned char *buf;
-	/* Old buffer number */
-	int oldbuf;
-	/* Linear representation */
-	int getlin;
-	/* How many bytes we need to process */
-	int bytes = ZT_CHUNKSIZE, left;
-	int x;
-
-	/* Let's pick something to transmit.  First source to
-	   try is our write-out buffer.  Always check it first because
-	   its our 'fast path' for whatever that's worth. */
-	while(bytes) {
-		if ((ms->outwritebuf > -1) && !ms->txdisable) {
-			buf= ms->writebuf[ms->outwritebuf];
-			left = ms->writen[ms->outwritebuf] - ms->writeidx[ms->outwritebuf];
-			if (left > bytes)
-				left = bytes;
-			if (ms->flags & ZT_FLAG_HDLC) {
-				/* If this is an HDLC channel we only send a byte of
-				   HDLC. */
-				for(x=0;x<left;x++) {
-					if (ms->txhdlc.bits < 8)
-						/* Load a byte of data only if needed */
-						fasthdlc_tx_load_nocheck(&ms->txhdlc, buf[ms->writeidx[ms->outwritebuf]++]);
-					*(txb++) = fasthdlc_tx_run_nocheck(&ms->txhdlc);
-				}
-				bytes -= left;
-			} else {
-				memcpy(txb, buf + ms->writeidx[ms->outwritebuf], left);
-				ms->writeidx[ms->outwritebuf]+=left;
-				txb += left;
-				bytes -= left;
-			}
-			/* Check buffer status */
-			if (ms->writeidx[ms->outwritebuf] >= ms->writen[ms->outwritebuf]) {
-				/* We've reached the end of our buffer.  Go to the next. */
-				oldbuf = ms->outwritebuf;
-				/* Clear out write index and such */
-				ms->writeidx[oldbuf] = 0;
-				ms->writen[oldbuf] = 0;
-				ms->outwritebuf = (ms->outwritebuf + 1) % ms->numbufs;
-				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))
-						wake_up_interruptible(&ms->eventbufq);
-					/* If we're only supposed to start when full, disable the transmitter */
-					if (ms->txbufpolicy == ZT_POLICY_WHEN_FULL)
-						ms->txdisable = 1;
-				}
-				if (ms->inwritebuf < 0) {
-					/* The filler doesn't have a place to put data.  Now
-					that we're done with this buffer, notify them. */
-					ms->inwritebuf = oldbuf;
-				}
-/* In the very orignal driver, it was quite well known to me (Jim) that there
-was a possibility that a channel sleeping on a write block needed to
-be potentially woken up EVERY time a buffer was emptied, not just on the first
-one, because if only done on the first one there is a slight timing potential
-of missing the wakeup (between where it senses the (lack of) active condition
-(with interrupts disabled) and where it does the sleep (interrupts enabled)
-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))) {
-					wake_up_interruptible(&ms->writebufq);
-					wake_up_interruptible(&ms->sel);
-					if (ms->iomask & ZT_IOMUX_WRITE)
-						wake_up_interruptible(&ms->eventbufq);
-				}
-				/* Transmit a flag if this is an HDLC channel */
-				if (ms->flags & ZT_FLAG_HDLC)
-					fasthdlc_tx_frame_nocheck(&ms->txhdlc);
-#ifdef CONFIG_ZAPATA_NET
-				if (ms->flags & ZT_FLAG_NETDEV)
-					netif_wake_queue(ztchan_to_dev(ms));
-#endif				
-#ifdef CONFIG_ZAPATA_PPP
-				if (ms->flags & ZT_FLAG_PPP) {
-					ms->do_ppp_wakeup = 1;
-					tasklet_schedule(&ms->ppp_calls);
-				}
-#endif
-			}
-		} else if (ms->curtone && !(ms->flags & ZT_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);
-			}
-			ms->tonep+=left;
-			bytes -= left;
-			if (ms->tonep >= ms->curtone->tonesamples) {
-				struct zt_tone *last;
-				/* Go to the next sample of the tone */
-				ms->tonep = 0;
-				last = ms->curtone;
-				ms->curtone = ms->curtone->next;
-				if (!ms->curtone) {
-					/* No more tones...  Is this dtmf or mf?  If so, go to the next digit */
-					if (ms->dialing)
-						__do_dtmf(ms);
-				} else {
-					if (last != ms->curtone)
-						zt_init_tone_state(&ms->ts, ms->curtone);
-				}
-			}
-		} else if (ms->flags & ZT_FLAG_LOOPED) {
-			for (x = 0; x < bytes; x++)
-				txb[x] = ms->readchunk[x];
-			bytes = 0;
-		} else if (ms->flags & ZT_FLAG_HDLC) {
-			for (x=0;x<bytes;x++) {
-				/* Okay, if we're HDLC, then transmit a flag by default */
-				if (ms->txhdlc.bits < 8) 
-					fasthdlc_tx_frame_nocheck(&ms->txhdlc);
-				*(txb++) = fasthdlc_tx_run_nocheck(&ms->txhdlc);
-			}
-			bytes = 0;
-		} else if (ms->flags & ZT_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);
-			} else {
-				memset(txb, 0xFF, bytes);
-			}
-			bytes = 0;
-		} else {
-			memset(txb, ZT_LIN2X(0, ms), bytes);	/* Lastly we use silence on telephony channels */
-			bytes = 0;
-		}
-	}	
-}
-
-static inline void rbs_itimer_expire(struct zt_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);
-		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); 
-			break;
-		}
-		__qevent(chan,ZT_EVENT_RINGOFFHOOK); 
-		break;
-#endif
-#ifdef	FXSFLASH
-	    case ZT_SIG_FXSKS:
-		if (chan->rxhooksig == ZT_RXSIG_ONHOOK) {
-			__qevent(chan, ZT_EVENT_ONHOOK); 
-			break;
-		}
-#endif
-		/* fall thru intentionally */
-	    default:  /* otherwise, its definitely off hook */
-		__qevent(chan,ZT_EVENT_RINGOFFHOOK); 
-		break;
-	}
-}
-
-static inline void __rbs_otimer_expire(struct zt_chan *chan)
-{
-	int len = 0;
-	/* Called with chan->lock held */
-
-	chan->otimer = 0;
-	/* Move to the next timer state */	
-	switch(chan->txstate) {
-	case ZT_TXSTATE_RINGOFF:
-		/* Turn on the ringer now that the silent time has passed */
-		++chan->cadencepos;
-		if (chan->cadencepos >= ZT_MAX_CADENCE)
-			chan->cadencepos = chan->firstcadencepos;
-		len = chan->ringcadence[chan->cadencepos];
-
-		if (!len) {
-			chan->cadencepos = chan->firstcadencepos;
-			len = chan->ringcadence[chan->cadencepos];
-		}
-
-		zt_rbs_sethook(chan, ZT_TXSIG_START, ZT_TXSTATE_RINGON, len);
-		__qevent(chan, ZT_EVENT_RINGERON);
-		break;
-		
-	case ZT_TXSTATE_RINGON:
-		/* Turn off the ringer now that the loud time has passed */
-		++chan->cadencepos;
-		if (chan->cadencepos >= ZT_MAX_CADENCE)
-			chan->cadencepos = 0;
-		len = chan->ringcadence[chan->cadencepos];
-
-		if (!len) {
-			chan->cadencepos = 0;
-			len = chan->curzone->ringcadence[chan->cadencepos];
-		}
-
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_RINGOFF, len);
-		__qevent(chan, ZT_EVENT_RINGEROFF);
-		break;
-		
-	case ZT_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);
-		wake_up_interruptible(&chan->txstateq);
-		break;
-		
-	case ZT_TXSTATE_PREWINK:
-		/* Actually wink */
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_WINK, chan->winktime);
-		break;
-		
-	case ZT_TXSTATE_WINK:
-		/* Wink complete, go on hook and stabalize */
-		zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_ONHOOK, 0);
-		if (chan->file && (chan->file->f_flags & O_NONBLOCK))
-			__qevent(chan, ZT_EVENT_HOOKCOMPLETE);
-		wake_up_interruptible(&chan->txstateq);
-		break;
-		
-	case ZT_TXSTATE_PREFLASH:
-		/* Actually flash */
-		zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_FLASH, chan->flashtime);
-		break;
-
-	case ZT_TXSTATE_FLASH:
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_OFFHOOK, 0);
-		if (chan->file && (chan->file->f_flags & O_NONBLOCK))
-			__qevent(chan, ZT_EVENT_HOOKCOMPLETE);
-		wake_up_interruptible(&chan->txstateq);
-		break;
-	
-	case ZT_TXSTATE_DEBOUNCE:
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_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;
-		wake_up_interruptible(&chan->txstateq);
-		break;
-		
-	case ZT_TXSTATE_AFTERSTART:
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_OFFHOOK, 0);
-		if (chan->file && (chan->file->f_flags & O_NONBLOCK))
-			__qevent(chan, ZT_EVENT_HOOKCOMPLETE);
-		wake_up_interruptible(&chan->txstateq);
-		break;
-
-	case ZT_TXSTATE_KEWL:
-		zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, ZT_TXSTATE_AFTERKEWL, ZT_AFTERKEWLTIME);
-		if (chan->file && (chan->file->f_flags & O_NONBLOCK))
-			__qevent(chan, ZT_EVENT_HOOKCOMPLETE);
-		wake_up_interruptible(&chan->txstateq);
-		break;
-
-	case ZT_TXSTATE_AFTERKEWL:
-		if (chan->kewlonhook)  {
-			__qevent(chan,ZT_EVENT_ONHOOK);
-		}
-		chan->txstate = ZT_TXSTATE_ONHOOK;
-		chan->gotgs = 0;
-		break;
-
-	case ZT_TXSTATE_PULSEBREAK:
-		zt_rbs_sethook(chan, ZT_TXSIG_OFFHOOK, ZT_TXSTATE_PULSEMAKE, 
-			chan->pulsemaketime);
-		wake_up_interruptible(&chan->txstateq);
-		break;
-
-	case ZT_TXSTATE_PULSEMAKE:
-		if (chan->pdialcount)
-			chan->pdialcount--;
-		if (chan->pdialcount)
-		{
-			zt_rbs_sethook(chan, ZT_TXSIG_ONHOOK, 
-				ZT_TXSTATE_PULSEBREAK, chan->pulsebreaktime);
-			break;
-		}
-		chan->txstate = ZT_TXSTATE_PULSEAFTER;
-		chan->otimer = chan->pulseaftertime * ZT_CHUNKSIZE;
-		wake_up_interruptible(&chan->txstateq);
-		break;
-
-	case ZT_TXSTATE_PULSEAFTER:
-		chan->txstate = ZT_TXSTATE_OFFHOOK;
-		__do_dtmf(chan);
-		wake_up_interruptible(&chan->txstateq);
-		break;
-
-	default:
-		break;
-	}
-}
-
-static void __zt_hooksig_pvt(struct zt_chan *chan, zt_rxsig_t rxsig)
-{
-
-	/* State machines for receive hookstate transitions 
-		called with chan->lock held */
-
-	if ((chan->rxhooksig) == rxsig) return;
-	
-	if ((chan->flags & ZT_FLAG_SIGFREEZE)) return;
-
-	chan->rxhooksig = rxsig;
-#ifdef	RINGBEGIN
-	if ((chan->sig & __ZT_SIG_FXS) && (rxsig == ZT_RXSIG_RING) &&
-	    (!chan->ringdebtimer))
-		__qevent(chan,ZT_EVENT_RINGBEGIN);  
-#endif
-	switch(chan->sig) {
-	    case ZT_SIG_EM:  /* E and M */
-	    case ZT_SIG_EM_E1:
-		switch(rxsig) {
-		    case ZT_RXSIG_OFFHOOK: /* went off hook */
-			/* The interface is going off hook */
-#ifdef	EMFLASH
-			if (chan->itimer)
-			{
-				__qevent(chan,ZT_EVENT_WINKFLASH); 
-				chan->itimerset = chan->itimer = 0;
-				break;				
-			}
-#endif
-#ifdef EMPULSE
-			if (chan->itimer) /* if timer still running */
-			{
-			    int plen = chan->itimerset - chan->itimer;
-			    if (plen <= ZT_MAXPULSETIME)
-			    {
-					if (plen >= ZT_MINPULSETIME)
-					{
-						chan->pulsecount++;
-
-						chan->pulsetimer = ZT_PULSETIMEOUT;
-                                                chan->itimerset = chan->itimer = 0;
-						if (chan->pulsecount == 1)
-							__qevent(chan,ZT_EVENT_PULSE_START); 
-					} 
-			    } 
-			    break;
-			}
-#endif
-			/* set wink timer */
-			chan->itimerset = chan->itimer = chan->rxwinktime * ZT_CHUNKSIZE;
-			break;
-		    case ZT_RXSIG_ONHOOK: /* went on hook */
-			/* This interface is now going on hook.
-			   Check for WINK, etc */
-			if (chan->itimer)
-				__qevent(chan,ZT_EVENT_WINKFLASH); 
-#if defined(EMFLASH) || defined(EMPULSE)
-			else {
-#ifdef EMFLASH
-				chan->itimerset = chan->itimer = chan->rxflashtime * ZT_CHUNKSIZE;
-
-#else /* EMFLASH */
-				chan->itimerset = chan->itimer = chan->rxwinktime * ZT_CHUNKSIZE;
-
-#endif /* EMFLASH */
-				chan->gotgs = 0;
-				break;				
-			}
-#else /* EMFLASH || EMPULSE */
-			else {
-				__qevent(chan,ZT_EVENT_ONHOOK); 
-				chan->gotgs = 0;
-			}
-#endif
-			chan->itimerset = chan->itimer = 0;
-			break;
-		    default:
-			break;
-		}
-		break;
-	   case ZT_SIG_FXSKS:  /* FXS Kewlstart */
-		  /* ignore a bit poopy if loop not closed and stable */
-		if (chan->txstate != ZT_TXSTATE_OFFHOOK) break;
-#ifdef	FXSFLASH
-		if (rxsig == ZT_RXSIG_ONHOOK) {
-			chan->itimer = ZT_FXSFLASHMAXTIME * ZT_CHUNKSIZE;
-			break;
-		} else 	if (rxsig == ZT_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);
-			}
-			chan->itimer = 0;
-			break;
-		}
-#endif
-		/* fall through intentionally */
-	   case ZT_SIG_FXSGS:  /* FXS Groundstart */
-		if (rxsig == ZT_RXSIG_ONHOOK) {
-			chan->ringdebtimer = RING_DEBOUNCE_TIME;
-			chan->ringtrailer = 0;
-			if (chan->txstate != ZT_TXSTATE_DEBOUNCE) {
-				chan->gotgs = 0;
-				__qevent(chan,ZT_EVENT_ONHOOK);
-			}
-		}
-		break;
-	   case ZT_SIG_FXOGS: /* FXO Groundstart */
-		if (rxsig == ZT_RXSIG_START) {
-			  /* if havent got gs, report it */
-			if (!chan->gotgs) {
-				__qevent(chan,ZT_EVENT_RINGOFFHOOK);
-				chan->gotgs = 1;
-			}
-		}
-		/* fall through intentionally */
-	   case ZT_SIG_FXOLS: /* FXO Loopstart */
-	   case ZT_SIG_FXOKS: /* FXO Kewlstart */
-		switch(rxsig) {
-		    case ZT_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);
-			}
-			chan->kewlonhook = 0;
-#ifdef CONFIG_ZAPATA_DEBUG
-			printk("Off hook on channel %d, itimer = %d, gotgs = %d\n", chan->channo, chan->itimer, chan->gotgs);
-#endif
-			if (chan->itimer) /* if timer still running */
-			{
-			    int plen = chan->itimerset - chan->itimer;
-			    if (plen <= ZT_MAXPULSETIME)
-			    {
-					if (plen >= ZT_MINPULSETIME)
-					{
-						chan->pulsecount++;
-						chan->pulsetimer = ZT_PULSETIMEOUT;
-						chan->itimer = chan->itimerset;
-						if (chan->pulsecount == 1)
-							__qevent(chan,ZT_EVENT_PULSE_START); 
-					} 
-			    } else 
-					__qevent(chan,ZT_EVENT_WINKFLASH); 
-			} else {
-				  /* if havent got GS detect */
-				if (!chan->gotgs) {
-					__qevent(chan,ZT_EVENT_RINGOFFHOOK); 
-					chan->gotgs = 1;
-					chan->itimerset = chan->itimer = 0;
-				}
-			}
-			chan->itimerset = chan->itimer = 0;
-			break;
-		    case ZT_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 == ZT_TXSTATE_KEWL)
-				chan->kewlonhook = 1;
-			break;
-		    default:
-			break;
-		}
-	    default:
-		break;
-	}
-}
-
-void zt_hooksig(struct zt_chan *chan, zt_rxsig_t rxsig)
-{
-	  /* skip if no change */
-	unsigned long flags;
-	spin_lock_irqsave(&chan->lock, flags);
-	__zt_hooksig_pvt(chan,rxsig);
-	spin_unlock_irqrestore(&chan->lock, flags);
-}
-
-void zt_rbsbits(struct zt_chan *chan, int cursig)
-{
-	unsigned long flags;
-	if (cursig == chan->rxsig)
-		return;
-
-	if ((chan->flags & ZT_FLAG_SIGFREEZE)) return;
-
-	spin_lock_irqsave(&chan->lock, flags);
-	switch(chan->sig) {
-	    case ZT_SIG_FXOGS: /* FXO Groundstart */
-		/* B-bit only matters for FXO GS */
-		if (!(cursig & ZT_BBIT)) {
-			__zt_hooksig_pvt(chan, ZT_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);
-		else /* on hook */
-			__zt_hooksig_pvt(chan,ZT_RXSIG_ONHOOK);
-		break;
-
-	   case ZT_SIG_FXSKS:  /* FXS Kewlstart */
-	   case ZT_SIG_FXSGS:  /* FXS Groundstart */
-		/* Fall through */
-	   case ZT_SIG_FXSLS:
-		if (!(cursig & ZT_BBIT)) {
-			/* Check for ringing first */
-			__zt_hooksig_pvt(chan, ZT_RXSIG_RING);
-			break;
-		}
-		if ((chan->sig != ZT_SIG_FXSLS) && (cursig & ZT_ABIT)) { 
-			    /* if went on hook */
-			__zt_hooksig_pvt(chan, ZT_RXSIG_ONHOOK);
-		} else {
-			__zt_hooksig_pvt(chan, ZT_RXSIG_OFFHOOK);
-		}
-		break;
-	   case ZT_SIG_CAS:
-		/* send event that something changed */
-		__qevent(chan, ZT_EVENT_BITSCHANGED);
-		break;
-
-	   default:
-		break;
-	}
-	/* Keep track of signalling for next time */
-	chan->rxsig = cursig;
-	spin_unlock_irqrestore(&chan->lock, flags);
-}
-
-static inline void __zt_ec_chunk(struct zt_chan *ss, unsigned char *rxchunk, const unsigned char *txchunk)
-{
-	short rxlin, txlin;
-	int x;
-	unsigned long flags;
-
-	spin_lock_irqsave(&ss->lock, flags);
-
-	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++)
-			/* We only ever really need to deal with signed linear - let's just convert it now */
-			ss->readchunkpreec[x] = ZT_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();
-#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);
-				if (ss->echostate == ECHO_STATE_PRETRAINING) {
-					if (--ss->echotimer <= 0) {
-						ss->echotimer = 0;
-						ss->echostate = ECHO_STATE_STARTTRAINING;
-					}
-				}
-				if ((ss->echostate == ECHO_STATE_AWAITINGECHO) && (txlin > 8000)) {
-					ss->echolastupdate = 0;
-					ss->echostate = ECHO_STATE_TRAINING;
-				}
-				if (ss->echostate == ECHO_STATE_TRAINING) {
-					if (echo_can_traintap(ss->ec, ss->echolastupdate++, rxlin)) {
-#if 0
-						printk("Finished training (%d taps trained)!\n", ss->echolastupdate);
-#endif						
-						ss->echostate = ECHO_STATE_ACTIVE;
-					}
-				}
-				rxlin = 0;
-				rxchunk[x] = ZT_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);
-			}
-#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);
-			}
-			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) */
-		}
-#if defined(CONFIG_ZAPTEL_MMX) || defined(ECHO_CAN_FP)
-		kernel_fpu_end();
-#endif		
-	}
-	spin_unlock_irqrestore(&ss->lock, flags);
-}
-
-void zt_ec_chunk(struct zt_chan *ss, unsigned char *rxchunk, const unsigned char *txchunk)
-{
-	__zt_ec_chunk(ss, rxchunk, txchunk);
-}
-
-void zt_ec_span(struct zt_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);
-	}
-}
-
-/* return 0 if nothing detected, 1 if lack of tone, 2 if presence of tone */
-/* modifies buffer pointed to by 'amp' with notched-out values */
-static inline int sf_detect (sf_detect_state_t *s,
-                 short *amp,
-                 int samples,long p1, long p2, long p3)
-{
-int     i,rv = 0;
-long x,y;
-
-#define	SF_DETECT_SAMPLES (ZT_CHUNKSIZE * 5)
-#define	SF_DETECT_MIN_ENERGY 500
-#define	NB 14  /* number of bits to shift left */
-         
-        /* determine energy level before filtering */
-        for(i = 0; i < samples; i++)
-        {
-                if (amp[i] < 0) s->e1 -= amp[i];
-                else s->e1 += amp[i];
-        }
-	/* do 2nd order IIR notch filter at given freq. and calculate
-	    energy */
-        for(i = 0; i < samples; i++)
-        {
-                x = amp[i] << NB;
-                y = s->x2 + (p1 * (s->x1 >> NB)) + x;
-                y += (p2 * (s->y2 >> NB)) + 
-			(p3 * (s->y1 >> NB));
-                s->x2 = s->x1;
-                s->x1 = x;
-                s->y2 = s->y1;
-                s->y1 = y;
-                amp[i] = y >> NB;
-                if (amp[i] < 0) s->e2 -= amp[i];
-                else s->e2 += amp[i];
-        }
-	s->samps += i;
-	/* if time to do determination */
-	if ((s->samps) >= SF_DETECT_SAMPLES)
-	{
-		rv = 1; /* default to no tone */
-		/* if enough energy, it is determined to be a tone */
-		if (((s->e1 - s->e2) / s->samps) > SF_DETECT_MIN_ENERGY) rv = 2;
-		/* reset energy processing variables */
-		s->samps = 0;
-		s->e1 = s->e2 = 0;
-	}
-	return(rv);		
-}
-
-static inline void __zt_process_putaudio_chunk(struct zt_chan *ss, unsigned char *rxb)
-{
-	/* We transmit data from our master channel */
-	/* Called with ss->lock held */
-	struct zt_chan *ms = ss->master;
-	/* Linear version of received data */
-	short putlin[ZT_CHUNKSIZE],k[ZT_CHUNKSIZE];
-	int x,r;
-
-	if (ms->dialing) ms->afterdialingtimer = 50;
-	else if (ms->afterdialingtimer) ms->afterdialingtimer--;
-	if (ms->afterdialingtimer && (!(ms->flags & ZT_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 */
-	} 
-	for (x=0;x<ZT_CHUNKSIZE;x++) {
-		rxb[x] = ms->rxgain[rxb[x]];
-		putlin[x] = ZT_XLAW(rxb[x], ms);
-	}
-
-#ifndef NO_ECHOCAN_DISABLE
-	if (ms->ec) {
-		for (x=0;x<ZT_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;
-				ms->echostate = ECHO_STATE_IDLE;
-				ms->echolastupdate = 0;
-				ms->echotimer = 0;
-				echo_can_free(ms->ec);
-				ms->ec = NULL;
-				break;
-			}
-		}
-	}
-#endif	
-	/* if doing rx tone decoding */
-	if (ms->rxp1 && ms->rxp2 && ms->rxp3)
-	{
-		r = sf_detect(&ms->rd,putlin,ZT_CHUNKSIZE,ms->rxp1,
-			ms->rxp2,ms->rxp3);
-		/* Convert back */
-		for(x=0;x<ZT_CHUNKSIZE;x++)
-			rxb[x] = ZT_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)))
-				{
-					__qevent(ms,ZT_EVENT_RINGOFFHOOK);
-				}
-				else
-				{
-					__qevent(ms,ZT_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);
-	}
-	
-	/* 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 */
-			/* Do nothing.  rx goes output */
-			break;
-		case ZT_CONF_MONITOR:		/* Monitor a channel's rx mode */
-			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO)) break;
-			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_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);
-			break;
-		case ZT_CONF_MONITORTX:	/* Monitor a channel's tx mode */
-			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO)) break;
-			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_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);
-			break;
-		case ZT_CONF_MONITORBOTH:	/* Monitor a channel's tx and rx mode */
-			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_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
-			   when you're so loud you're clipping anyway */
-			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);
-			break;
-		case ZT_CONF_MONITOR_RX_PREECHO:		/* Monitor a channel's rx mode */
-			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO))
-				break;
-
-			if (!chans[ms->confna]->readchunkpreec)
-				break;
-
-			/* Add monitored channel */
-			ACSS(putlin, chans[ms->confna]->flags & ZT_FLAG_PSEUDO ?
-			     chans[ms->confna]->getlin : chans[ms->confna]->readchunkpreec);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				rxb[x] = ZT_LIN2X(putlin[x], ms);
-
-			break;
-		case ZT_CONF_MONITOR_TX_PREECHO:	/* Monitor a channel's tx mode */
-			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO))
-				break;
-
-			if (!chans[ms->confna]->readchunkpreec)
-				break;
-
-			/* Add monitored channel */
-			ACSS(putlin, chans[ms->confna]->flags & ZT_FLAG_PSEUDO ?
-			     chans[ms->confna]->readchunkpreec : chans[ms->confna]->getlin);
-			for (x = 0; x < ZT_CHUNKSIZE; x++)
-				rxb[x] = ZT_LIN2X(putlin[x], ms);
-
-			break;
-		case ZT_CONF_MONITORBOTH_PREECHO:	/* Monitor a channel's tx and rx mode */
-			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO))
-				break;
-
-			if (!chans[ms->confna]->readchunkpreec)
-				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
-			   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);
-
-			break;
-		case ZT_CONF_REALANDPSEUDO:
-			  /* do normal conf mode processing */
-			if (ms->confmode & ZT_CONF_TALKER) {
-				/* Store temp value */
-				memcpy(k, putlin, ZT_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));
-				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));
-			  /* do the pseudo-channel part processing */
-			memset(putlin, 0, ZT_CHUNKSIZE * sizeof(short));
-			if (ms->confmode & ZT_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);
-			break;
-		case ZT_CONF_CONF:	/* Normal conference mode */
-			if (ms->flags & ZT_FLAG_PSEUDO) /* if a pseudo-channel */
-			   {
-				if (ms->confmode & ZT_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->getlin, putlin, ZT_CHUNKSIZE * sizeof(short));
-				break;
-			   }
-			/* fall through */
-		case ZT_CONF_CONFANN:  /* Conference with announce */
-			if (ms->confmode & ZT_CONF_TALKER) {
-				/* Store temp value */
-				memcpy(k, putlin, ZT_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));
-				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));
-			  /* rxc unmodified */
-			break;
-		case ZT_CONF_CONFMON:
-		case ZT_CONF_CONFANNMON:
-			if (ms->confmode & ZT_CONF_TALKER) {
-				/* Store temp value */
-				memcpy(k, putlin, ZT_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));
-				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);
-			break;
-		case ZT_CONF_DIGITALMON:
-			  /* if not a pseudo-channel, ignore */
-			if (!(ms->flags & ZT_FLAG_PSEUDO)) break;
-			/* Add monitored channel */
-			if (chans[ms->confna]->flags & ZT_FLAG_PSEUDO) {
-				memcpy(rxb, chans[ms->confna]->getraw, ZT_CHUNKSIZE);
-			} else {
-				memcpy(rxb, chans[ms->confna]->putraw, ZT_CHUNKSIZE);
-			}
-			break;			
-		}
-	}
-}
-
-/* HDLC (or other) receiver buffer functions for read side */
-static inline void __putbuf_chunk(struct zt_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;
-	/* Our receive buffer */
-	unsigned char *buf;
-#if defined(CONFIG_ZAPATA_NET)  || defined(CONFIG_ZAPATA_PPP)
-	/* SKB for receiving network stuff */
-	struct sk_buff *skb=NULL;
-#endif	
-	int oldbuf;
-	int eof=0;
-	int abort=0;
-	int res;
-	int left, x;
-
-	while(bytes) {
-#if defined(CONFIG_ZAPATA_NET)  || defined(CONFIG_ZAPATA_PPP)
-		skb = NULL;
-#endif	
-		abort = 0;
-		eof = 0;
-		/* Next, figure out if we've got a buffer to receive into */
-		if (ms->inreadbuf > -1) {
-			/* Read into the current buffer */
-			buf = ms->readbuf[ms->inreadbuf];
-			left = ms->blocksize - ms->readidx[ms->inreadbuf];
-			if (left > bytes)
-				left = bytes;
-			if (ms->flags & ZT_FLAG_HDLC) {
-				for (x=0;x<left;x++) {
-					/* Handle HDLC deframing */
-					fasthdlc_rx_load_nocheck(&ms->rxhdlc, *(rxb++));
-					bytes--;
-					res = fasthdlc_rx_run(&ms->rxhdlc);
-					/* If there is nothing there, continue */
-					if (res & RETURN_EMPTY_FLAG)
-						continue;
-					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;
-							} else
-								eof=1;
-							break;
-						}
-						continue;
-					} else if (res & RETURN_DISCARD_FLAG) {
-						/* This could be someone idling with 
-						  "idle" instead of "flag" */
-						if (!ms->readidx[ms->inreadbuf])
-							continue;
-						abort = ZT_EVENT_ABORT;
-						break;
-					} else {
-						unsigned char rxc;
-						rxc = res;
-						ms->infcs = PPP_FCS(ms->infcs, rxc);
-						buf[ms->readidx[ms->inreadbuf]++] = rxc;
-						/* Pay attention to the possibility of an overrun */
-						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;
-							/* Force the HDLC state back to frame-search mode */
-							ms->rxhdlc.state = 0;
-							ms->rxhdlc.bits = 0;
-							ms->readidx[ms->inreadbuf]=0;
-							break;
-						}
-					}
-				}
-			} else {
-				/* Not HDLC */
-				memcpy(buf + ms->readidx[ms->inreadbuf], rxb, left);
-				rxb += left;
-				ms->readidx[ms->inreadbuf] += left;
-				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)) {
-					eof = 0;
-					abort = ZT_EVENT_OVERRUN;
-				}
-			}
-			if (eof)  {
-				/* Finished with this buffer, try another. */
-				oldbuf = ms->inreadbuf;
-				ms->infcs = PPP_INITFCS;
-				ms->readn[ms->inreadbuf] = ms->readidx[ms->inreadbuf];
-#ifdef CONFIG_ZAPATA_DEBUG
-				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)) {
-#ifdef CONFIG_ZAPATA_NET
-#endif /* CONFIG_ZAPATA_NET */
-					/* Our network receiver logic is MUCH
-					  different.  We actually only use a single
-					  buffer */
-					if (ms->readn[ms->inreadbuf] > 1) {
-						/* Drop the FCS */
-						ms->readn[ms->inreadbuf] -= 2;
-						/* Allocate an SKB */
-#ifdef CONFIG_ZAPATA_PPP
-						if (!ms->do_ppp_error)
-#endif
-							skb = dev_alloc_skb(ms->readn[ms->inreadbuf]);
-						if (skb) {
-							/* XXX Get rid of this memcpy XXX */
-							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) {
-#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_packets++;
-								stats->rx_bytes += ms->readn[ms->inreadbuf];
-							}
-#endif
-
-						} else {
-#ifdef CONFIG_ZAPATA_NET
-							if (ms->flags & ZT_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_dropped++;
-							}
-#endif
-#ifdef CONFIG_ZAPATA_PPP
-							if (ms->flags & ZT_FLAG_PPP) {
-								abort = ZT_EVENT_OVERRUN;
-							}
-#endif
-#if 1
-#ifdef CONFIG_ZAPATA_PPP
-							if (!ms->do_ppp_error)
-#endif
-								printk("Memory squeeze, dropped one\n");
-#endif
-						}
-					}
-					/* We don't cycle through buffers, just
-					reuse the same one */
-					ms->readn[ms->inreadbuf] = 0;
-					ms->readidx[ms->inreadbuf] = 0;
-				} else 
-#endif
-				{
-					ms->inreadbuf = (ms->inreadbuf + 1) % ms->numbufs;
-					if (ms->inreadbuf == ms->outreadbuf) {
-						/* Whoops, we're full, and have no where else
-						to store into at the moment.  We'll drop it
-						until there's a buffer available */
-#ifdef CONFIG_ZAPATA_DEBUG
-						printk("Out of storage space\n");
-#endif
-						ms->inreadbuf = -1;
-						/* Enable the receiver in case they've got POLICY_WHEN_FULL */
-						ms->rxdisable = 0;
-					}
-					if (ms->outreadbuf < 0) { /* start out buffer if not already */
-						ms->outreadbuf = oldbuf;
-					}
-/* In the very orignal driver, it was quite well known to me (Jim) that there
-was a possibility that a channel sleeping on a receive block needed to
-be potentially woken up EVERY time a buffer was filled, not just on the first
-one, because if only done on the first one there is a slight timing potential
-of missing the wakeup (between where it senses the (lack of) active condition
-(with interrupts disabled) and where it does the sleep (interrupts enabled)
-in the read or iomux call, etc). That is why the read 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->rxdisable) { /* if receiver enabled */
-						/* Notify a blocked reader that there is data available
-						to be read, unless we're waiting for it to be full */
-#ifdef CONFIG_ZAPATA_DEBUG
-						printk("Notifying reader data in block %d\n", oldbuf);
-#endif
-						wake_up_interruptible(&ms->readbufq);
-						wake_up_interruptible(&ms->sel);
-						if (ms->iomask & ZT_IOMUX_READ)
-							wake_up_interruptible(&ms->eventbufq);
-					}
-				}
-			}
-			if (abort) {
-				/* Start over reading frame */
-				ms->readidx[ms->inreadbuf] = 0;
-				ms->infcs = PPP_INITFCS;
-
-#ifdef CONFIG_ZAPATA_NET
-				if (ms->flags & ZT_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)
-						stats->rx_over_errors++;
-					if (abort == ZT_EVENT_BADFCS)
-						stats->rx_crc_errors++;
-					if (abort == ZT_EVENT_ABORT)
-						stats->rx_frame_errors++;
-				} else 
-#endif			
-#ifdef CONFIG_ZAPATA_PPP
-				if (ms->flags & ZT_FLAG_PPP) {
-					ms->do_ppp_error = 1;
-					tasklet_schedule(&ms->ppp_calls);
-				} else
-#endif
-
-				if ((ms->flags & ZT_FLAG_OPEN) && !ss->span->alarms) 
-						/* Notify the receiver... */
-					__qevent(ss->master, abort);
-#if 0
-				printk("torintr_receive: Aborted %d bytes of frame on %d\n", amt, ss->master);
-#endif
-
-			}
-		} else /* No place to receive -- drop on the floor */
-			break;
-#ifdef CONFIG_ZAPATA_NET
-		if (skb && (ms->flags & ZT_FLAG_NETDEV))
-#ifdef NEW_HDLC_INTERFACE
-		{
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)
-			skb->mac.raw = skb->data;
-#else
-			skb_reset_mac_header(skb);
-#endif
-			skb->dev = ztchan_to_dev(ms);
-#ifdef ZAP_HDLC_TYPE_TRANS
-			skb->protocol = hdlc_type_trans(skb, ztchan_to_dev(ms));
-#else
-			skb->protocol = htons (ETH_P_HDLC);
-#endif
-			netif_rx(skb);
-		}
-#else
-			hdlc_netif_rx(&ms->hdlcnetdev->netdev, skb);
-#endif
-#endif
-#ifdef CONFIG_ZAPATA_PPP
-		if (skb && (ms->flags & ZT_FLAG_PPP)) {
-			unsigned char *tmp;
-			tmp = skb->data;
-			skb_pull(skb, 2);
-			/* Make sure that it's addressed to ALL STATIONS and UNNUMBERED */
-			if (!tmp || (tmp[0] != 0xff) || (tmp[1] != 0x03)) {
-				/* Invalid SKB -- drop */
-				if (tmp)
-					printk("Received invalid SKB (%02x, %02x)\n", tmp[0], tmp[1]);
-				dev_kfree_skb_irq(skb);
-			} else {
-				skb_queue_tail(&ms->ppp_rq, skb);
-				tasklet_schedule(&ms->ppp_calls);
-			}
-		}
-#endif
-	}
-}
-
-static inline void __zt_putbuf_chunk(struct zt_chan *ss, unsigned char *rxb)
-{
-	__putbuf_chunk(ss, rxb, ZT_CHUNKSIZE);
-}
-
-static void __zt_hdlc_abort(struct zt_chan *ss, int event)
-{
-	if (ss->inreadbuf >= 0)
-		ss->readidx[ss->inreadbuf] = 0;
-	if ((ss->flags & ZT_FLAG_OPEN) && !ss->span->alarms)
-		__qevent(ss->master, event);
-}
-
-extern void zt_hdlc_abort(struct zt_chan *ss, int event)
-{
-	unsigned long flags;
-	spin_lock_irqsave(&ss->lock, flags);
-	__zt_hdlc_abort(ss, event);
-	spin_unlock_irqrestore(&ss->lock, flags);
-}
-
-extern void zt_hdlc_putbuf(struct zt_chan *ss, unsigned char *rxb, int bytes)
-{
-	unsigned long flags;
-	int res;
-	int left;
-
-	spin_lock_irqsave(&ss->lock, flags);
-	if (ss->inreadbuf < 0) {
-#ifdef CONFIG_ZAPATA_DEBUG
-		printk("No place to receive HDLC frame\n");
-#endif
-		spin_unlock_irqrestore(&ss->lock, flags);
-		return;
-	}
-	/* Read into the current buffer */
-	left = ss->blocksize - ss->readidx[ss->inreadbuf];
-	if (left > bytes)
-		left = bytes;
-	if (left > 0) {
-		memcpy(ss->readbuf[ss->inreadbuf] + ss->readidx[ss->inreadbuf], rxb, left);
-		rxb += left;
-		ss->readidx[ss->inreadbuf] += left;
-		bytes -= left;
-	}
-	/* Something isn't fit into buffer */
-	if (bytes) {
-#ifdef CONFIG_ZAPATA_DEBUG
-		printk("HDLC frame isn't fit into buffer space\n");
-#endif
-		__zt_hdlc_abort(ss, ZT_EVENT_OVERRUN);
-	}
-	res = left;
-	spin_unlock_irqrestore(&ss->lock, flags);
-}
-
-extern void zt_hdlc_finish(struct zt_chan *ss)
-{
-	int oldreadbuf;
-	unsigned long flags;
-
-	spin_lock_irqsave(&ss->lock, flags);
-
-	if ((oldreadbuf = ss->inreadbuf) < 0) {
-#ifdef CONFIG_ZAPATA_DEBUG
-		printk("No buffers to finish\n");
-#endif
-		spin_unlock_irqrestore(&ss->lock, flags);
-		return;
-	}
-
-	if (!ss->readidx[ss->inreadbuf]) {
-#ifdef CONFIG_ZAPATA_DEBUG
-		printk("Empty HDLC frame received\n");
-#endif
-		spin_unlock_irqrestore(&ss->lock, flags);
-		return;
-	}
-
-	ss->readn[ss->inreadbuf] = ss->readidx[ss->inreadbuf];
-	ss->inreadbuf = (ss->inreadbuf + 1) % ss->numbufs;
-	if (ss->inreadbuf == ss->outreadbuf) {
-		ss->inreadbuf = -1;
-#ifdef CONFIG_ZAPATA_DEBUG
-		printk("Notifying reader data in block %d\n", oldreadbuf);
-#endif
-		ss->rxdisable = 0;
-	}
-	if (ss->outreadbuf < 0) {
-		ss->outreadbuf = oldreadbuf;
-	}
-
-	if (!ss->rxdisable) {
-		wake_up_interruptible(&ss->readbufq);
-		wake_up_interruptible(&ss->sel);
-		if (ss->iomask & ZT_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)
-{
-	unsigned char *buf;
-	unsigned long flags;
-	int left = 0;
-	int res;
-	int oldbuf;
-
-	spin_lock_irqsave(&ss->lock, flags);
-	if (ss->outwritebuf > -1) {
-		buf = ss->writebuf[ss->outwritebuf];
-		left = ss->writen[ss->outwritebuf] - ss->writeidx[ss->outwritebuf];
-		/* Strip off the empty HDLC CRC end */
-		left -= 2;
-		if (left <= *size) {
-			*size = left;
-			res = 1;
-		} else
-			res = 0;
-
-		memcpy(bufptr, &buf[ss->writeidx[ss->outwritebuf]], *size);
-		ss->writeidx[ss->outwritebuf] += *size;
-
-		if (res) {
-			/* Rotate buffers */
-			oldbuf = ss->outwritebuf;
-			ss->writeidx[oldbuf] = 0;
-			ss->writen[oldbuf] = 0;
-			ss->outwritebuf = (ss->outwritebuf + 1) % ss->numbufs;
-			if (ss->outwritebuf == ss->inwritebuf) {
-				ss->outwritebuf = -1;
-				if (ss->iomask & (ZT_IOMUX_WRITE | ZT_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)
-					ss->txdisable = 1;
-				res = -1;
-			}
-
-			if (ss->inwritebuf < 0)
-				ss->inwritebuf = oldbuf;
-
-			if (!(ss->flags & (ZT_FLAG_NETDEV | ZT_FLAG_PPP))) {
-				wake_up_interruptible(&ss->writebufq);
-				wake_up_interruptible(&ss->sel);
-				if ((ss->iomask & ZT_IOMUX_WRITE) && (res >= 0))
-					wake_up_interruptible(&ss->eventbufq);
-			}
-		}
-	} else {
-		res = -1;
-		*size = 0;
-	}
-	spin_unlock_irqrestore(&ss->lock, flags);
-
-	return res;
-}
-
-
-static void process_timers(void)
-{
-	unsigned long flags;
-	struct zt_timer *cur;
-	spin_lock_irqsave(&zaptimerlock, flags);
-	cur = zaptimers;
-	while(cur) {
-		if (cur->ms) {
-			cur->pos -= ZT_CHUNKSIZE;
-			if (cur->pos <= 0) {
-				cur->tripped++;
-				cur->pos = cur->ms;
-				wake_up_interruptible(&cur->sel);
-			}
-		}
-		cur = cur->next;
-	}
-	spin_unlock_irqrestore(&zaptimerlock, flags);
-}
-
-static unsigned int zt_timer_poll(struct file *file, struct poll_table_struct *wait_table)
-{
-	struct zt_timer *timer = file->private_data;
-	unsigned long flags;
-	int ret = 0;
-	if (timer) {
-		poll_wait(file, &timer->sel, wait_table);
-		spin_lock_irqsave(&zaptimerlock, flags);
-		if (timer->tripped || timer->ping) 
-			ret |= POLLPRI;
-		spin_unlock_irqrestore(&zaptimerlock, flags);
-	} else
-		ret = -EINVAL;
-	return ret;
-}
-
-/* device poll routine */
-static unsigned int
-zt_chan_poll(struct file *file, struct poll_table_struct *wait_table, int unit)
-{   
-	
-	struct zt_chan *chan = chans[unit];
-	int	ret;
-	unsigned long flags;
-
-	  /* do the poll wait */
-	if (chan) {
-		poll_wait(file, &chan->sel, wait_table);
-		ret = 0; /* start with nothing to return */
-		spin_lock_irqsave(&chan->lock, flags);
-		   /* if at least 1 write buffer avail */
-		if (chan->inwritebuf > -1) {
-			ret |= POLLOUT | POLLWRNORM;
-		}
-		if ((chan->outreadbuf > -1) && !chan->rxdisable) {
-			ret |= POLLIN | POLLRDNORM;
-		}
-		if (chan->eventoutidx != chan->eventinidx)
-		   {
-			/* Indicate an exception */
-			ret |= POLLPRI;
-		   }
-		spin_unlock_irqrestore(&chan->lock, flags);
-	} else
-		ret = -EINVAL;
-	return(ret);  /* return what we found */
-}
-
-static int zt_mmap(struct file *file, struct vm_area_struct *vm)
-{
-	int unit = UNIT(file);
-	if (unit == 250)
-		return zt_transcode_fops->mmap(file, vm);
-	return -ENOSYS;
-}
-
-static unsigned int zt_poll(struct file *file, struct poll_table_struct *wait_table)
-{
-	int unit = UNIT(file);
-	struct zt_chan *chan;
-
-	if (!unit)
-		return -EINVAL;
-
-	if (unit == 250)
-		return zt_transcode_fops->poll(file, wait_table);
-
-	if (unit == 253)
-		return zt_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);
-	}
-	if (unit == 255) {
-		chan = file->private_data;
-		if (!chan) {
-			printk("No pseudo channel structure to read?\n");
-			return -EINVAL;
-		}
-		return zt_chan_poll(file, wait_table, chan->channo);
-	}
-	return zt_chan_poll(file, wait_table, unit);
-}
-
-static void __zt_transmit_chunk(struct zt_chan *chan, unsigned char *buf)
-{
-	unsigned char silly[ZT_CHUNKSIZE];
-	/* Called with chan->lock locked */
-#ifdef	OPTIMIZE_CHANMUTE
-	if(likely(chan->chanmute))
-		return;
-#endif
-	if (!buf)
-		buf = silly;
-	__zt_getbuf_chunk(chan, buf);
-
-	if ((chan->flags & ZT_FLAG_AUDIO) || (chan->confmode)) {
-#ifdef CONFIG_ZAPTEL_MMX
-		zt_kernel_fpu_begin();
-#endif
-		__zt_process_getaudio_chunk(chan, buf);
-#ifdef CONFIG_ZAPTEL_MMX
-		kernel_fpu_end();
-#endif
-	}
-}
-
-static inline void __zt_real_transmit(struct zt_chan *chan)
-{
-	/* Called with chan->lock held */
-#ifdef	OPTIMIZE_CHANMUTE
-	if(likely(chan->chanmute))
-		return;
-#endif
-	if (chan->confmode) {
-		/* Pull queued data off the conference */
-		__buf_pull(&chan->confout, chan->writechunk, chan, "zt_real_transmit");
-	} else {
-		__zt_transmit_chunk(chan, chan->writechunk);
-	}
-}
-
-static void __zt_getempty(struct zt_chan *ms, unsigned char *buf)
-{
-	int bytes = ZT_CHUNKSIZE;
-	int left;
-	unsigned char *txb = buf;
-	int x;
-	short getlin;
-	/* Called with ms->lock held */
-
-	while(bytes) {
-		/* Receive silence, or tone */
-		if (ms->curtone) {
-			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);
-			}
-			ms->tonep+=left;
-			bytes -= left;
-			if (ms->tonep >= ms->curtone->tonesamples) {
-				struct zt_tone *last;
-				/* Go to the next sample of the tone */
-				ms->tonep = 0;
-				last = ms->curtone;
-				ms->curtone = ms->curtone->next;
-				if (!ms->curtone) {
-					/* No more tones...  Is this dtmf or mf?  If so, go to the next digit */
-					if (ms->dialing)
-						__do_dtmf(ms);
-				} else {
-					if (last != ms->curtone)
-						zt_init_tone_state(&ms->ts, ms->curtone);
-				}
-			}
-		} else {
-			/* Use silence */
-			memset(txb, ZT_LIN2X(0, ms), bytes);
-			bytes = 0;
-		}
-	}
-		
-}
-
-static void __zt_receive_chunk(struct zt_chan *chan, unsigned char *buf)
-{
-	/* Receive chunk of audio -- called with chan->lock held */
-	unsigned char waste[ZT_CHUNKSIZE];
-
-#ifdef	OPTIMIZE_CHANMUTE
-	if(likely(chan->chanmute))
-		return;
-#endif
-	if (!buf) {
-		memset(waste, ZT_LIN2X(0, chan), sizeof(waste));
-		buf = waste;
-	}
-	if ((chan->flags & ZT_FLAG_AUDIO) || (chan->confmode)) {
-#ifdef CONFIG_ZAPTEL_MMX                         
-		zt_kernel_fpu_begin();
-#endif
-		__zt_process_putaudio_chunk(chan, buf);
-#ifdef CONFIG_ZAPTEL_MMX
-		kernel_fpu_end();
-#endif
-	}
-	__zt_putbuf_chunk(chan, buf);
-}
-
-static inline void __zt_real_receive(struct zt_chan *chan)
-{
-	/* Called with chan->lock held */
-#ifdef	OPTIMIZE_CHANMUTE
-	if(likely(chan->chanmute))
-		return;
-#endif
-	if (chan->confmode) {
-		/* Load into queue if we have space */
-		__buf_push(&chan->confin, chan->readchunk, "zt_real_receive");
-	} else {
-		__zt_receive_chunk(chan, chan->readchunk);
-	}
-}
-
-int zt_transmit(struct zt_span *span)
-{
-	int x,y,z;
-	unsigned long flags;
-
-#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) {
-			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;
-				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]);
-			} else {
-				if (span->chans[x].nextslave) {
-					u_char data[ZT_CHUNKSIZE];
-					int pos=ZT_CHUNKSIZE;
-					/* Process master/slaves one way */
-					for (y=0;y<ZT_CHUNKSIZE;y++) {
-						/* Process slaves for this byte too */
-						z = x;
-						do {
-							if (pos==ZT_CHUNKSIZE) {
-								/* Get next chunk */
-								__zt_transmit_chunk(&span->chans[x], data);
-								pos = 0;
-							}
-							span->chans[z].writechunk[y] = data[pos++]; 
-							z = span->chans[z].nextslave;
-						} while(z);
-					}
-				} else {
-					/* Process independents elsewise */
-					__zt_real_transmit(&span->chans[x]);
-				}
-			}
-			if (span->chans[x].sig == ZT_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) {
-						span->chans[x].txsig = chans[span->chans[x].confna]->rxsig;
-						span->rbsbits(&span->chans[x], chans[span->chans[x].confna]->rxsig);
-					}
-				}
-			}
-
-		}
-		spin_unlock_irqrestore(&span->chans[x].lock, flags);
-	}
-	if (span->mainttimer) {
-		span->mainttimer -= ZT_CHUNKSIZE;
-		if (span->mainttimer <= 0) {
-			span->mainttimer = 0;
-			if (span->maint)
-				span->maint(span, ZT_MAINT_LOOPSTOP);
-			span->maintstat = 0;
-			wake_up_interruptible(&span->maintq);
-		}
-	}
-#endif
-	return 0;
-}
-
-int zt_receive(struct zt_span *span)
-{
-	int x,y,z;
-	unsigned long flags, flagso;
-
-#if 1
-#ifdef CONFIG_ZAPTEL_WATCHDOG
-	span->watchcounter--;
-#endif	
-	for (x=0;x<span->channels;x++) {
-		if (span->chans[x].master == &span->chans[x]) {
-			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];
-				int pos = 0;
-				for (y=0;y<ZT_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);
-							pos = 0;
-						}
-						z=span->chans[z].nextslave;
-					} while(z);
-				}
-			} else {
-				/* Process a normal channel */
-				if (!(span->chans[x].flags & ZT_FLAG_NOSTDTXRX))
-					__zt_real_receive(&span->chans[x]);
-			}
-			if (span->chans[x].itimer) {
-				span->chans[x].itimer -= ZT_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;
-				else if (span->chans[x].ringtrailer) {
-					span->chans[x].ringtrailer-= ZT_CHUNKSIZE;
-					/* See if RING trailer is expired */
-					if (!span->chans[x].ringtrailer && !span->chans[x].ringdebtimer) 
-						__qevent(&span->chans[x],ZT_EVENT_RINGOFFHOOK);
-				}
-			}
-			if (span->chans[x].pulsetimer)
-			{
-				span->chans[x].pulsetimer--;
-				if (span->chans[x].pulsetimer <= 0)
-				{
-					if (span->chans[x].pulsecount)
-					{
-						if (span->chans[x].pulsecount > 12) {
-						
-							printk("Got pulse digit %d on %s???\n",
-						    span->chans[x].pulsecount,
-							span->chans[x].name);
-						} else if (span->chans[x].pulsecount > 11) {
-							__qevent(&span->chans[x], ZT_EVENT_PULSEDIGIT | '#');
-						} else if (span->chans[x].pulsecount > 10) {
-							__qevent(&span->chans[x], ZT_EVENT_PULSEDIGIT | '*');
-						} else if (span->chans[x].pulsecount > 9) {
-							__qevent(&span->chans[x], ZT_EVENT_PULSEDIGIT | '0');
-						} else {
-							__qevent(&span->chans[x], ZT_EVENT_PULSEDIGIT | ('0' + 
-								span->chans[x].pulsecount));
-						}
-						span->chans[x].pulsecount = 0;
-					}
-				}
-			}
-			spin_unlock_irqrestore(&span->chans[x].lock, flags);
-		}
-	}
-
-	if (span == master) {
-		/* Hold the big zap lock for the duration of major
-		   activities which touch all sorts of channels */
-		spin_lock_irqsave(&bigzaplock, flagso);			
-		/* Process any timers */
-		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);
-		for (x=1;x<maxchans;x++) {
-			if (chans[x] && chans[x]->confmode && !(chans[x]->flags & ZT_FLAG_PSEUDO)) {
-				u_char *data;
-				spin_lock_irqsave(&chans[x]->lock, flags);
-				data = __buf_peek(&chans[x]->confin);
-				__zt_receive_chunk(chans[x], data);
-				if (data)
-					__buf_pull(&chans[x]->confin, NULL,chans[x], "confreceive");
-				spin_unlock_irqrestore(&chans[x]->lock, flags);
-			}
-		}
-		/* This is the master channel, so make things switch over */
-		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)) {
-				spin_lock_irqsave(&chans[x]->lock, flags);
-				__zt_transmit_chunk(chans[x], NULL);
-				spin_unlock_irqrestore(&chans[x]->lock, flags);
-			}
-		}
-		if (maxlinks) {
-#ifdef CONFIG_ZAPTEL_MMX
-			zt_kernel_fpu_begin();
-#endif			
-			  /* process all the conf links */
-			for(x = 1; x <= maxlinks; x++) {
-				  /* if we have a destination conf */
-				if (((z = confalias[conf_links[x].dst]) > 0) &&
-				    ((y = confalias[conf_links[x].src]) > 0)) {
-					ACSS(conf_sums[z], conf_sums[y]);
-				}
-			}
-#ifdef CONFIG_ZAPTEL_MMX
-			kernel_fpu_end();
-#endif			
-		}
-		/* 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];
-				spin_lock_irqsave(&chans[x]->lock, flags);
-				__zt_getempty(chans[x], tmp);
-				__zt_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)) {
-				u_char *data;
-				spin_lock_irqsave(&chans[x]->lock, flags);
-				data = __buf_pushpeek(&chans[x]->confout);
-				__zt_transmit_chunk(chans[x], data);
-				if (data)
-					__buf_push(&chans[x]->confout, NULL, "conftransmit");
-				spin_unlock_irqrestore(&chans[x]->lock, flags);
-			}
-		}
-#ifdef	ZAPTEL_SYNC_TICK
-		for (x=0;x<maxspans;x++) {
-			struct zt_span	*s = spans[x];
-
-			if (s && s->sync_tick)
-				s->sync_tick(s, s == master);
-		}
-#endif
-		spin_unlock_irqrestore(&bigzaplock, flagso);			
-	}
-#endif
-	return 0;
-}
-
-MODULE_AUTHOR("Mark Spencer <markster@digium.com>");
-MODULE_DESCRIPTION("Zapata Telephony Interface");
-#ifdef MODULE_LICENSE
-MODULE_LICENSE("GPL");
-#endif
-#ifdef MODULE_VERSION
-MODULE_VERSION(ZAPTEL_VERSION);
-#endif
-
-#ifdef LINUX26
-module_param(debug, int, 0600);
-module_param(deftaps, int, 0600);
-#else
-MODULE_PARM(debug, "i");
-MODULE_PARM(deftaps, "i");
-#endif
-
-static struct file_operations zt_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,
-	flush: NULL,
-	fsync: NULL,
-	fasync: NULL,
-};
-
-#ifdef CONFIG_ZAPTEL_WATCHDOG
-static struct timer_list watchdogtimer;
-
-static void watchdog_check(unsigned long ignored)
-{
-	int x;
-	unsigned long flags;
-	static int wdcheck=0;
-	
-	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) {
-				/* 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]->watchdog) {
-						printk("Kicking span %s\n", spans[x]->name);
-						spans[x]->watchdog(spans[x], ZT_WATCHDOG_NOINTS);
-					} else {
-						printk("Span %s is dead with no revival\n", spans[x]->name);
-						spans[x]->watchstate = ZT_WATCHSTATE_FAILED;
-					}
-				}
-			} else {
-				if ((spans[x]->watchstate != ZT_WATCHSTATE_OK) &&
-					(spans[x]->watchstate != ZT_WATCHSTATE_UNKNOWN))
-						printk("Span %s is alive!\n", spans[x]->name);
-				spans[x]->watchstate = ZT_WATCHSTATE_OK;
-			}
-			spans[x]->watchcounter = ZT_WATCHDOG_INIT;
-		}
-	}
-	local_irq_restore(flags);
-	if (!wdcheck) {
-		printk("Zaptel watchdog on duty!\n");
-		wdcheck=1;
-	}
-	mod_timer(&watchdogtimer, jiffies + 2);
-}
-
-static int __init watchdog_init(void)
-{
-	init_timer(&watchdogtimer);
-	watchdogtimer.expires = 0;
-	watchdogtimer.data =0;
-	watchdogtimer.function = watchdog_check;
-	/* Run every couple of jiffy or so */
-	mod_timer(&watchdogtimer, jiffies + 2);
-	return 0;
-}
-
-static void __exit watchdog_cleanup(void)
-{
-	del_timer(&watchdogtimer);
-}
-
-#endif
-
-int zt_register_chardev(struct zt_chardev *dev)
-{
-#ifdef CONFIG_ZAP_UDEV
-	char udevname[strlen(dev->name) + 3];
-
-	strcpy(udevname, "zap");
-	strcat(udevname, dev->name);
-	CLASS_DEV_CREATE(zap_class, MKDEV(ZT_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, ZT_DEVFS_MODE, &zt_fops, NULL);
-#endif /* CONFIG_DEVFS_FS */
-
-	return 0;
-}
-
-int zt_unregister_chardev(struct zt_chardev *dev)
-{
-#ifdef CONFIG_ZAP_UDEV
-	class_device_destroy(zap_class, MKDEV(ZT_MAJOR, dev->minor));
-#endif /* CONFIG_ZAP_UDEV */
-
-#ifdef CONFIG_DEVFS_FS
-	devfs_unregister(dev->devfs_handle);
-#endif /* CONFIG_DEVFS_FS */
-
-	return 0;
-}
-
-static int __init zt_init(void) {
-	int res = 0;
-
-#ifdef CONFIG_PROC_FS
-	proc_entries[0] = proc_mkdir("zaptel", NULL);
-#endif
-
-#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");
-#endif /* CONFIG_ZAP_UDEV */
-
-#ifdef CONFIG_DEVFS_FS
-	{
-		devfs_register_chrdev(ZT_MAJOR, "zaptel", &zt_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, ZT_DEVFS_MODE, &zt_fops, NULL);
-		channel = devfs_register(zaptel_devfs_dir, "channel", DEVFS_FL_DEFAULT, ZT_MAJOR, 254, ZT_DEVFS_MODE, &zt_fops, NULL);
-		pseudo = devfs_register(zaptel_devfs_dir, "pseudo", DEVFS_FL_DEFAULT, ZT_MAJOR, 255, ZT_DEVFS_MODE, &zt_fops, NULL);
-		ctl = devfs_register(zaptel_devfs_dir, "ctl", DEVFS_FL_DEFAULT, ZT_MAJOR, 0, ZT_DEVFS_MODE, &zt_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);
-		return res;
-	}
-#endif /* CONFIG_DEVFS_FS */
-
-	printk(KERN_INFO "Zapata Telephony Interface Registered on major %d\n", ZT_MAJOR);
-	printk(KERN_INFO "Zaptel Version: %s\n", ZAPTEL_VERSION);
-	echo_can_init();
-	zt_conv_init();
-	fasthdlc_precalc();
-	rotate_sums();
-	rwlock_init(&chan_lock);
-#ifdef CONFIG_ZAPTEL_WATCHDOG
-	watchdog_init();
-#endif	
-	return res;
-}
-
-static void __exit zt_cleanup(void) {
-	int x;
-
-#ifdef CONFIG_PROC_FS
-	remove_proc_entry("zaptel", NULL);
-#endif
-
-	printk(KERN_INFO "Zapata Telephony Interface Unloaded\n");
-	for (x = 0; x < ZT_TONE_ZONE_MAX; x++) {
-		if (tone_zones[x])
-			kfree(tone_zones[x]);
-	}
-
-#ifdef CONFIG_DEVFS_FS
-	devfs_unregister(timer);
-	devfs_unregister(channel);
-	devfs_unregister(pseudo);
-	devfs_unregister(ctl);
-	devfs_unregister(zaptel_devfs_dir);
-	devfs_unregister_chrdev(ZT_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_destroy(zap_class);
-#endif /* CONFIG_ZAP_UDEV */
-	unregister_chrdev(ZT_MAJOR, "zaptel");
-#endif
-#ifdef CONFIG_ZAPTEL_WATCHDOG
-	watchdog_cleanup();
-#endif
-
-	echo_can_shutdown();
-}
-
-module_init(zt_init);
-module_exit(zt_cleanup);