freebsd-dev/sys/dev/ce/ceddk.c

/*
 * Middle-level code for Cronyx Tau32-PCI adapters.
 *
 * Copyright (C) 2004 Cronyx Engineering
 * Copyright (C) 2004 Roman Kurakin <rik@FreeBSD.org>
 *
 * This software is distributed with NO WARRANTIES, not even the implied
 * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Authors grant any other persons or organisations a permission to use,
 * modify and redistribute this software in source and binary forms,
 * as long as this message is kept with the software, all derivative
 * works or modified versions.
 *
 * $Cronyx: ceddk.c,v 1.2.6.2 2005/11/17 16:04:13 rik Exp $
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <dev/cx/machdep.h>
#include <dev/ce/ceddk.h>

#undef CE_DDK_DEBUG_ENABLED
#ifdef CE_DDK_DEBUG_ENABLED
#ifdef __FreeBSD__
# define CE_DDK_DEBUG(b,c,s) \
	do { \
		if (c) { \
			printf("ce%d-%d: ",(b)->num,(c)->num); \
		} else { \
			printf("ce%d-*: ",(b)->num); \
		} \
		printf s; \
	} while (0)
#else
# define CE_DDK_DEBUG(b,c,s)	do {} while (0)
#endif
#else
# define CE_DDK_DEBUG(b,c,s)	do {} while (0)
#endif

#if 0
#define ENTER() \
	static int enter=0; \
	do { \
	enter++; \
	printf ("%s: >> enter (%16llx) %d\n", __FUNCTION__, rdtsc (), enter); \
	} while (0)

#define EXIT(val...) \
	do { \
	enter--; \
	printf ("%s: << exit  (%16llx) %d line %d\n", __FUNCTION__, rdtsc (), enter, __LINE__); \
	return val; \
	} while (0)
#else
#define ENTER() \
	do {} while (0)

#define EXIT(val...) \
	do {return val;} while (0)
#endif

#define CE_ENQUEUE(list,item) \
	do { \
		TAU32_UserRequest **last; \
		last = &(list); \
		while (*last) { \
			last = &(*last)->next; \
		} \
		(*last) = (item); \
		(item)->next = NULL; \
	} while (0)
	
#define CE_ENQUEUE_HEAD(list,item) \
	do { \
		(item)->next = list; \
		list = item; \
	} while (0)
	
#define CE_DEQUEUE(list,item) \
	do { \
		item = list; \
		if (list) { \
			list = (item)->next; \
		} \
	} while (0)
	
#define CE_PREREQUEST(b,c,list,item) \
	do { \
		item = list; \
		if (!item) { \
			CE_DDK_DEBUG (b, c, ("Fatal error, no free structs " \
					     "for UserRequest (%s:%d)\n", \
					     __FUNCTION__, __LINE__)); \
		} \
	} while (0)

#define CE_DUMP_QUEUE(list) \
	do { \
		TAU32_UserRequest *item; \
		int i = 0; \
		item = list; \
		while (item) { \
			printf ("item%d: %p\n", i, item); \
			item = item->next; \
			i++; \
		} \
	} while (0)

#define CE_FIND_ITEM(list,item,flag) \
	do { \
		TAU32_UserRequest *citem; \
		flag = 0; \
		for (citem = list; citem; citem = citem->next) { \
			if (citem == item) { \
				flag = 1; \
				break; \
			} \
		} \
	} while (0)
	
#define CE_LAST_ITEM(list,item) \
	do { \
		TAU32_UserRequest **last; \
		last = &(list); \
		while ((*last) && (*last)->next) { \
			last = &(*last)->next; \
		} \
		(item) = (*last); \
	} while (0)

#define CE_ASSERT(a) \
	do { \
		if (!(a)) { \
			printf ("ASSERT: %d %s\n", __LINE__, #a); \
			__asm __volatile ("int $3"); \
		} \
	} while (0)

static void _ce_set_ts (ce_chan_t *c, unsigned long ts);
static void _ce_submit_configure_e1 (ce_chan_t *c, char *rname);

#ifdef CE_DDK_DEBUG_ENABLED
static char *ce_err2str (unsigned long err)
{
	switch (err) {
	case TAU32_SUCCESSFUL:
		return "Successful";
	case TAU32_ERROR_ALLOCATION:
		return "Allocation error, not enough tx/rx descriptors";
	case TAU32_ERROR_BUS:
		return "PEB could not access to host memory by PCI bus for load/store information";
	case TAU32_ERROR_FAIL:
		return "PEB action request failed";
	case TAU32_ERROR_TIMEOUT:
		return "PEB action request timeout";
	case TAU32_ERROR_CANCELLED:
		return "request has been canceled";
	case TAU32_ERROR_TX_UNDERFLOW:
		return "transmission underflow";
	case TAU32_ERROR_TX_PROTOCOL:
		return "TX_PROTOCOL";
	case TAU32_ERROR_RX_OVERFLOW:
		return "RX_OVERFLOW";
	case TAU32_ERROR_RX_ABORT:
		return "RX_ABORT";
	case TAU32_ERROR_RX_CRC:
		return "RX_CRC";
	case TAU32_ERROR_RX_SHORT:
		return "RX_SHORT";
	case TAU32_ERROR_RX_SYNC:
		return "RX_SYNC";
	case TAU32_ERROR_RX_FRAME:
		return "RX_FRAME";
	case TAU32_ERROR_RX_LONG:
		return "RX_LONG";
	case TAU32_ERROR_RX_SPLIT:
		return "frame has splitted between two requests due rx-gap allocation";
	case TAU32_ERROR_RX_UNFIT:
		return "frame can't be fit into request buffer";
	case TAU32_ERROR_TSP:
		return "ERROR_TSP";
	case TAU32_ERROR_RSP:
		return "ERROR_RSP";
	case TAU32_ERROR_INT_OVER_TX:
		return "ERROR INT OVER TX";
	case TAU32_ERROR_INT_OVER_RX:
		return "ERROR INT OVER RX";
	case TAU32_ERROR_INT_STORM:
		return "irq storm";
	case TAU32_ERROR_INT_E1LOST:
		return "ERROR_E1LOST";
	default:
		return ("Unknown error");
	}
}
#endif

void ce_set_dtr (ce_chan_t *c, int on)
{
	c->dtr = on?1:0;
}

void ce_set_rts (ce_chan_t *c, int on)
{
	c->rts = on?1:0;
}

static void TAU32_CALLBACK_TYPE ce_on_receive
	(TAU32_UserContext *pContext, TAU32_UserRequest *req)
{
	ce_buf_item_t *item = (ce_buf_item_t *)req;
	ce_chan_t *c;
	ce_board_t *b;
	unsigned int error;
	int len;

	ENTER ();
	if (!req || !req->sys) {
		EXIT ();
	}

	c = (ce_chan_t *)req->sys;
	b = c->board;

	len = req->Io.Rx.Received;
	error = req->ErrorCode;
	
	c->rintr++;
	if (error == TAU32_SUCCESSFUL) {
		if (req->Io.Rx.FrameEnd) {
			c->ipkts++;
		} else {
			CE_DDK_DEBUG (b, c, ("No FrameEnd\n"));
			/* probably do something in some cases*/
		}
		c->ibytes += len;
		if (c->receive)
			c->receive (c, item->buf, len);
	} else if (error & TAU32_ERROR_BUS) {
		c->overrun++;
		if (c->error)
			c->error (c, CE_OVERRUN);
	} else {
		CE_DDK_DEBUG (b, c, ("Another receive error: %x\n", error));
		/* Do some procesing */
	}
	
	CE_ASSERT (!req->pInternal);
	CE_ENQUEUE (c->rx_queue, req);
	while (c->rx_queue) {
		CE_DEQUEUE (c->rx_queue, req);
		CE_ASSERT (req);
		item = (ce_buf_item_t *)req;
		req->Command = TAU32_Rx_Data;
		req->Io.Rx.Channel = c->num;
		req->pCallback = ce_on_receive;
		req->Io.Rx.BufferLength = BUFSZ+4;
		req->Io.Rx.PhysicalDataAddress = item->phys;
		if (!TAU32_SubmitRequest (b->ddk.pControllerObject, req)) {
			CE_DDK_DEBUG (b, c, ("RX submition failure\n"));
			c->rx_pending--;
			CE_ENQUEUE_HEAD (c->rx_queue, req);
			break;
		}
	}
	EXIT ();
}

