obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_ZAPHFC)		+= zaphfc/

#ifdef CONFIG_DAHDI_BRI_DCHANS

			} else if (test_bit(DAHDI_FLAGBIT_BRIDCHAN, &ms->flags)) {

			    /*

			     * Let's get this right, we want to transmit complete frames only.

			     * The card driver will do the dirty HDLC work for us.

			     * txb (transmit buffer) is supposed to be big enough to store one frame

			     * we will make this as big as the D fifo (1KB or 2KB)

			     */

			    /* there are 'left' bytes in the user buffer left to transmit */

			    left = ms->writen[ms->outwritebuf] - ms->writeidx[ms->outwritebuf] - 2;

			    if (left > ms->maxbytes2transmit) {

				memcpy(txb, buf + ms->writeidx[ms->outwritebuf], ms->maxbytes2transmit);

				ms->writeidx[ms->outwritebuf] += ms->maxbytes2transmit;

				txb += ms->maxbytes2transmit;

				ms->bytes2transmit = ms->maxbytes2transmit;

				ms->eoftx = 0;

			    } else {

				memcpy(txb, buf + ms->writeidx[ms->outwritebuf], left);

				ms->writeidx[ms->outwritebuf] += left + 2;

				txb += left + 2;

				ms->bytes2transmit = left;

				ms->eoftx = 1;

			    }

			    bytes = 0;

#endif

#if defined(CONFIG_DAHDI_BRI_DCHANS)

				ms->bytes2transmit=DAHDI_CHUNKSIZE;

#endif

#if defined(CONFIG_DAHDI_BRI_DCHANS)

				if (test_bit(DAHDI_FLAGBIT_BRIDCHAN, &ms->flags)) {

			//	    if (ms->bytes2transmit > 0) {

					// txb += 2;

					// ms->bytes2transmit -= 2;

					bytes=0;

					ms->eoftx = 1;

//					printk(KERN_CRIT "zaptel EOF(%d) bytes2transmit %d\n",ms->eoftx,ms->bytes2transmit);

			//	    }

				}

#endif

#if defined(CONFIG_DAHDI_BRI_DCHANS)

		} else if (test_bit(DAHDI_FLAGBIT_BRIDCHAN, &ms->flags)) {

		    ms->bytes2transmit = 0;

		    ms->eoftx = 0;

		    bytes = 0;

#endif

#if defined(CONFIG_DAHDI_BRI_DCHANS)

	if (test_bit(DAHDI_FLAGBIT_BRIDCHAN, &ms->flags)) {

	    bytes = ms->bytes2receive;

	    if (bytes < 1) return;

//	    printk(KERN_CRIT "bytes2receive %d\n",ms->bytes2receive);

	}

#endif

#ifdef CONFIG_DAHDI_BRI_DCHANS

			} else if (test_bit(DAHDI_FLAGBIT_BRIDCHAN, &ms->flags)) {

			    memcpy(buf + ms->readidx[ms->inreadbuf], rxb, left);

			    rxb += left;

			    ms->readidx[ms->inreadbuf] += left;

			    bytes -= left;

			    if (ms->eofrx == 1) {

				eof=1;

			    }

//			    printk(KERN_CRIT "receiving %d bytes\n",ms->bytes2receive);

			    ms->bytes2receive = 0;

			    ms->eofrx = 0;

#endif

/*

 * DAHDI 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 DAHDI 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 - 2008 Digium, Inc.

 *

 * All rights reserved.

 *

 */

/*

 * See http://www.asterisk.org for more information about

 * the Asterisk project. Please do not directly contact

 * any of the maintainers of this project for assistance;

 * the project provides a web site, mailing lists and IRC

 * channels for your use.

 *

 * This program is free software, distributed under the terms of

 * the GNU General Public License Version 2 as published by the

 * Free Software Foundation. See the LICENSE file included with

 * this program for more details.

 */

#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>

#include <linux/moduleparam.h>

#include <linux/list.h>

#include <linux/ppp_defs.h>

#include <asm/atomic.h>

#define module_printk(level, fmt, args...) printk(level "%s: " fmt, THIS_MODULE->name, ## args)

/* #define BUF_MUNGE */

#include <dahdi/version.h>

/* Grab fasthdlc with tables */

#define FAST_HDLC_NEED_TABLES

#include <dahdi/kernel.h>

#include "ecdis.h"

#ifndef CONFIG_OLD_HDLC_API

#define NEW_HDLC_INTERFACE

#endif

#ifdef CONFIG_DAHDI_PPP

#include <linux/netdevice.h>

#include <linux/if.h>

#include <linux/if_ppp.h>

#endif

#ifdef CONFIG_DAHDI_NET

#include <linux/netdevice.h>

#endif

#include "hpec/hpec_user.h"

/* Get helper arithmetic */

#include "arith.h"

#if defined(CONFIG_DAHDI_MMX) || defined(ECHO_CAN_FP)

#include <asm/i387.h>

#endif

#define hdlc_to_ztchan(h) (((struct dahdi_hdlc *)(h))->chan)

#define dev_to_ztchan(h) (((struct dahdi_hdlc *)(dev_to_hdlc(h)->priv))->chan)

#define ztchan_to_dev(h) ((h)->hdlcnetdev->netdev)

/* 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 *dahdi_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(dahdi_transcode_fops);

EXPORT_SYMBOL(dahdi_init_tone_state);

EXPORT_SYMBOL(dahdi_mf_tone);

EXPORT_SYMBOL(dahdi_register);

EXPORT_SYMBOL(dahdi_unregister);

EXPORT_SYMBOL(__dahdi_mulaw);

EXPORT_SYMBOL(__dahdi_alaw);

#ifdef CONFIG_CALC_XLAW

EXPORT_SYMBOL(__dahdi_lineartoulaw);

EXPORT_SYMBOL(__dahdi_lineartoalaw);

#else

EXPORT_SYMBOL(__dahdi_lin2mu);

EXPORT_SYMBOL(__dahdi_lin2a);

#endif

EXPORT_SYMBOL(dahdi_lboname);

EXPORT_SYMBOL(dahdi_transmit);

EXPORT_SYMBOL(dahdi_receive);

EXPORT_SYMBOL(dahdi_rbsbits);

EXPORT_SYMBOL(dahdi_qevent_nolock);

EXPORT_SYMBOL(dahdi_qevent_lock);

EXPORT_SYMBOL(dahdi_hooksig);

EXPORT_SYMBOL(dahdi_alarm_notify);

EXPORT_SYMBOL(dahdi_set_dynamic_ioctl);

EXPORT_SYMBOL(dahdi_ec_chunk);

EXPORT_SYMBOL(dahdi_ec_span);

EXPORT_SYMBOL(dahdi_hdlc_abort);

EXPORT_SYMBOL(dahdi_hdlc_finish);

EXPORT_SYMBOL(dahdi_hdlc_getbuf);

EXPORT_SYMBOL(dahdi_hdlc_putbuf);

EXPORT_SYMBOL(dahdi_alarm_channel);

EXPORT_SYMBOL(dahdi_register_chardev);

EXPORT_SYMBOL(dahdi_unregister_chardev);

EXPORT_SYMBOL(dahdi_register_echocan_factory);

EXPORT_SYMBOL(dahdi_unregister_echocan_factory);

EXPORT_SYMBOL(dahdi_set_hpec_ioctl);

#ifdef CONFIG_PROC_FS

static struct proc_dir_entry *proc_entries[DAHDI_MAX_SPANS];

#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)

#define CLASS_DEV_CREATE(class, devt, device, name) \

	device_create(class, device, devt, NULL, "%s", name)

#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)

#define CLASS_DEV_CREATE(class, devt, device, name) \

	device_create(class, device, devt, name)

#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)

#define CLASS_DEV_CREATE(class, devt, device, name) \

        class_device_create(class, NULL, devt, device, name)

#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)

#define CLASS_DEV_CREATE(class, devt, device, name) \

        class_device_create(class, devt, device, name)

#else

#define CLASS_DEV_CREATE(class, devt, device, name) \

        class_simple_device_add(class, devt, device, name)

#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)

#define CLASS_DEV_DESTROY(class, devt) \

	device_destroy(class, devt)

#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)

#define CLASS_DEV_DESTROY(class, devt) \

	class_device_destroy(class, devt)

#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)

#define CLASS_DEV_DESTROY(class, devt) \

	class_simple_device_remove(devt)

#else

#define CLASS_DEV_DESTROY(class, devt) \

	class_simple_device_remove(class, devt)

#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)

static struct class *dahdi_class = NULL;

#else

static struct class_simple *dahdi_class = NULL;

#define class_create class_simple_create

#define class_destroy class_simple_destroy

#endif

/*

 * See issue http://bugs.digium.com/view.php?id=13504 for more information. 

 * on why reference counting on the echo canceller modules is disabled

 * currently.

 */

#undef USE_ECHOCAN_REFCOUNT 

static int deftaps = 64;

static int debug;

/*!

 * \brief states for transmit signalling

 */

enum dahdi_txstate {

	DAHDI_TXSTATE_ONHOOK,

	DAHDI_TXSTATE_OFFHOOK,

	DAHDI_TXSTATE_START,

	DAHDI_TXSTATE_PREWINK,

	DAHDI_TXSTATE_WINK,

	DAHDI_TXSTATE_PREFLASH,

	DAHDI_TXSTATE_FLASH,

	DAHDI_TXSTATE_DEBOUNCE,

	DAHDI_TXSTATE_AFTERSTART,

	DAHDI_TXSTATE_RINGON,

	DAHDI_TXSTATE_RINGOFF,

	DAHDI_TXSTATE_KEWL,

	DAHDI_TXSTATE_AFTERKEWL,

	DAHDI_TXSTATE_PULSEBREAK,

	DAHDI_TXSTATE_PULSEMAKE,

	DAHDI_TXSTATE_PULSEAFTER,

};

typedef short sumtype[DAHDI_MAX_CHUNKSIZE];

static sumtype sums[(DAHDI_MAX_CONF + 1) * 3];

/* Translate conference aliases into actual conferences

   and vice-versa */

static short confalias[DAHDI_MAX_CONF + 1];

static short confrev[DAHDI_MAX_CONF + 1];

static sumtype *conf_sums_next;

static sumtype *conf_sums;

static sumtype *conf_sums_prev;

static struct dahdi_span *master;

static struct file_operations dahdi_fops;

struct file_operations *dahdi_transcode_fops = NULL;

static struct {

	int	src;	/* source conf number */

	int	dst;	/* dst conf number */

} conf_links[DAHDI_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).

*/

enum dahdi_digit_mode {

	DIGIT_MODE_DTMF,

	DIGIT_MODE_MFR1,

	DIGIT_MODE_PULSE,

	DIGIT_MODE_MFR2_FWD,

	DIGIT_MODE_MFR2_REV,

};

#include "digits.h"

static struct dahdi_dialparams global_dialparams = {

	.dtmf_tonelen = DEFAULT_DTMF_LENGTH,

	.mfv1_tonelen = DEFAULT_MFR1_LENGTH,

	.mfr2_tonelen = DEFAULT_MFR2_LENGTH,

};

static int dahdi_chan_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data, int unit);

