d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
df8437a93d
freebsd-skq/sys/dev/ce/ceddk.c
Mateusz Guzik ebf31a5cb9 ce: clean up empty lines in .c and .h files
2020-09-01 22:10:00 +00:00

1522 lines
36 KiB
C
Raw Blame History

/*
* 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);
}
Reference in New Issue View Git Blame Copy Permalink