static void TAU32_CALLBACK_TYPE ce_on_transmit
	(TAU32_UserContext *pContext, TAU32_UserRequest *req)
{
	int len;
	unsigned int error;
	ce_chan_t *c;
	ENTER ();

	if (!req || !req->sys) {
		EXIT ();
	}

	c = (ce_chan_t *)req->sys;

	len = req->Io.Tx.Transmitted;
	error = req->ErrorCode;
	
	c->tintr++;
	if (error == TAU32_SUCCESSFUL) {
		c->obytes += len;
		c->opkts++;
	} else if (error & TAU32_ERROR_BUS) {
		c->underrun++;
		if (c->error)
			c->error (c, CE_UNDERRUN);		
	} else {
		CE_DDK_DEBUG (c->board, c, ("Another transmit error: %x\n",
				error));
		/* Do some procesing */
	}
	
	CE_ENQUEUE (c->tx_queue, req);
	c->tx_pending--;
	
	if (c->transmit)
		c->transmit (c, 0, len);
	EXIT ();
}

int ce_transmit_space (ce_chan_t *c)
{
	return c->tx_pending < (TAU32_IO_QUEUE);
}

int ce_send_packet (ce_chan_t *c, unsigned char *buf, int len, void *tag)
{
	TAU32_UserRequest *req;
	ce_buf_item_t *item;
	
	ENTER ();

	if (!ce_transmit_space (c)) {
		EXIT (-1);
	}

	if (len <= 0 || len > BUFSZ) {
		EXIT (-2);
	}

	CE_DEQUEUE (c->tx_queue, req);
	CE_ASSERT (req);
	item = (ce_buf_item_t *)req;
		
	if (buf != item->buf)
		memcpy (item->buf, buf, len);
		
	CE_ASSERT (!req->pInternal);
		
	req->Command = TAU32_Tx_Data | TAU32_Tx_FrameEnd;
	req->Io.Tx.Channel = c->num;
	req->pCallback = ce_on_transmit;
	req->Io.Tx.DataLength = len;
	req->Io.Tx.PhysicalDataAddress = item->phys;
	c->tx_pending++;
	if (!TAU32_SubmitRequest (c->board->ddk.pControllerObject, req)) {
		CE_DDK_DEBUG (c->board, c, ("Can't submit packet for "
					    "transmission\n"));
		CE_ENQUEUE_HEAD (c->tx_queue, req);
		c->tx_pending--;
		EXIT (-3);
	}
	EXIT (0);
}

static void TAU32_CALLBACK_TYPE ce_on_config
	(TAU32_UserContext *pContext, TAU32_UserRequest *req)
{
	ce_board_t *b = (ce_board_t *) pContext;
	ENTER ();
	b->cr.pending--;
	if (req->ErrorCode)
		CE_DDK_DEBUG (b, (ce_chan_t*)0, ("Config request failure: %lx\n",
			      req->ErrorCode));
	EXIT ();
}

static void TAU32_CALLBACK_TYPE ce_on_config_stop
	(TAU32_UserContext *pContext, TAU32_UserRequest *req)
{
	int i, first;
	TAU32_UserRequest *rreq;
	ce_board_t *b = (ce_board_t *) pContext;
	ce_chan_t *c = b->chan + req->Io.ChannelNumber;
	
	ENTER ();
	/* Stop all requests */
	CE_ASSERT (0);/* Buggy */
	CE_LAST_ITEM (c->rx_queue, rreq);
	/* A little hacky, try to guess which is a first */
	first = rreq ? (c->rx_item - (ce_buf_item_t *)rreq) + 1 : 0;
	for (i = 0; i < TAU32_IO_QUEUE; i++) {
		int is_pending;
		rreq = &c->rx_item[(i + first) % TAU32_IO_QUEUE].req;
		CE_FIND_ITEM (c->rx_queue, rreq, is_pending);
		if (!is_pending)
			continue;
		TAU32_CancelRequest (b->ddk.pControllerObject, rreq, 1);
		rreq->Command = TAU32_Rx_Data;
		rreq->Io.Rx.Channel = c->num;
		rreq->Io.Rx.BufferLength = BUFSZ+4;
		rreq->Io.Rx.PhysicalDataAddress = ((ce_buf_item_t *)rreq)->phys;
		c->rx_pending++;
		if (!TAU32_SubmitRequest (b->ddk.pControllerObject, rreq)) {
			CE_ASSERT (0);/* Buggy */
			c->rx_pending--;
			break;
		}
	}
	
	c->tx_pending = 0;
/*	c->rx_pending = 0;*/
	EXIT ();
}