#if defined(CONFIG_DAHDI_MMX) || defined(ECHO_CAN_FP)

#define dahdi_kernel_fpu_begin kernel_fpu_begin

#endif

struct dahdi_timer {

	int ms;			/* Countdown */

	int pos;		/* Position */

	int ping;		/* Whether we've been ping'd */

	int tripped;	/* Whether we're tripped */

	struct list_head list;

	wait_queue_head_t sel;

};

static LIST_HEAD(zaptimers);

#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 dahdi_zone {

	atomic_t refcount;

	char name[40];	/* Informational, only */

	int ringcadence[DAHDI_MAX_CADENCE];

	struct dahdi_tone *tones[DAHDI_TONE_MAX];

	/* Each of these is a circular list

	   of dahdi_tones to generate what we

	   want.  Use NULL if the tone is

	   unavailable */

	struct dahdi_tone dtmf[16];		/* DTMF tones for this zone, with desired length */

	struct dahdi_tone dtmf_continuous[16];	/* DTMF tones for this zone, continuous play */

	struct dahdi_tone mfr1[15];		/* MFR1 tones for this zone, with desired length */

	struct dahdi_tone mfr2_fwd[15];		/* MFR2 FWD tones for this zone, with desired length */

	struct dahdi_tone mfr2_rev[15];		/* MFR2 REV tones for this zone, with desired length */

	struct dahdi_tone mfr2_fwd_continuous[16];	/* MFR2 FWD tones for this zone, continuous play */

	struct dahdi_tone mfr2_rev_continuous[16];	/* MFR2 REV tones for this zone, continuous play */

};

