e3e6a34984
Previously they included sys/dev/cx/machdep.h, but the cx driver was retired in r359178. These drivers haven't had real development for a decade or more so there's no real benefit in sharing this file; just copy it to the ce and cp subdirs.
1523 lines
36 KiB
C
1523 lines
36 KiB
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/ce/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 completeness, but for now I
|
|
* don't use it. I just started to write and haven't finished it yet.
|
|
* It is VERY BUGGY!!! Do not use it. If you really need
|
|
* it ask me to fix it or rewrite it by yourself.
|
|
* 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);
|
|
}
|