static int ce_cfg_submit (ce_board_t *b)
{
	TAU32_UserRequest *req;
	ENTER ();

	CE_DEQUEUE (b->cr.queue, req);
	CE_ASSERT (req);
	CE_ASSERT (!req->pInternal);

	req->pCallback = ce_on_config;
	b->cr.pending++;
	
	CE_DDK_DEBUG (b, (ce_chan_t *)0, ("config request pending: %d\n",
		      b->cr.pending));

	if (!TAU32_SubmitRequest (b->ddk.pControllerObject, req)) {
		CE_ENQUEUE_HEAD (b->cr.queue, req);
		CE_DDK_DEBUG (b, (ce_chan_t *)0, ("Fail to submit config request\n"));
		b->cr.pending--;
		EXIT (0);
	}
	
	EXIT (1);
}

void ce_init_board (ce_board_t *b)
{
	int i;

	b->cr.queue = NULL;

	for (i = 0; i < CONFREQSZ; i++) {
		CE_ENQUEUE (b->cr.queue, b->cr.req + i);
	}

	b->chan[0].config = TAU32_ais_on_loss;

	/* lloop = off, rloop = off */
	b->chan[0].config |= TAU32_LineNormal;
	b->chan[0].lloop = 0;
	b->chan[0].rloop = 0;

	/* unfram=off, scrambler=off, use16=off, crc4=off,
	   higain=off, monitor=off*/
	b->chan[0].config |= (b->ddk.Interfaces == 2 ? TAU32_framed_cas_cross :
						       TAU32_framed_cas_set);
	b->chan[0].unfram = 0;
	b->chan[0].scrambler = 0;
	b->chan[0].use16 = 0;
	b->chan[0].crc4 = 0;
	b->chan[0].higain = 0;
	b->chan[0].monitor = 0;

	if (b->ddk.Interfaces == 2) {
		b->chan[1].config = TAU32_ais_on_loss;
		/* lloop = off, rloop = off */
		b->chan[1].config |= TAU32_LineNormal;
		/* unfram=off, scrambler=off, use16=off, crc4=off,
		   higain=off, monitor=off*/
		b->chan[1].config |= TAU32_framed_cas_cross;
		b->chan[1].unfram = 0;
		b->chan[1].scrambler = 0;
		b->chan[1].use16 = 0;
		b->chan[1].crc4 = 0;
		b->chan[1].higain = 0;
		b->chan[1].monitor = 0;
	}

	for (i = 0; i < NCHAN; i++) {
		/* Chan0 ts=1-15,17-31, Chan1 ts=1-2 */
		b->chan[i].type = i < b->ddk.Interfaces ? T_E1 : T_DATA;
		b->chan[i].ts = (i == 0 ? 0xfffefffe :
				(i != 1 ? 0 : 
				(b->ddk.Interfaces == 2 ? 0x6: 0)));
		b->chan[i].dir = (b->ddk.Interfaces == 2) ? (i%2) : 0;
		b->chan[i].mtu = 1504;
	}
#if 0
	/* c->num == 0 */
	req = b->cr.queue;
	/* We must have some here */
	CE_ASSERT (req);
	req->Command = TAU32_Configure_E1;
	req->Io.InterfaceConfig.Interface = TAU32_E1_A;
	req->Io.InterfaceConfig.Config = b->chan[0].config;
	req->Io.InterfaceConfig.UnframedTsMask = 0;
	if (!ce_cfg_submit (b)) {
		CE_DDK_DEBUG (b, b->chan + 0,
			      ("Submit request failure, line %d\n",
			      __LINE__));
	}
	/* c->num == 1 */
	if (b->ddk.Interfaces == 2) {
		req = b->cr.queue;
		/* We must have some here */
		CE_ASSERT (req);
		req->Command = TAU32_Configure_E1;
		req->Io.InterfaceConfig.Interface = TAU32_E1_B;
		req->Io.InterfaceConfig.Config = b->chan[1].config;
		req->Io.InterfaceConfig.UnframedTsMask = 0;
		if (!ce_cfg_submit (b)) {
			CE_DDK_DEBUG (b, b->chan + 1,
				      ("Submit request failure, line %d\n",
				      __LINE__));
		}
	}
#endif
	/* Set default cross matrix */
	for (i = 0; i < 32; i++) {
		/* -X-> Peb */
		b->dxc[i] = TAU32_CROSS_OFF;
		/* Link2 -> Link1 */
		b->dxc[i + 32] = i + 64;
		/* Link1 -> Link2 */
		b->dxc[i + 64] = i + 32;
	}

	/* We have only mux mode for now. Later we will also have cross mode */
	b->mux = 1;
}

void ce_start_chan (ce_chan_t *c, int tx, int rx, ce_buf_t *cb,
	unsigned long phys)
{
	int i;
	ce_board_t *b = c->board;

/*	c->config = TAU32_ais_on_loss | TAU32_framed_cas_cross;*/

	if (cb) {
		CE_DDK_DEBUG (b, c, ("ce_buf_t virt:%p phys:%p\n", cb,
			      (void *)phys));
		c->tx_item = cb->tx_item;
		c->rx_item = cb->rx_item;
		c->tx_queue = NULL;
		c->rx_queue = NULL;
		for (i = 0; i < TAU32_IO_QUEUE; i++) {
			c->tx_item[i].phys = phys +
				((char *)(c->tx_item[i].buf)-(char *)cb);
			c->rx_item[i].phys = phys +
				((char *)(c->rx_item[i].buf)-(char *)cb);
			cb->tx_item[i].req.sys = c;
			cb->rx_item[i].req.sys = c;
			CE_DDK_DEBUG (b, c, ("tx_item[%d].buf virt:%p phys:%p\n",
				      i, c->tx_item[i].buf,
				      (void *)c->tx_item[i].phys));
			CE_DDK_DEBUG (b, c, ("rx_item[%d].buf virt:%p phys:%p\n",
				      i, c->rx_item[i].buf,
				      (void *)c->rx_item[i].phys));
			CE_ENQUEUE (c->rx_queue, &c->rx_item[i].req);
			CE_ENQUEUE (c->tx_queue, &c->tx_item[i].req);
		}
		c->tx_pending = 0;
		c->rx_pending = 0;
	}
	
	/* submit rx */
	while (1) {
		ce_buf_item_t *item;
		TAU32_UserRequest *req;
		
		CE_DEQUEUE (c->rx_queue, req);
		if (!req)
			break;
		item = (ce_buf_item_t *) req;
		CE_ASSERT (c->rx_pending < TAU32_IO_QUEUE);
		req->Command = TAU32_Rx_Data;
		req->Io.Rx.Channel = c->num;
		req->pCallback = ce_on_receive;
		req->Io.Rx.BufferLength = c->mtu + (c->phony ? 0 : 4);
		req->Io.Rx.PhysicalDataAddress = item->phys;
		c->rx_pending++;
		if (!TAU32_SubmitRequest (b->ddk.pControllerObject, req)) {
			CE_DDK_DEBUG (b, c, ("Faild to submit rx request\n"));
			/*XXXRIK: shouldn't happen, but ... */
			CE_ASSERT (0);
			c->rx_pending--;
			break;
		}	
	}
	
	if (tx | rx) {
		TAU32_UserRequest *req;
		CE_PREREQUEST (b, c, b->cr.queue, req);
		if (!req)
 			return;
		req->Command = TAU32_Configure_Commit |
			       (tx ? TAU32_Tx_Start : 0) |
			       (rx ? TAU32_Rx_Start : 0);
		req->Io.ChannelNumber = c->num;
		if (!ce_cfg_submit (b)) {
			CE_DDK_DEBUG (b, c, ("Can't start chan\n"));
			/* Do some error processing */
			return;
		}
	}
	
	/* If we run just after ce_board_init we have prope values.
	 * Else I hope you didn't set ts to incorrect value.
	 */
	_ce_set_ts (c, c->ts);
	if (c->num < b->ddk.Interfaces) {
		/* The same for other modes. We don't check them.
		 * We hope that config is correctly set. Just as we have
		 * after ce_board_init. If channel was stoped we hope that
		 * it's config was not broken just after it and we didn't
		 * brake it before start.
		 */
		_ce_submit_configure_e1 (c, "start_init");
	}
}