static struct dahdi_span *spans[DAHDI_MAX_SPANS];

static struct dahdi_chan *chans[DAHDI_MAX_CHANNELS];

static int maxspans = 0;

static int maxchans = 0;

static int maxconfs = 0;

static int maxlinks = 0;

static int default_zone = -1;

short __dahdi_mulaw[256];

short __dahdi_alaw[256];

#ifndef CONFIG_CALC_XLAW

u_char __dahdi_lin2mu[16384];

u_char __dahdi_lin2a[16384];

#endif

static u_char defgain[256];

#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10)

#define __RW_LOCK_UNLOCKED() RW_LOCK_UNLOCKED

#endif

#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 dahdi_zone *tone_zones[DAHDI_TONE_ZONE_MAX];

#define NUM_SIGS	10

#ifdef DEFINE_RWLOCK

static DEFINE_RWLOCK(ecfactory_list_lock);

#else

static rwlock_t ecfactory_list_lock = __RW_LOCK_UNLOCKED();

#endif

static LIST_HEAD(ecfactory_list);

struct ecfactory {

	const struct dahdi_echocan_factory *ec;

	struct module *owner;

	struct list_head list;

};

int dahdi_register_echocan_factory(const struct dahdi_echocan_factory *ec)

{

	struct ecfactory *cur;

	write_lock(&ecfactory_list_lock);

	/* make sure it isn't already registered */

	list_for_each_entry(cur, &ecfactory_list, list) {

		if (cur->ec == ec) {

			write_unlock(&ecfactory_list_lock);

			return -EPERM;

		}

	}

	if (!(cur = kzalloc(sizeof(*cur), GFP_KERNEL))) {

		write_unlock(&ecfactory_list_lock);

		return -ENOMEM;

	}

	cur->ec = ec;

	INIT_LIST_HEAD(&cur->list);

	list_add_tail(&cur->list, &ecfactory_list);

	write_unlock(&ecfactory_list_lock);

	return 0;

}

void dahdi_unregister_echocan_factory(const struct dahdi_echocan_factory *ec)

{

	struct ecfactory *cur, *next;

	write_lock(&ecfactory_list_lock);

	list_for_each_entry_safe(cur, next, &ecfactory_list, list) {

		if (cur->ec == ec) {

			list_del(&cur->list);

			break;

		}

	}

	write_unlock(&ecfactory_list_lock);

}

static inline void rotate_sums(void)

{

	/* Rotate where we sum and so forth */

	static int pos = 0;

	conf_sums_prev = sums + (DAHDI_MAX_CONF + 1) * pos;

	conf_sums = sums + (DAHDI_MAX_CONF + 1) * ((pos + 1) % 3);

	conf_sums_next = sums + (DAHDI_MAX_CONF + 1) * ((pos + 2) % 3);

	pos = (pos + 1) % 3;

	memset(conf_sums_next, 0, maxconfs * sizeof(sumtype));

}

/*!

 * \return quiescent (idle) signalling states, for the various signalling types

 */

static int dahdi_q_sig(struct dahdi_chan *chan)

{

	int	x;

	static const unsigned int in_sig[NUM_SIGS][2] = {

		{ DAHDI_SIG_NONE,  0 },

		{ DAHDI_SIG_EM,    (DAHDI_ABIT << 8) },

		{ DAHDI_SIG_FXSLS, DAHDI_BBIT | (DAHDI_BBIT << 8) },

		{ DAHDI_SIG_FXSGS, DAHDI_ABIT | DAHDI_BBIT | ((DAHDI_ABIT | DAHDI_BBIT) << 8) },

		{ DAHDI_SIG_FXSKS, DAHDI_BBIT | DAHDI_BBIT | ((DAHDI_ABIT | DAHDI_BBIT) << 8) },

		{ DAHDI_SIG_FXOLS, (DAHDI_ABIT << 8) },

		{ DAHDI_SIG_FXOGS, DAHDI_BBIT | ((DAHDI_ABIT | DAHDI_BBIT) << 8) },

		{ DAHDI_SIG_FXOKS, (DAHDI_ABIT << 8) },

		{ DAHDI_SIG_SF,    0 },

		{ DAHDI_SIG_EM_E1, DAHDI_DBIT | ((DAHDI_ABIT | DAHDI_DBIT) << 8) },

	};

	/* must have span to begin with */

	if (!chan->span)

		return -1;

	/* if RBS does not apply, return error */

	if (!(chan->span->flags & DAHDI_FLAG_RBS) || !chan->span->rbsbits)

		return -1;

	if (chan->sig == DAHDI_SIG_CAS)

		return chan->idlebits;

	for (x = 0; x < NUM_SIGS; x++) {

		if (in_sig[x][0] == chan->sig)

			return in_sig[x][1];

	}

	return -1; /* not found -- error */

}

#ifdef CONFIG_PROC_FS

static const char *sigstr(int sig)

{

	switch (sig) {

	case DAHDI_SIG_FXSLS:

		return "FXSLS";

	case DAHDI_SIG_FXSKS:

		return "FXSKS";

	case DAHDI_SIG_FXSGS:

		return "FXSGS";

	case DAHDI_SIG_FXOLS:

		return "FXOLS";

	case DAHDI_SIG_FXOKS:

		return "FXOKS";

	case DAHDI_SIG_FXOGS:

		return "FXOGS";

	case DAHDI_SIG_EM:

		return "E&M";

	case DAHDI_SIG_EM_E1:

		return "E&M-E1";

	case DAHDI_SIG_CLEAR:

		return "Clear";

	case DAHDI_SIG_HDLCRAW:

		return "HDLCRAW";

	case DAHDI_SIG_HDLCFCS:

		return "HDLCFCS";

	case DAHDI_SIG_HDLCNET:

		return "HDLCNET";

	case DAHDI_SIG_HARDHDLC:

		return "Hardware-assisted HDLC";

	case DAHDI_SIG_MTP2:

		return "MTP2";

	case DAHDI_SIG_SLAVE:

		return "Slave";

	case DAHDI_SIG_CAS:

		return "CAS";

	case DAHDI_SIG_DACS:

		return "DACS";

	case DAHDI_SIG_DACS_RBS:

		return "DACS+RBS";

	case DAHDI_SIG_SF:

		return "SF (ToneOnly)";

	case DAHDI_SIG_NONE:

	default:

		return "Unconfigured";

	}

}

static int fill_alarm_string(char *buf, int count, int alarms)

{

	int len;

	if (alarms <= 0)

		return 0;

	len = snprintf(buf, count, "%s%s%s%s%s%s",

			(alarms & DAHDI_ALARM_BLUE) ? "BLUE " : "",

			(alarms & DAHDI_ALARM_YELLOW) ? "YELLOW " : "",

			(alarms & DAHDI_ALARM_RED) ? "RED " : "",

			(alarms & DAHDI_ALARM_LOOPBACK) ? "LOOP " : "",

			(alarms & DAHDI_ALARM_RECOVER) ? "RECOVERING " : "",

			(alarms & DAHDI_ALARM_NOTOPEN) ? "NOTOPEN " : "");

	if (len > 0)

		buf[--len] = '\0';	/* strip last space */

	return len;

}

static int dahdi_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data)

{

	int x, len = 0, real_count;

	long span;

	/* In Linux 2.6, page is always PROC_BLOCK_SIZE=(PAGE_SIZE-1024) bytes.

	 * 0<count<=PROC_BLOCK_SIZE . count=1 will produce an error in

	 * vsnprintf ('head -c 1 /proc/dahdi/1', 'dd bs=1').

	 * An ugly hack. Good way: seq_printf (seq_file.c). */

        real_count = count;

	count = PAGE_SIZE-1024;

	span = (long)data;

	if (!span)

		return 0;

	if (spans[span]->name)

		len += snprintf(page + len, count - len, "Span %ld: %s ",

				span, spans[span]->name);

	if (spans[span]->desc)

		len += snprintf(page + len, count - len, "\"%s\"",

				spans[span]->desc);

	else

		len += snprintf(page + len, count - len, "\"\"");

	if (spans[span] == master)

		len += snprintf(page + len, count - len, " (MASTER)");

	if (spans[span]->lineconfig) {

		/* framing first */

		if (spans[span]->lineconfig & DAHDI_CONFIG_B8ZS)

			len += snprintf(page + len, count - len, " B8ZS/");

		else if (spans[span]->lineconfig & DAHDI_CONFIG_AMI)

			len += snprintf(page + len, count - len, " AMI/");

		else if (spans[span]->lineconfig & DAHDI_CONFIG_HDB3)

			len += snprintf(page + len, count - len, " HDB3/");

		/* then coding */

		if (spans[span]->lineconfig & DAHDI_CONFIG_ESF)

			len += snprintf(page + len, count - len, "ESF");

		else if (spans[span]->lineconfig & DAHDI_CONFIG_D4)

			len += snprintf(page + len, count - len, "D4");

		else if (spans[span]->lineconfig & DAHDI_CONFIG_CCS)

			len += snprintf(page + len, count - len, "CCS");

		/* E1's can enable CRC checking */

		if (spans[span]->lineconfig & DAHDI_CONFIG_CRC4)

			len += snprintf(page + len, count - len, "/CRC4");

	}

	len += snprintf(page + len, count - len, " ");

	/* list alarms */

	len += fill_alarm_string(page + len, count - len, spans[span]->alarms);

	if (spans[span]->syncsrc &&

		(spans[span]->syncsrc == spans[span]->spanno))

		len += snprintf(page + len, count - len, "ClockSource ");

	len += snprintf(page + len, count - len, "\n");

	if (spans[span]->bpvcount)

		len += snprintf(page + len, count - len, "\tBPV count: %d\n",

				spans[span]->bpvcount);

	if (spans[span]->crc4count)

		len += snprintf(page + len, count - len,

				"\tCRC4 error count: %d\n",

				spans[span]->crc4count);

	if (spans[span]->ebitcount)

		len += snprintf(page + len, count - len,

				"\tE-bit error count: %d\n",

				spans[span]->ebitcount);

	if (spans[span]->fascount)

		len += snprintf(page + len, count - len,

				"\tFAS error count: %d\n",

				spans[span]->fascount);

	if (spans[span]->irqmisses)

		len += snprintf(page + len, count - len,

				"\tIRQ misses: %d\n",

				spans[span]->irqmisses);

	if (spans[span]->timingslips)

		len += snprintf(page + len, count - len,

				"\tTiming slips: %d\n",

				spans[span]->timingslips);

	len += snprintf(page + len, count - len, "\n");

	for (x = 0; x < spans[span]->channels; x++) {

		struct dahdi_chan *chan = spans[span]->chans[x];

		if (chan->name)

			len += snprintf(page + len, count - len,

					"\t%4d %s ", chan->channo, chan->name);

		if (chan->sig) {

			if (chan->sig == DAHDI_SIG_SLAVE)

				len += snprintf(page+len, count-len, "%s ",

						sigstr(chan->master->sig));

			else {

				len += snprintf(page+len, count-len, "%s ",

						sigstr(chan->sig));

				if (chan->nextslave &&

					(chan->master->channo == chan->channo))

					len += snprintf(page+len, count-len,

							"Master ");

			}

		}

		if (test_bit(DAHDI_FLAGBIT_OPEN, &chan->flags))

			len += snprintf(page + len, count - len, "(In use) ");

#ifdef	OPTIMIZE_CHANMUTE

		if (chan->chanmute)

			len += snprintf(page+len, count-len, "(no pcm) ");

#endif

		len += fill_alarm_string(page+len, count-len,

				chan->chan_alarms);

		if (chan->ec_factory)

			len += snprintf(page+len, count-len, "(SWEC: %s) ",

					chan->ec_factory->name);

		if (chan->ec_state)

			len += snprintf(page+len, count-len, "(EC: %s) ",

					chan->ec_state->ops->name);

		len += snprintf(page+len, count-len, "\n");

		/* If everything printed so far is before beginning 

		 * of request */

		if (len <= off) {

			off -= len;

			len = 0;

		}

		/* stop if we've already generated enough */

		if (len > off + count)

			break;

		/* stop if we're NEAR danger limit. let it be -128 bytes. */

		if (len > count-128)

			break;

	}

	count = real_count;

	/* If everything printed so far is before beginning of request */

	if (len <= off) {

		off = 0;

		len = 0;

	}

	*start = page + off;

	len -= off;		/* un-count any remaining offset */

	*eof = 1;

	if (len > count)

		len = count;	/* don't return bytes not asked for */

	return len;

}