void ce_stop_chan (ce_chan_t *c)
{
	ce_board_t *b = c->board;
	TAU32_UserRequest *req;
	CE_DEQUEUE (b->cr.queue, req);

	/* XXXRIK: This function should be for comleteness, but for now I
	 * don't use it. So I just start to write and didn't finished it yet.
	 * It and it is VERY BUGGY!!! Do not use it. If you really
	 * need it ask me to fix it or rewrite it by your self.
	 * Note: most buggy part of it in ce_on_config_stop!
	 */
	if (!req) {
		CE_DDK_DEBUG (b, c, ("Fatal error, no free structs for "
			      "UserRequest (%s:%d)\n", __FUNCTION__, __LINE__));
		return;
	}
	req->Command = TAU32_Configure_Commit |
		       TAU32_Tx_Stop | TAU32_Rx_Stop;
	req->Command = 0;
	req->Io.ChannelNumber = c->num;
	req->pCallback = ce_on_config_stop;
	b->cr.pending++;
	
	if (!TAU32_SubmitRequest (b->ddk.pControllerObject, req)) {
		CE_ENQUEUE_HEAD (b->cr.queue, req);
		CE_DDK_DEBUG (b, c, ("Can't stop chan\n"));
		b->cr.pending--;
	}
}	


void ce_register_transmit (ce_chan_t *c,
	void (*func) (ce_chan_t*, void*, int))
{
	c->transmit = func;
}

void ce_register_receive (ce_chan_t *c,
	void (*func) (ce_chan_t*, unsigned char*, int))
{
	c->receive = func;
}

void ce_register_error (ce_chan_t *c,
	void (*func) (ce_chan_t*, int))
{
	c->error = func;
}

void TAU32_CALLBACK_TYPE ce_error_callback (TAU32_UserContext *pContext,
						int Item, unsigned NotifyBits)
{
	ce_board_t *b = (ce_board_t *) pContext;
	ENTER ();
	if (NotifyBits & (TAU32_ERROR_FAIL | TAU32_ERROR_TIMEOUT
		| TAU32_ERROR_INT_OVER_TX | TAU32_ERROR_INT_OVER_RX
		| TAU32_ERROR_INT_STORM)) {
		/* Fatal: adapter failure, need reset & restart */
		/* RIKXXX: probably I should add CE_FAILURE for ce_error */
		CE_DDK_DEBUG (b, (ce_chan_t *)0, ("Err, disable interrupts: %s\n",
				ce_err2str (NotifyBits)));
/*		TAU32_DisableInterrupts (b->ddk.pControllerObject);*/
		EXIT ();
	}
	if (Item >= 0) {
		/* channel error */
		ce_chan_t *c = b->chan + Item;
		if (NotifyBits & TAU32_ERROR_TX_UNDERFLOW) {
			c->underrun++;
			if (c->error)
				c->error (c, CE_UNDERRUN);
		}
		if (NotifyBits & TAU32_ERROR_RX_OVERFLOW) {
			c->overrun++;
			if (c->error)
				c->error (c, CE_OVERFLOW);
		}
		if (NotifyBits & (TAU32_ERROR_RX_FRAME | TAU32_ERROR_RX_ABORT |
		    TAU32_ERROR_RX_SHORT | TAU32_ERROR_RX_LONG |
		    TAU32_ERROR_RX_SYNC | TAU32_ERROR_RX_SPLIT |
		    TAU32_ERROR_RX_UNFIT)) {
			c->frame++;
			CE_DDK_DEBUG (b, c, ("Frame error: %x\n", NotifyBits));
			if (c->error)
				c->error (c, CE_FRAME);
		}
		if(NotifyBits & TAU32_ERROR_RX_CRC) {
			c->crc++;
			if (c->error)
				c->error (c, CE_CRC);
		}
	} else {
		CE_DDK_DEBUG (b, (ce_chan_t *)0, ("Another error: %x\n",
			      NotifyBits));
		/* Adapter error, do smth */
	}
	EXIT ();
}

void TAU32_CALLBACK_TYPE ce_status_callback(TAU32_UserContext *pContext,
						int Item, unsigned NotifyBits)
{
	ce_board_t *b = (ce_board_t *) pContext;
	ENTER ();
	if(Item >= 0) {
		/* e1 status */
		ce_chan_t *c = b->chan + Item;
		c->acc_status |= b->ddk.InterfacesInfo[Item].Status;
/*		CE_DDK_DEBUG (b, c, ("Current status: %x\n", c->acc_status));*/
	} else {
		CE_DDK_DEBUG (b, (ce_chan_t *)0, ("Another status: %x\n", NotifyBits));
		/* Adapter status, do smth. */
	}
	EXIT ();
}

int ce_get_cd (ce_chan_t *c)
{
	unsigned int e1status = c->board->ddk.InterfacesInfo[c->dir].Status;

	return (c->ts && !(e1status & (TAU32_RCL | TAU32_E1OFF)));
}

int ce_get_cts (ce_chan_t *c)
{
	return 0;
}

int ce_get_dsr (ce_chan_t *c)
{
	return 0;
}