#endif

static int dahdi_first_empty_alias(void)

{

	/* Find the first conference which has no alias pointing to it */

	int x;

	for (x=1;x<DAHDI_MAX_CONF;x++) {

		if (!confrev[x])

			return x;

	}

	return -1;

}

static void recalc_maxconfs(void)

{

	int x;

	for (x = DAHDI_MAX_CONF - 1; x > 0; x--) {

		if (confrev[x]) {

			maxconfs = x + 1;

			return;

		}

	}

	maxconfs = 0;

}

static void recalc_maxlinks(void)

{

	int x;

	for (x = DAHDI_MAX_CONF - 1; x > 0; x--) {

		if (conf_links[x].src || conf_links[x].dst) {

			maxlinks = x + 1;

			return;

		}

	}

	maxlinks = 0;

}

static int dahdi_first_empty_conference(void)

{

	/* Find the first conference which has no alias */

	int x;

	for (x = DAHDI_MAX_CONF - 1; x > 0; x--) {

		if (!confalias[x])

			return x;

	}

	return -1;

}

static int dahdi_get_conf_alias(int x)

{

	int a;

	if (confalias[x])

		return confalias[x];

	/* Allocate an alias */

	a = dahdi_first_empty_alias();

	confalias[x] = a;

	confrev[a] = x;

	/* Highest conference may have changed */

	recalc_maxconfs();

	return a;

}

static void dahdi_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 & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONF ||

				(chans[y]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONFANN ||

				(chans[y]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONFMON ||

				(chans[y]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_CONFANNMON ||

				(chans[y]->confmode & DAHDI_CONF_MODE_MASK) == DAHDI_CONF_REALANDPSEUDO)) {

			return;

		}

	}

	/* If we get here, nobody is in the conference anymore.  Clear it out

	   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 dahdi_chan *chan, int event)

{

	/* if full, ignore */

	if ((chan->eventoutidx == 0) && (chan->eventinidx == (DAHDI_MAX_EVENTSIZE - 1)))

		return;

	/* if full, ignore */

	if (chan->eventinidx == (chan->eventoutidx - 1))

		return;

	/* save the event */

	chan->eventbuf[chan->eventinidx++] = event;

	/* wrap the index, if necessary */

	if (chan->eventinidx >= DAHDI_MAX_EVENTSIZE)

		chan->eventinidx = 0;

	/* wake em all up */

	if (chan->iomask & DAHDI_IOMUX_SIGEVENT)

		wake_up_interruptible(&chan->eventbufq);

	wake_up_interruptible(&chan->readbufq);

	wake_up_interruptible(&chan->writebufq);

	wake_up_interruptible(&chan->sel);

	return;

}

void dahdi_qevent_nolock(struct dahdi_chan *chan, int event)

{

	__qevent(chan, event);

}

void dahdi_qevent_lock(struct dahdi_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 dahdi_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 dahdi_reallocbufs(struct dahdi_chan *ss, int j, int numbufs)

{

	unsigned char *newbuf, *oldbuf;

	unsigned long flags;

	int x;

	/* Check numbufs */

	if (numbufs < 2)

		numbufs = 2;

	if (numbufs > DAHDI_MAX_NUM_BUFS)

		numbufs = DAHDI_MAX_NUM_BUFS;

	/* We need to allocate our buffers now */

	if (j) {

		if (!(newbuf = kcalloc(j * 2, numbufs, GFP_KERNEL)))

			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 == DAHDI_POLICY_WHEN_FULL) || (ss->txbufpolicy == DAHDI_POLICY_HALF_FULL))

		ss->txdisable = 1;

	else

		ss->txdisable = 0;

	if (ss->rxbufpolicy == DAHDI_POLICY_WHEN_FULL)

		ss->rxdisable = 1;

	else

		ss->rxdisable = 0;

	spin_unlock_irqrestore(&ss->lock, flags);

	if (oldbuf)

		kfree(oldbuf);

	return 0;

}

static int dahdi_hangup(struct dahdi_chan *chan);

static void dahdi_set_law(struct dahdi_chan *chan, int law);

/* Pull a DAHDI_CHUNKSIZE piece off the queue.  Returns

   0 on success or -1 on failure.  If failed, provides

   silence */

static int __buf_pull(struct confq *q, u_char *data, struct dahdi_chan *c, char *label)

{

	int oldoutbuf = q->outbuf;

	/* Ain't nuffin to read */

	if (q->outbuf < 0) {

		if (data)

			memset(data, DAHDI_LIN2X(0,c), DAHDI_CHUNKSIZE);

		return -1;

	}

	if (data)

		memcpy(data, q->buf[q->outbuf], DAHDI_CHUNKSIZE);

	q->outbuf = (q->outbuf + 1) % DAHDI_CB_SIZE;

	/* Won't be nuffin next time */

	if (q->outbuf == q->inbuf) {

		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 += DAHDI_CB_SIZE;

	return q->buf[pos];

}

static void __buf_munge(struct dahdi_chan *chan, u_char *old, u_char *new)

{

	/* Run a weighted average of the old and new, in order to

	   mask a missing sample */

	int x;

	int val;

	for (x=0;x<DAHDI_CHUNKSIZE;x++) {

		val = x * DAHDI_XLAW(new[x], chan) + (DAHDI_CHUNKSIZE - x - 1) * DAHDI_XLAW(old[x], chan);

		val = val / (DAHDI_CHUNKSIZE - 1);

		old[x] = DAHDI_LIN2X(val, chan);

	}

}

#endif

/* 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, DAHDI_CHUNKSIZE);

	/* Advance the inbuf pointer */

	q->inbuf = (q->inbuf + 1) % DAHDI_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 dahdi_chan *chan)

{

	int x;

	/* Empty out buffers and reset to initialization */

	for (x = 0; x < DAHDI_CB_SIZE; x++)

		chan->confin.buf[x] = chan->confin.buffer + DAHDI_CHUNKSIZE * x;

	chan->confin.inbuf = 0;

	chan->confin.outbuf = -1;

	for (x = 0; x < DAHDI_CB_SIZE; x++)

		chan->confout.buf[x] = chan->confout.buffer + DAHDI_CHUNKSIZE * x;

	chan->confout.inbuf = 0;

	chan->confout.outbuf = -1;

}

static const struct dahdi_echocan_factory *find_echocan(const char *name)

{

	struct ecfactory *cur;

	char name_upper[strlen(name) + 1];

	char *c;

	const char *d;

	char modname_buf[128] = "dahdi_echocan_";

	unsigned int tried_once = 0;

	for (c = name_upper, d = name; *d; c++, d++) {

		*c = toupper(*d);

	}

	*c = '\0';

retry:

	read_lock(&ecfactory_list_lock);

	list_for_each_entry(cur, &ecfactory_list, list) {

		if (!strcmp(name_upper, cur->ec->name)) {

#ifdef USE_ECHOCAN_REFCOUNT

			if (try_module_get(cur->owner)) {

				read_unlock(&ecfactory_list_lock);

				return cur->ec;

			} else {

				read_unlock(&ecfactory_list_lock);

				return NULL;

			}

#else

			read_unlock(&ecfactory_list_lock);

			return cur->ec;

#endif

		}

	}

	read_unlock(&ecfactory_list_lock);

	if (tried_once) {

		return NULL;

	}

	/* couldn't find it, let's try to load it */

	for (c = &modname_buf[strlen(modname_buf)], d = name; *d; c++, d++) {

		*c = tolower(*d);

	}

	request_module("%s", modname_buf);

	tried_once = 1;

	/* and try one more time */

	goto retry;

}

static void release_echocan(const struct dahdi_echocan_factory *ec)

{

#ifdef USE_ECHOCAN_REFCOUNT

	if (ec)

		module_put(ec->owner);

#endif

}

/** 

 * close_channel - close the channel, resetting any channel variables

 * @chan: the dahdi_chan to close

 *

 * This function might be called before the channel is placed on the global

 * array of channels, (chans), and therefore, neither this function nor it's

 * children should depend on the dahdi_chan.channo member which is not set yet.

 */

static void close_channel(struct dahdi_chan *chan)

{

	unsigned long flags;

	void *rxgain = NULL;

	struct dahdi_echocan_state *ec_state;

	const struct dahdi_echocan_factory *ec_current;

	int oldconf;

	short *readchunkpreec;

#ifdef CONFIG_DAHDI_PPP

	struct ppp_channel *ppp;

#endif

	might_sleep();

	/* XXX Buffers should be send out before reallocation!!! XXX */

	if (!(chan->flags & DAHDI_FLAG_NOSTDTXRX))

		dahdi_reallocbufs(chan, 0, 0);

	spin_lock_irqsave(&chan->lock, flags);

#ifdef CONFIG_DAHDI_PPP

	ppp = chan->ppp;

	chan->ppp = NULL;

#endif

	ec_state = chan->ec_state;

	chan->ec_state = NULL;

	ec_current = chan->ec_current;

	chan->ec_current = 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;

	dahdi_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 & __DAHDI_SIG_DACS) != __DAHDI_SIG_DACS) {

		chan->confna = 0;

		chan->confmode = 0;

	}

	chan->confmute = 0;

	/* release conference resource, if any to release */

	if (oldconf) dahdi_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 &= ~(DAHDI_FLAG_LOOPED | DAHDI_FLAG_LINEAR | DAHDI_FLAG_PPP | DAHDI_FLAG_SIGFREEZE);

	dahdi_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);

	if (ec_state) {

		ec_state->ops->echocan_free(chan, ec_state);

		release_echocan(ec_current);

	}

	spin_unlock_irqrestore(&chan->lock, flags);

	if (rxgain)

		kfree(rxgain);

	if (readchunkpreec)

		kfree(readchunkpreec);

#ifdef CONFIG_DAHDI_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 dahdi_zone *z = NULL;

	int res = 0;

	if ((num >= DAHDI_TONE_ZONE_MAX) || (num < 0))

		return -EINVAL;

	write_lock(&zone_lock);

	if (tone_zones[num]) {

		if (!atomic_read(&tone_zones[num]->refcount)) {

			z = tone_zones[num];

			tone_zones[num] = NULL;

		} else {

			res = -EBUSY;

		}

	}

	write_unlock(&zone_lock);

	if (z)

		kfree(z);

	return res;

}

static int dahdi_register_tone_zone(int num, struct dahdi_zone *zone)