void ce_e1_timer (ce_chan_t *c)
{
	unsigned bpv, fas, crc4, ebit, pcv, oof, css;
	unsigned int acc_status;
	ce_board_t *b = c->board;
	TAU32_E1_State	*state;

	if (c->num >= b->ddk.Interfaces)
		return;
	
	state = &b->ddk.InterfacesInfo[c->num];
	acc_status = c->acc_status;
	
	/* Clear acc_status */
	c->acc_status = b->ddk.InterfacesInfo[c->num].Status;

	/* Count seconds.
	 * During the first second after the channel startup
	 * the status registers are not stable yet,
	 * we will so skip the first second. */
	++c->cursec;
	if (! c->totsec && c->cursec <= 1)
		return;

	c->status = 0;

	/* Compute the SNMP-compatible channel status. */
	oof = 0;

	if (acc_status & TAU32_RCL)
		c->status |= ESTS_LOS;		/* loss of signal */
	if (acc_status & TAU32_RUA1)
		c->status |= ESTS_AIS;		/* receiving all ones */

	/* Get error counters. */
	bpv = state->RxViolations;
	fas = 0;
	crc4 = 0;
	ebit = 0;
	css = 0;

	if (! c->unfram) {
		if (! c->use16 && (acc_status & TAU32_RSA1))
			c->status |= ESTS_AIS16;	/* signaling all ones */
		if (! c->use16 && (acc_status & TAU32_RDMA))
			c->status |= ESTS_FARLOMF;	/* alarm in timeslot 16 */
		if (acc_status & TAU32_RRA)
			c->status |= ESTS_FARLOF;	/* far loss of framing */

		if (acc_status & TAU32_RFAS) {
			c->status |= ESTS_LOF;		/* loss of framing */
			++oof;				/* out of framing */
		}
		if ((! c->use16 && (acc_status & TAU32_RCAS)) ||
		    (c->crc4 && (acc_status & TAU32_RCRC4))) {
			c->status |= ESTS_LOMF;		/* loss of multiframing */
			++oof;				/* out of framing */
		}
		fas = state->FasErrors;
		crc4 = state->Crc4Errors;
		ebit = state->FarEndBlockErrors;

		/* Controlled slip second -- any slip event. */
		css = state->TransmitSlips + state->ReceiveSlips;
	}
	
	/* Clear state */
	state->RxViolations		= 0;
	state->FasErrors		= 0;
	state->Crc4Errors		= 0;
	state->FarEndBlockErrors	= 0;
	state->TransmitSlips		= 0;
	state->ReceiveSlips		= 0;

	if (c->status & ESTS_LOS)
		c->status = ESTS_LOS;
	else if (c->status & ESTS_AIS)
		c->status = ESTS_AIS;
	else if (c->status & ESTS_LOF)
		c->status = ESTS_LOF;
	else if (c->status & ESTS_LOMF)
		c->status &= ~(ESTS_FARLOMF | ESTS_AIS16);

	if (! c->status)
		c->status = ESTS_NOALARM;

	c->currnt.bpv += bpv;
	c->currnt.fse += fas;
	if (c->crc4) {
		c->currnt.crce += crc4;
		c->currnt.rcrce += ebit;
	}

	/* Path code violation is frame sync error if CRC4 disabled,
	 * or CRC error if CRC4 enabled. */
	pcv = fas;
	if (c->crc4)
		pcv += crc4;

	/* Unavaiable second -- receiving all ones, or
	 * loss of carrier, or loss of signal. */
	if (acc_status & (TAU32_RUA1 | TAU32_RCL))
		/* Unavailable second -- no other counters. */
		++c->currnt.uas;
	else {
		/* Line errored second -- any BPV. */
		if (bpv)
			++c->currnt.les;

		/* Errored second -- any PCV, or out of frame sync,
		 * or any slip events. */
		if (pcv || oof || css)
			++c->currnt.es;

		/* Severely errored framing second -- out of frame sync. */
		if (oof)
			++c->currnt.oofs;

		/* Severely errored seconds --
		 * 832 or more PCVs, or 2048 or more BPVs. */
		if (bpv >= 2048 || pcv >= 832)
			++c->currnt.ses;
		else {
			/* Bursty errored seconds --
			 * no SES and more than 1 PCV. */
			if (pcv > 1)
				++c->currnt.bes;

			/* Collect data for computing
			 * degraded minutes. */
			++c->degsec;
			c->degerr += bpv + pcv;
		}
	}

	/* Degraded minutes -- having error rate more than 10e-6,
	 * not counting unavailable and severely errored seconds. */
	if (c->cursec % 60 == 0) {
		if (c->degerr > c->degsec * 2048 / 1000)
			++c->currnt.dm;
		c->degsec = 0;
		c->degerr = 0;
	}

	/* Rotate statistics every 15 minutes. */
	if (c->cursec > 15*60) {
		int i;

		for (i=47; i>0; --i)
			c->interval[i] = c->interval[i-1];
		c->interval[0] = c->currnt;

		/* Accumulate total statistics. */
		c->total.bpv   += c->currnt.bpv;
		c->total.fse   += c->currnt.fse;
		c->total.crce  += c->currnt.crce;
		c->total.rcrce += c->currnt.rcrce;
		c->total.uas   += c->currnt.uas;
		c->total.les   += c->currnt.les;
		c->total.es    += c->currnt.es;
		c->total.bes   += c->currnt.bes;
		c->total.ses   += c->currnt.ses;
		c->total.oofs  += c->currnt.oofs;
		c->total.css   += c->currnt.css;
		c->total.dm    += c->currnt.dm;
		c->currnt.bpv	= 0;
		c->currnt.fse	= 0;
		c->currnt.crce	= 0;
		c->currnt.rcrce	= 0;
		c->currnt.uas	= 0;
		c->currnt.les	= 0;
		c->currnt.es	= 0;
		c->currnt.bes	= 0;
		c->currnt.ses	= 0;
		c->currnt.oofs	= 0;
		c->currnt.css	= 0;
		c->currnt.dm	= 0;

		c->totsec += c->cursec;
		c->cursec = 0;
	}
}

void ce_set_baud (ce_chan_t *c, unsigned long baud)
{
	TAU32_UserRequest *req;
	ce_board_t *b = c->board;
	unsigned long cfg = c->config & ~TAU32_framing_mode_mask;
	unsigned long ts;
	unsigned long kbps = (baud + 32000) / 64000 * 64;
	
	if (!c->unfram || c->num != 0 ||
		baud == c->baud || b->cr.pending >= CONFREQSZ)
		return;
	
	if (!kbps || kbps > 1024) {
		ts = 0xffffffffUL;
		cfg |= TAU32_unframed_2048;
	} else if (kbps > 512) {
		ts = 0x0000ffffUL;
		cfg |= TAU32_unframed_1024;
	} else if (kbps > 256) {
		ts = 0x000000ffUL;
		cfg |= TAU32_unframed_512;
	} else if (kbps > 128) {
		ts = 0x0000000fUL;
		cfg |= TAU32_unframed_256;
	} else if (kbps > 64) {
		ts = 0x00000003UL;
		cfg |= TAU32_unframed_128;
	} else {
		ts = 0x00000001UL;
		cfg |= TAU32_unframed_64;
	}

	/* _ce_set_ts () will set proper baud */
	_ce_set_ts (c, ts);
	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;
	req->Command = TAU32_Configure_E1;
	req->Io.InterfaceConfig.Interface = TAU32_E1_A;
	req->Io.InterfaceConfig.Config = cfg;
	req->Io.InterfaceConfig.UnframedTsMask = ts;
	if (ce_cfg_submit (b)) {
		c->baud = baud;
		c->ts = ts;
		c->config = cfg;
	}
}

void ce_set_lloop (ce_chan_t *c, unsigned char on)
{
	TAU32_UserRequest *req;
	unsigned long cfg = c->config & ~(TAU32_line_mode_mask | TAU32_ais_on_loss);
	ce_board_t *b = c->board;

	if (c->num >= b->ddk.Interfaces || b->cr.pending >= CONFREQSZ)
		return;
	on = on ? 1 : 0;
	if (on == c->lloop)
		return;

	cfg |= on ? TAU32_LineLoopInt : (TAU32_LineNormal | TAU32_ais_on_loss);
	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;
	req->Command = TAU32_Configure_E1;
	req->Io.InterfaceConfig.Interface = c->num ? TAU32_E1_B : TAU32_E1_A;
	req->Io.InterfaceConfig.Config = cfg;
	req->Io.InterfaceConfig.UnframedTsMask = c->ts;
	CE_DDK_DEBUG (b, c, ("Submit lloop\n"));
	if (ce_cfg_submit (b)) {
		c->lloop = on ? 1 : 0;
		c->config = cfg;
	} 
}

void ce_set_rloop (ce_chan_t *c, unsigned char on)
{
	TAU32_UserRequest *req;
	unsigned long cfg = c->config & ~TAU32_line_mode_mask;
	ce_board_t *b = c->board;

	if (c->num >= b->ddk.Interfaces || b->cr.pending >= CONFREQSZ)
		return;
	on = on ? 1 : 0;
	if (on == c->rloop)
		return;

	cfg |= on ? TAU32_LineLoopExt : TAU32_LineNormal;
	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;
	req->Command = TAU32_Configure_E1;
	req->Io.InterfaceConfig.Interface = c->num ? TAU32_E1_B : TAU32_E1_A;
	req->Io.InterfaceConfig.Config = cfg;
	req->Io.InterfaceConfig.UnframedTsMask = c->ts;
	CE_DDK_DEBUG (b, c, ("Submit rloop\n"));
	if (ce_cfg_submit (b)) {
		c->rloop = on ? 1 : 0;
		c->config = cfg;
	}
}

void ce_set_higain (ce_chan_t *c, unsigned char on)
{
	TAU32_UserRequest *req;
	unsigned long cfg = c->config & ~TAU32_higain;
	ce_board_t *b = c->board;

	if (c->num >= b->ddk.Interfaces || b->cr.pending >= CONFREQSZ)
		return;
	on = on ? 1 : 0;
	if (on == c->higain)
		return;

	cfg |= on ? TAU32_higain : 0;
	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;
	req->Command = TAU32_Configure_E1;
	req->Io.InterfaceConfig.Interface = c->num ? TAU32_E1_B : TAU32_E1_A;
	req->Io.InterfaceConfig.Config = cfg;
	req->Io.InterfaceConfig.UnframedTsMask = c->ts;
	CE_DDK_DEBUG (b, c, ("Submit higain\n"));
	if (ce_cfg_submit (b)) {
		c->higain = on ? 1 : 0;
		c->config = cfg;
	}
}

static void _ce_set_ts (ce_chan_t *c, unsigned long ts)
{
	TAU32_UserRequest *req;
	ce_board_t *b = c->board;
	unsigned long mask = 0, omask = 0;
	int nts = 0, ots = 0, pts = 0;
	int i, k;

	if (b->cr.pending >= CONFREQSZ)
		return;

	/*
	 * pts - number of busy "peb" ts
	 * ots - current (old) busy ts
	 * nts - new busy ts
	 */
	for (i = 0; i < 32; i++) {
		if (c->ts & (1ul << i))
			ots++;
		if (ts & (1ul << i))
			nts++;
		if (b->dxc[i] != TAU32_CROSS_OFF)
			pts++;
	}
	
	CE_DDK_DEBUG (b, c, ("pts: %d ots: %d nts: %d ts: %lx\n", pts, ots, nts,
		      ts));
	/* 32 - all busy + my old busy == free */
	if (32 - pts + ots - nts < 0)
		return;
		
	/* Ok. We have enougth "peb" ts. Clean old. */
	/* We start from zero, cause this is peb cells */
	for (i = 0; i < 32; i++) {
		int tin = b->dxc[i];
		int t = tin % 32;
		if (tin < (c->dir?64:32) || tin > (c->dir?95:63))
			continue;
		if (c->ts & (1ul << t)) {
			b->dxc[tin] = TAU32_CROSS_OFF;
			b->dxc[i] = TAU32_CROSS_OFF;
			if (b->dxc[t + 32] == TAU32_CROSS_OFF &&
			    b->dxc[t + 64] == TAU32_CROSS_OFF) {
				b->dxc[t + 32] = t + 64;
				b->dxc[t + 64] = t + 32;
			}
			omask |= (1ul << t);
		}
	}
	
	k = 0;
	/* Set */
	for (i = 0; i < 32; i++) {
		if ((ts & (1ul << i)) == 0)
			continue;
		while (b->dxc[k] != TAU32_CROSS_OFF) {
			k++;
			/* Paranoic */
			if (k >= 32) {
				CE_DDK_DEBUG (b, c, ("TS count overflow\n"));
				return;
			}
		}
		b->dxc[k] = (c->dir?64:32) + i;
		b->dxc[(c->dir?64:32) + i] = k;
		if (b->dxc[(c->dir?32:64) + i] == (c->dir?64:32) + i)
			b->dxc[(c->dir?32:64) + i] = TAU32_CROSS_OFF;
		mask |= (1ul << k);
	}
	
	c->ts = ts;
	c->baud = nts*64000;

	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;

	req->Command = TAU32_Timeslots_Channel | TAU32_Configure_Commit;
	req->Io.ChannelNumber = c->num;
	req->Io.ChannelConfig.AssignedTsMask = mask;	
	
	if (c->phony) {
		b->pmask &= ~omask;
		b->pmask |= mask;
	}
	
	CE_DDK_DEBUG (b, c, ("ts=%lx mask=%lx omask=%lx pmask=%lx\n", c->ts,
		      mask, omask, b->pmask));
	CE_DDK_DEBUG (b, c, ("Crossmatrix table:\n"));

#ifdef CE_DDK_DEBUG_ENABLED
	for (i = 0; i < 32*3; i++) {
		printf ("%3d\t%s", b->dxc[i], (i%8==7)?"\n":"");
		printf ("%s",(i%32==31)?"\n":"");
	}
#endif

	CE_DDK_DEBUG (b, c, ("Submit tsmask\n"));
	if (!ce_cfg_submit (b)) {
		CE_DDK_DEBUG (b, c, ("Fail to submit tsmask\n"));
		/* Do some error processing */
		return;
	}
	
	CE_DDK_DEBUG (b, c, ("SetCrossMatrix\n"));
	if (!TAU32_SetCrossMatrix(b->ddk.pControllerObject, b->dxc, b->pmask)) {
		CE_DDK_DEBUG (b, c, ("Faild to SetCrossMatrix\n"));
		/* Do some error processing */
		return;
	}
}