{

	int res = 0;

	if ((num >= DAHDI_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)

		module_printk(KERN_INFO, "Registered tone zone %d (%s)\n", num, zone->name);

	return res;

}

static int start_tone_digit(struct dahdi_chan *chan, int tone)

{

	struct dahdi_tone *playtone = NULL;

	int base, max;

	if (!chan->curzone)

		return -ENODATA;

	switch (chan->digitmode) {

	case DIGIT_MODE_DTMF:

		/* Set dialing so that a dial operation doesn't interrupt this tone */

		chan->dialing = 1;

		base = DAHDI_TONE_DTMF_BASE;

		max = DAHDI_TONE_DTMF_MAX;

		break;

	case DIGIT_MODE_MFR2_FWD:

		base = DAHDI_TONE_MFR2_FWD_BASE;

		max = DAHDI_TONE_MFR2_FWD_MAX;

		break;

	case DIGIT_MODE_MFR2_REV:

		base = DAHDI_TONE_MFR2_REV_BASE;

		max = DAHDI_TONE_MFR2_REV_MAX;

		break;

	default:

		return -EINVAL;

	}

	if ((tone < base) || (tone > max))

		return -EINVAL;

	switch (chan->digitmode) {

	case DIGIT_MODE_DTMF:

		playtone = &chan->curzone->dtmf_continuous[tone - base];

		break;

	case DIGIT_MODE_MFR2_FWD:

		playtone = &chan->curzone->mfr2_fwd_continuous[tone - base];

		break;

	case DIGIT_MODE_MFR2_REV:

		playtone = &chan->curzone->mfr2_rev_continuous[tone - base];

		break;

	}

	if (!playtone || !playtone->tonesamples)

		return -ENOSYS;

	chan->curtone = playtone;

	return 0;

}

static int start_tone(struct dahdi_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 (!chan->curzone) {

		static int __warnonce = 1;

		if (__warnonce) {

			__warnonce = 0;

			/* The tonezones are loaded by dahdi_cfg based on /etc/dahdi/system.conf. */

			module_printk(KERN_WARNING, "DAHDI: Cannot start tones until tone zone is loaded.\n");

		}

		/* Note that no tone zone exists at the moment */

		res = -ENODATA;

	} else if ((tone >= 0 && tone <= DAHDI_TONE_MAX)) {

		/* 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 if (chan->digitmode == DIGIT_MODE_DTMF ||

			chan->digitmode == DIGIT_MODE_MFR2_FWD ||

			chan->digitmode == DIGIT_MODE_MFR2_REV) {

		res = start_tone_digit(chan, tone);

	} else {

		chan->dialing = 0;

		res = -EINVAL;

	}

	if (chan->curtone)

		dahdi_init_tone_state(&chan->ts, chan->curtone);

	return res;

}

static int set_tone_zone(struct dahdi_chan *chan, int zone)

{

	int res = 0;

	struct dahdi_zone *z;

	/* Do not call with the channel locked. */

	if (zone == -1)

		zone = default_zone;

	if ((zone >= DAHDI_TONE_ZONE_MAX) || (zone < 0))

		return -EINVAL;

	read_lock(&zone_lock);

	if ((z = tone_zones[zone])) {

		unsigned long flags;

		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 dahdi_set_law(struct dahdi_chan *chan, int law)

{

	if (!law) {

		if (chan->deflaw)

			law = chan->deflaw;

		else

			if (chan->span) law = chan->span->deflaw;

			else law = DAHDI_LAW_MULAW;

	}

	if (law == DAHDI_LAW_ALAW) {

		chan->xlaw = __dahdi_alaw;

#ifdef CONFIG_CALC_XLAW

		chan->lineartoxlaw = __dahdi_lineartoalaw;

#else

		chan->lin2x = __dahdi_lin2a;

#endif

	} else {

		chan->xlaw = __dahdi_mulaw;

#ifdef CONFIG_CALC_XLAW

		chan->lineartoxlaw = __dahdi_lineartoulaw;

#else

		chan->lin2x = __dahdi_lin2mu;

#endif

	}

}

static int dahdi_chan_reg(struct dahdi_chan *chan)

{

	int x;

	unsigned long flags;

	might_sleep();

	spin_lock_init(&chan->lock);

	if (!chan->master)

		chan->master = chan;

	if (!chan->readchunk)

		chan->readchunk = chan->sreadchunk;

	if (!chan->writechunk)

		chan->writechunk = chan->swritechunk;

	dahdi_set_law(chan, 0);

	close_channel(chan);

	write_lock_irqsave(&chan_lock, flags);

	for (x = 1; x < DAHDI_MAX_CHANNELS; x++) {

		if (chans[x])

			continue;

		chans[x] = chan;

		if (maxchans < x + 1)

			maxchans = x + 1;

		chan->channo = x;

		write_unlock_irqrestore(&chan_lock, flags);

		/* set this AFTER running close_channel() so that

		   HDLC channels wont cause hangage */

		set_bit(DAHDI_FLAGBIT_REGISTERED, &chan->flags);

		break;

	}

	if (DAHDI_MAX_CHANNELS == x) {

		write_unlock_irqrestore(&chan_lock, flags);

		module_printk(KERN_ERR, "No more channels available\n");

		return -ENOMEM;

	}

	return 0;

}

char *dahdi_lboname(int x)

{

	if ((x < 0) || (x > 7))

		return "Unknown";

	return dahdi_txlevelnames[x];

}

#if defined(CONFIG_DAHDI_NET) || defined(CONFIG_DAHDI_PPP)

static inline void print_debug_writebuf(struct dahdi_chan* ss, struct sk_buff *skb, int oldbuf)

{

#ifdef CONFIG_DAHDI_DEBUG

	int x;

	module_printk(KERN_NOTICE, "Buffered %d bytes to go out in buffer %d\n", ss->writen[oldbuf], oldbuf);

	module_printk(KERN_DEBUG "");

	for (x=0;x<ss->writen[oldbuf];x++)

		printk("%02x ", ss->writebuf[oldbuf][x]);

	printk("\n");

#endif

}

#endif

#ifdef CONFIG_DAHDI_NET

#ifdef NEW_HDLC_INTERFACE

static int dahdi_net_open(struct net_device *dev)

{

	int res = hdlc_open(dev);

	struct dahdi_chan *ms = dev_to_ztchan(dev);

/*	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 dahdi_net_open(hdlc_device *hdlc)

{

	struct dahdi_chan *ms = hdlc_to_ztchan(hdlc);

	int res;

#endif

	if (!ms) {

		module_printk(KERN_NOTICE, "dahdi_net_open: nothing??\n");

		return -EINVAL;

	}

	if (test_bit(DAHDI_FLAGBIT_OPEN, &ms->flags)) {

		module_printk(KERN_NOTICE, "%s is already open!\n", ms->name);

		return -EBUSY;

	}

	if (!(ms->flags & DAHDI_FLAG_NETDEV)) {

		module_printk(KERN_NOTICE, "%s is not a net device!\n", ms->name);

		return -EINVAL;

	}

	ms->txbufpolicy = DAHDI_POLICY_IMMEDIATE;

	ms->rxbufpolicy = DAHDI_POLICY_IMMEDIATE;

	res = dahdi_reallocbufs(ms, DAHDI_DEFAULT_MTU_MRU, DAHDI_DEFAULT_NUM_BUFS);

	if (res)

		return res;

	fasthdlc_init(&ms->rxhdlc, (ms->flags & DAHDI_FLAG_HDLC56) ? FASTHDLC_MODE_56 : FASTHDLC_MODE_64);

	fasthdlc_init(&ms->txhdlc, (ms->flags & DAHDI_FLAG_HDLC56) ? FASTHDLC_MODE_56 : FASTHDLC_MODE_64);

	ms->infcs = PPP_INITFCS;

	netif_start_queue(ztchan_to_dev(ms));

#ifdef CONFIG_DAHDI_DEBUG

	module_printk(KERN_NOTICE, "DAHDINET: Opened channel %d name %s\n", ms->channo, ms->name);

#endif

	return 0;

}

static int dahdi_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;

}

#ifdef NEW_HDLC_INTERFACE

static int dahdi_net_stop(struct net_device *dev)

{

    hdlc_device *h = dev_to_hdlc(dev);

    struct dahdi_hdlc *hdlc = h->priv;

#else

static void dahdi_net_close(hdlc_device *hdlc)

{

#endif

	struct dahdi_chan *ms = hdlc_to_ztchan(hdlc);

	if (!ms) {

#ifdef NEW_HDLC_INTERFACE

		module_printk(KERN_NOTICE, "dahdi_net_stop: nothing??\n");

		return 0;

#else

		module_printk(KERN_NOTICE, "dahdi_net_close: nothing??\n");

		return;

#endif

	}

	if (!(ms->flags & DAHDI_FLAG_NETDEV)) {

#ifdef NEW_HDLC_INTERFACE

		module_printk(KERN_NOTICE, "dahdi_net_stop: %s is not a net device!\n", ms->name);

		return 0;

#else

		module_printk(KERN_NOTICE, "dahdi_net_close: %s is not a net device!\n", ms->name);

		return;

#endif

	}

	/* Not much to do here.  Just deallocate the buffers */

        netif_stop_queue(ztchan_to_dev(ms));

	dahdi_reallocbufs(ms, 0, 0);

	hdlc_close(dev);

#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 */

static int dahdi_net_attach(struct net_device *dev, unsigned short encoding,

        unsigned short parity)

{

/*        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 dahdi_hdlc *dahdi_hdlc_alloc(void)

{

	return kzalloc(sizeof(struct dahdi_hdlc), GFP_KERNEL);

}

#ifdef NEW_HDLC_INTERFACE

static int dahdi_xmit(struct sk_buff *skb, struct net_device *dev)

{

	/* FIXME: this construction seems to be not very optimal for me but I could find nothing better at the moment (Friday, 10PM :( )  --byg */

/*	struct dahdi_chan *ss = hdlc_to_ztchan(list_entry(dev, struct dahdi_hdlc, netdev.netdev));*/

	struct dahdi_chan *ss = dev_to_ztchan(dev);

	struct net_device_stats *stats = hdlc_stats(dev);

#else

static int dahdi_xmit(hdlc_device *hdlc, struct sk_buff *skb)

{

	struct dahdi_chan *ss = hdlc_to_ztchan(hdlc);

	struct net_device *dev = &ss->hdlcnetdev->netdev.netdev;

	struct net_device_stats *stats = &ss->hdlcnetdev->netdev.stats;

#endif

	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) {

		module_printk(KERN_ERR, "dahdi_xmit(%s): skb is too large (%d > %d)\n", dev->name, skb->len, ss->blocksize -2);

		stats->tx_dropped++;

		retval = 0;

	} else if (ss->inwritebuf >= 0) {

		/* 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];

		print_debug_writebuf(ss, skb, oldbuf);

		retval = 0;

		/* Free the SKB */

		dev_kfree_skb_any(skb);

	}

	spin_unlock_irqrestore(&ss->lock, flags);

	return retval;

}

#ifdef NEW_HDLC_INTERFACE

static int dahdi_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)

{

	return hdlc_ioctl(dev, ifr, cmd);

}

#else

static int dahdi_net_ioctl(hdlc_device *hdlc, struct ifreq *ifr, int cmd)

{

	return -EIO;

}

#endif

#endif

#ifdef CONFIG_DAHDI_PPP

static int dahdi_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 dahdi_chan *ss = ppp->private;

	int x,oldbuf;

	unsigned int fcs;

	unsigned char *data;

	unsigned long flags;

	int retval = 0;

	/* See if we have any buffers */

	spin_lock_irqsave(&ss->lock, flags);

	if (!(test_bit(DAHDI_FLAGBIT_OPEN, &ss->flags))) {

		module_printk(KERN_ERR, "Can't transmit on closed channel\n");

		retval = 1;

	} else if (skb->len > ss->blocksize - 4) {

		module_printk(KERN_ERR, "dahdi_ppp_xmit(%s): skb is too large (%d > %d)\n", ss->name, skb->len, ss->blocksize -2);

		retval = 1;

	} else if (ss->inwritebuf >= 0) {

		/* We have a place to put this packet */

		/* 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" */