void ce_set_ts (ce_chan_t *c, unsigned long ts)
{
	ce_board_t *b = c->board;
	ce_chan_t *x;

	if (c->ts == ts || b->chan->unfram)
		return;

	ts &= ~(1ul);

	if (!b->chan[c->dir].use16)
		ts &= ~(1ul << 16);
		
	for (x = b->chan; x < b->chan + NCHAN; x++) {
		if (x == c || x->dir != c->dir)
			continue;
		ts &= ~x->ts;
	}
	
	_ce_set_ts (c, ts);
}

void ce_set_unfram (ce_chan_t *c, unsigned char on)
{
	TAU32_UserRequest *req;
	ce_board_t *b = c->board;
	unsigned long cfg = c->config & ~TAU32_framing_mode_mask;
	unsigned long i;
	
	if (c->num != 0 || b->cr.pending + 2*32 + 3>= CONFREQSZ)
		return;

	on = on ? 1 : 0;
	
	if (on == c->unfram)
		return;
		
	if (on) {
		ce_set_dir (c, 0);
		for (i = 1; i < TAU32_CHANNELS; i++) {
			ce_set_ts (b->chan + i, 0);
			ce_set_phony (b->chan + i, 0);
		}
		ce_set_use16 (b->chan + 0, 0);
		ce_set_use16 (b->chan + 1, 0);
		/* Get current value, previous ce_set request may change it */
		cfg = c->config & ~TAU32_framing_mode_mask;
		cfg |= TAU32_unframed_2048;
		c->unfram = on;
		_ce_set_ts (b->chan, ~0ul);
		c->config = cfg;
		/* XXXRIK: Do extra checks on config queue size*/
		if (b->ddk.Interfaces) {
			CE_PREREQUEST (b, c, b->cr.queue, req);
			if (!req)
				return;
			req->Command = TAU32_Configure_E1;
			req->Io.InterfaceConfig.Interface = TAU32_E1_B;
			req->Io.InterfaceConfig.Config = TAU32_LineOff;
			req->Io.InterfaceConfig.UnframedTsMask = 0;
			CE_DDK_DEBUG (b, c, ("unfram: B line off\n"));
			ce_cfg_submit (b);
		}
		CE_PREREQUEST (b, c, b->cr.queue, req);
		if (!req)
			return;
		req->Command = TAU32_Configure_E1;
		req->Io.InterfaceConfig.Interface = TAU32_E1_A;
		req->Io.InterfaceConfig.Config = cfg;
		req->Io.InterfaceConfig.UnframedTsMask = c->ts;
		CE_DDK_DEBUG (b, c, ("Submit unfram\n"));
		ce_cfg_submit (b);
	} else {
		cfg |= TAU32_framed_cas_cross;
		CE_PREREQUEST (b, c, b->cr.queue, req);
		if (!req)
			return;
		req->Command = TAU32_Configure_E1;
		req->Io.InterfaceConfig.Interface = TAU32_E1_ALL;
		req->Io.InterfaceConfig.Config = cfg;
		req->Io.InterfaceConfig.UnframedTsMask = 0;
		CE_DDK_DEBUG (b, c, ("Submit framed\n"));
		ce_cfg_submit (b);
		ce_set_ts (c, 0);
	}
	c->unfram = on;
}

void ce_set_phony (ce_chan_t *c, unsigned char on)
{
	TAU32_UserRequest *req;
	ce_board_t *b = c->board;
	unsigned long mask = 0;
	int i;
	
	if ((c->phony && on) || (c->phony == 0 && on == 0) ||
	    b->cr.pending >= CONFREQSZ)
		return;
	
	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;

	req->Command = TAU32_Configure_Channel;
	req->Io.InterfaceConfig.Config = on ? TAU32_TMA :
		(TAU32_HDLC | TAU32_fr_rx_splitcheck | TAU32_fr_rx_fitcheck);
	req->Io.ChannelNumber = c->num;
	CE_DDK_DEBUG (b, c, ("Submit phony\n"));
	if (!ce_cfg_submit (b)) {
		/* Do some error processing */
		return;
	}

	for (i = 0; i < 32; i++) {
		int t = b->dxc[i] % 32;
		if (b->dxc[i] < (c->dir?64:32) || b->dxc[i] > (c->dir?95:63))
			continue;
		if (c->ts & (1ul << t))
			mask |= (1ul << t);
	}
	
	CE_DDK_DEBUG (b, c, ("phony mask:%lx\n", mask));
	
	if (on) {
		b->pmask |= mask;
	} else {
		b->pmask &= ~mask;
	}

	c->phony = on ? 1 : 0;
	
	CE_DDK_DEBUG (b, c, ("Submit (setcrosmatrix) phony\n"));
	if (!TAU32_SetCrossMatrix(b->ddk.pControllerObject, b->dxc, b->pmask)) {
		/* Do some error processing */
		return;
	}
}

void ce_set_scrambler (ce_chan_t *c, unsigned char on)
{
	TAU32_UserRequest *req;
	unsigned long cfg = c->config & ~TAU32_scrambler;
	ce_board_t *b = c->board;

	if (c->num != 0 || c->unfram == 0 || b->cr.pending >= CONFREQSZ)
		return;
	on = on ? 1 : 0;
	if (on == c->scrambler)
		return;

	cfg |= on ? TAU32_scrambler : 0;
	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;
	req->Command = TAU32_Configure_E1;
	req->Io.InterfaceConfig.Interface = c->num ? TAU32_E1_B : TAU32_E1_A;
	req->Io.InterfaceConfig.Config = cfg;
	req->Io.InterfaceConfig.UnframedTsMask = c->ts;
	CE_DDK_DEBUG (b, c, ("Submit scrambler\n"));
	if (ce_cfg_submit (b)) {
		c->scrambler = on ? 1 : 0;
		c->config = cfg;
	}
}

void ce_set_monitor (ce_chan_t *c, unsigned char on)
{
	TAU32_UserRequest *req;
	unsigned long cfg = c->config & ~TAU32_monitor;
	ce_board_t *b = c->board;

	if (c->num >= b->ddk.Interfaces || b->cr.pending >= CONFREQSZ)
		return;
	on = on ? 1 : 0;
	if (on == c->monitor)
		return;

	cfg |= on ? TAU32_monitor : 0;
	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;
	req->Command = TAU32_Configure_E1;
	req->Io.InterfaceConfig.Interface = c->num ? TAU32_E1_B : TAU32_E1_A;
	req->Io.InterfaceConfig.Config = cfg;
	req->Io.InterfaceConfig.UnframedTsMask = c->ts;
	CE_DDK_DEBUG (b, c, ("Submit monitor\n"));
	if (ce_cfg_submit (b)) {
		c->monitor = on ? 1 : 0;
		c->config = cfg;
	}
}

static void _ce_submit_configure_e1 (ce_chan_t *c, char *rname)
{
	TAU32_UserRequest *req;
	ce_board_t *b = c->board;

	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;
	req->Command = TAU32_Configure_E1;
	req->Io.InterfaceConfig.Interface = c->num == 0 ? TAU32_E1_A : TAU32_E1_B;
	req->Io.InterfaceConfig.Config = c->config;
	req->Io.InterfaceConfig.UnframedTsMask = c->ts;
	CE_DDK_DEBUG (b, c, ("Submit %s\n", rname ? rname : ""));
	if (!ce_cfg_submit (b)) {
		CE_DDK_DEBUG (b, c, ("Fail to submit %s\n", rname?rname:""));
		/* Do some error processing */
		return;	
	}
}

void ce_set_use16 (ce_chan_t *c, unsigned char on)
{
	ce_board_t *b = c->board;
	ce_chan_t *x;
	unsigned long cfg[2];
	int use[2];

	if (c->num >= b->ddk.Interfaces || b->cr.pending + 2 >= CONFREQSZ)
		return;

	cfg[0] = b->chan[0].config & ~TAU32_framing_mode_mask;
	cfg[1] = b->chan[1].config & ~TAU32_framing_mode_mask;
	
	on = on ? 1 : 0;
	
	if (c->use16 == on || b->chan->unfram)
		return;
		
	use[0] = b->chan[0].use16;
	use[1] = b->chan[1].use16;
	
	/* Correct value */
	use[c->num] = on;

	if (b->ddk.Interfaces == 1) {
		cfg[0] |= on ? TAU32_framed_cas_set : TAU32_framed_no_cas;
	} else {
		if (use[0] == 0 && use[1] == 0) {
			cfg[0] |= TAU32_framed_cas_cross;
			cfg[1] |= TAU32_framed_cas_cross;
		} else if (use[0] == 0) {
			cfg[0] |= TAU32_framed_cas_set;
			cfg[1] |= TAU32_framed_no_cas;
		} else if (use[1] == 0) {
			cfg[0] |= TAU32_framed_no_cas;
			cfg[1] |= TAU32_framed_cas_set;
		} else {
			cfg[0] |= TAU32_framed_no_cas;
			cfg[1] |= TAU32_framed_no_cas;
		}
	}

	c->use16 = on;

	for (x = b->chan; !on && x < b->chan + NCHAN; x++) {
		if (x->dir == c->num && x->ts & (1ul<<16)) {
			ce_set_ts (x, x->ts);
			break;
		}
	}

	if (cfg[0] != b->chan[0].config) {
		b->chan[0].config = cfg[0];
		_ce_submit_configure_e1 (b->chan + 0, "use16");
	}

	if (cfg[1] != b->chan[1].config) {
		b->chan[1].config = cfg[1];
		_ce_submit_configure_e1 (b->chan + 1, "use16");
	}
}

void ce_set_crc4 (ce_chan_t *c, unsigned char on)
{
	TAU32_UserRequest *req;
	unsigned long cfg = c->config & ~TAU32_crc4_mf;
	ce_board_t *b = c->board;

	if (c->num >= b->ddk.Interfaces || b->cr.pending >= CONFREQSZ)
		return;
	on = on ? 1 : 0;
	if (on == c->crc4 || b->chan->unfram)
		return;

	cfg |= on ? TAU32_crc4_mf : 0;
	CE_PREREQUEST (b, c, b->cr.queue, req);
	if (!req)
		return;
	req->Command = TAU32_Configure_E1;
	req->Io.InterfaceConfig.Interface = c->num ? TAU32_E1_B : TAU32_E1_A;
	req->Io.InterfaceConfig.Config = cfg;
	req->Io.InterfaceConfig.UnframedTsMask = c->ts;
	CE_DDK_DEBUG (b, c, ("Submit crc4\n"));
	if (ce_cfg_submit (b)) {
		c->crc4 = on ? 1 : 0;
		c->config = cfg;
	}
}

void ce_set_gsyn (ce_chan_t *c, int syn)
{
	ce_board_t *b = c->board;
	unsigned int mode;

	if (c->num >= b->ddk.Interfaces)
		return;
	
	if (syn == GSYN_RCV)
		syn = c->num ? GSYN_RCV1 : GSYN_RCV0;

	switch (syn) {
	default:	mode = TAU32_SYNC_INTERNAL;	break;
	case GSYN_RCV0:	mode = TAU32_SYNC_RCV_A;	break;
	case GSYN_RCV1:	mode = TAU32_SYNC_RCV_B;	break;
	}

	CE_DDK_DEBUG (b, c, ("Set Sync Mode\n"));
	if (TAU32_SetSyncMode (b->ddk.pControllerObject, mode)) {
		b->chan->gsyn = syn;
		if (b->ddk.Interfaces > 1)
			(b->chan + 1)->gsyn = syn;
	}
}

int ce_get_cable (ce_chan_t *c)
{
	ce_board_t *b = c->board;
	if (c->num >= b->ddk.Interfaces)
		return 0;

	return CABLE_TP;
}

void ce_set_dir (ce_chan_t *c, int dir)
{
	ce_board_t *b = c->board;
	unsigned long ts;
	if (b->cr.pending + 1>= CONFREQSZ || c->dir == dir)
		return;

	ts = c->ts;
	ce_set_ts (c, 0);
	c->dir = dir;
	ce_set_ts (c, ts);
}