/*
 * TRC_CORE.C - trace core module
 */

#include	<ndis.h>
#include	<ndiswan.h>
#include	<mydefs.h>
#include	<mytypes.h>
#include	<util.h>
#include	<opcodes.h>
#include	<adapter.h>
#include	<idd.h>
#include	<mtl.h>
#include	<cm.h>
#include	<trc.h>
#include	<disp.h>

/* local trace context table (NULL=free) */

#define	CheckNULLTrace(Trace)	\
		{				 		\
			if (Trace == NULL)	\
				break;			\
		}


/* register an available idd */
INT
trc_register_idd(VOID *idd)
{
    IDD_MSG     msg;

    D_LOG(D_ENTRY, ("trc_register_idd: entry, idd: 0x%lx", idd));

    /* add handle to idd command receiver */
    if ( idd_attach(idd, IDD_PORT_CMD_RX, (VOID*)trc__cmd_handler, idd) != IDD_E_SUCC )
        return(TRC_E_IDD);

	/* issue idd command to stop trace */
	NdisZeroMemory(&msg, sizeof(msg));
	msg.opcode = CMD_TRC_OFF;
	if ( idd_send_msg(idd, &msg, IDD_PORT_CMD_TX, NULL, NULL) != IDD_E_SUCC )
		return(TRC_E_IDD);

	return(TRC_E_SUCC);
}

/* deregister an available idd */
INT
trc_deregister_idd(VOID *idd)
{
    IDD_MSG     msg;

    D_LOG(D_ENTRY, ("trc_deregister_idd: entry, idd: 0x%lx", idd));

	/* issue idd command to stop trace */
	NdisZeroMemory(&msg, sizeof(msg));
	msg.opcode = CMD_TRC_OFF;
	if ( idd_send_msg(idd, &msg, IDD_PORT_CMD_TX, NULL, NULL) != IDD_E_SUCC )
		return(TRC_E_IDD);

    /* remove handle from idd command receiver */
    if ( idd_detach(idd, IDD_PORT_CMD_RX, (VOID*)trc__cmd_handler, idd) != IDD_E_SUCC )
        return(TRC_E_IDD);
    else
        return(TRC_E_SUCC);
}

/* create a trace object */
INT
trc_create(VOID **trc_1, ULONG depth)
{
	TRC	**ret_trc = (TRC**)trc_1;
    NDIS_PHYSICAL_ADDRESS   pa = NDIS_PHYSICAL_ADDRESS_CONST(0xffffffff, 0xffffffff);
    TRC                     *trc;

    D_LOG(D_ENTRY, ("trc_create: entry, ret_trc: 0x%lx, depth: %ld", ret_trc, depth));

    /* allocate memory object */
    NdisAllocateMemory((PVOID*)&trc, sizeof(*trc), 0, pa);
    if ( !trc )
    {
        mem_alloc_failed:
        D_LOG(D_ALWAYS, ("trc_create: memory allocate failed!")); 
        return(TRC_E_NOMEM);
    }
    D_LOG(D_ALWAYS, ("trc_create: trc: 0x%lx", trc));
    NdisZeroMemory(trc, sizeof(*trc));

    /* allocate buffer memory */
    NdisAllocateMemory((PVOID*)&trc->ent_tbl, sizeof(TRC_ENTRY) * depth,
                                                        0, pa);
    if ( !trc->ent_tbl )
        goto mem_alloc_failed;                                         
    D_LOG(D_ALWAYS, ("trc_create: trc->ent_tbl: 0x%lx", trc->ent_tbl));
    NdisZeroMemory(trc->ent_tbl, sizeof(TRC_ENTRY) * depth);
    
    /* setup initial field values */
    trc->stat.state = TRC_ST_STOP;
    trc->stat.filter = TRC_FT_NONE;
    trc->stat.depth = depth;
    
    /* return succ */
    *ret_trc = trc;
	return(TRC_E_SUCC);
}

/* delte a trace object */
INT
trc_destroy(VOID *trc_1)
{
	TRC		*trc = (TRC*)trc_1;
    
    D_LOG(D_ENTRY, ("trc_destroy: entry, trc: 0x%lx", trc));

    /* free memory */
    NdisFreeMemory(trc->ent_tbl, sizeof(TRC_ENTRY) * trc->stat.depth, 0);
    NdisFreeMemory(trc, sizeof(*trc), 0);

    return(TRC_E_SUCC);        
}

/* perform a trace control function */
INT
trc_control(VOID *idd, ULONG op, ULONG arg)
{
    IDD_MSG     msg;
	TRC			*trc;
	INT			ret;


	trc = idd_get_trc(idd);

    D_LOG(D_ENTRY, ("trc_control: idd: 0x%lx trc: 0x%lx, op: 0x%x, arg: 0x%x", idd, trc, op, arg));

    /* branch on opcode */
    switch ( op )
    {
		case TRC_OP_CREATE:
			D_LOG(D_ENTRY, ("trc_control: CreateTrace"));
			// if no trace object for this idd yet
			if (trc == NULL)
			{
				//create trace object
				if ((ret = trc_create(&trc, arg)) != TRC_E_SUCC)
					return(TRC_E_IDD);

				// register trace for this idd
				if ((ret = trc_register_idd (idd)) != TRC_E_SUCC)
				{
					trc_destroy(trc);
					return(TRC_E_IDD);
				}

				idd_set_trc (idd, trc);

				// set ref count
				trc->create_ref = 0;

				// set backpointer
				trc->idd = idd;
			}
			// inc ref count
			trc->create_ref++;
			break;

		case TRC_OP_DESTROY:
			D_LOG(D_ENTRY, ("trc_control: DestroyTrace"));

			// if trc == NULL break;
			CheckNULLTrace (trc);

			// dec ref count
			if (--trc->create_ref)
				break;

			trc_deregister_idd(idd);
			trc_destroy(trc);
			idd_set_trc(idd, NULL);
			break;

        case TRC_OP_RESET :
			D_LOG(D_ENTRY, ("trc_control: ResetTrace"));
			// if trc == NULL break;
			CheckNULLTrace (trc);

            trc->stat.state = TRC_ST_STOP;
            trc->stat.entries = trc->stat.seq_1st = 0;
			trc->ent_put = trc->ent_get = trc->ent_num = trc->ent_seq = 0;
            break;

        case TRC_OP_STOP :
			D_LOG(D_ENTRY, ("trc_control: StopTrace"));
			// if trc == NULL break;
			CheckNULLTrace (trc);

			// check start flag
			if (--trc->start_ref)
				break;

            trc->stat.state = TRC_ST_STOP;

			/* issue idd command to stop trace */
			NdisZeroMemory(&msg, sizeof(msg));
			msg.opcode = CMD_TRC_OFF;
			if ( idd_send_msg((VOID*)arg, &msg, IDD_PORT_CMD_TX, NULL, NULL) != IDD_E_SUCC )
				return(TRC_E_IDD);
            break;

        case TRC_OP_START :
			D_LOG(D_ENTRY, ("trc_control: StartTrace"));
			// if trc == NULL break;
			CheckNULLTrace (trc);

            trc->stat.state = TRC_ST_RUN;

			// check start flag
			if (trc->start_ref++)
				break;


			/* issue idd command to start trace */
			NdisZeroMemory(&msg, sizeof(msg));
			msg.opcode = CMD_TRC_ON;
			if ( idd_send_msg((VOID*)arg, &msg, IDD_PORT_CMD_TX, NULL, NULL) != IDD_E_SUCC )
				return(TRC_E_IDD);
			break;

        case TRC_OP_SET_FILTER :
			D_LOG(D_ENTRY, ("trc_control: SetTraceFilter"));
			// if trc == NULL break;
			CheckNULLTrace (trc);

            trc->stat.filter = arg;
            break;

        default :
            return(TRC_E_PARAM);
    }

    /* if here, was successful */
    return(TRC_E_SUCC);
}

/* get status of a trace context */
INT
trc_get_status(VOID *trc_1, TRC_STATUS *stat)
{
	TRC		*trc = (TRC*)trc_1;

	D_LOG(D_ENTRY, ("trc_get_status: entry, trc: 0x%lx, stat: 0x%lx", trc, stat));

	// if no obect exit
	if (trc == NULL)
		return (TRC_E_NOSUCH);

    *stat = trc->stat;
    stat->entries = trc->ent_num;
    stat->seq_1st = trc->ent_seq;
 
    return(TRC_E_SUCC);
}

/* get an entry by sequence number */
INT
trc_get_entry(VOID *trc_1, ULONG seq, TRC_ENTRY *ent)
{
	TRC		*trc = (TRC*)trc_1;
    ULONG     n, index;
    
    D_LOG(D_ENTRY, ("trc_get_entry: entry, trc: 0x%lx, seq: %ld, ent: 0x%lx", \
                                trc, seq, ent));

	// if no obect exit
	if (trc == NULL)
		return(TRC_E_NOSUCH);

    /* find requested sequence number, temp!!!, using search! */
    for ( n = 0 ; n < trc->ent_num ; n++ )
    {
        index = (trc->ent_get + n) % trc->stat.depth;
        if ( trc->ent_tbl[index].seq == seq )
        {
            /* found */
            *ent = trc->ent_tbl[index];
            return(TRC_E_SUCC);
        }
    }
    /* if here not found */
    return(TRC_E_NOSUCH);
}

/* handler for trace and dump area data packets */
VOID
trc__cmd_handler(VOID *idd_1, USHORT chan, ULONG Reserved, IDD_MSG *msg)
{
    TRC         *trc;
    TRC_ENTRY   *ent;
	IDD	*idd = (IDD*)idd_1;


	D_LOG(D_ENTRY, ("trc__cmd_handler: idd: %lx, chan: %d, msg: %lx", \
								idd, chan, msg));
	D_LOG(D_ENTRY, ("trc__cmd_handler: opcode: 0x%x, buflen: 0x%x, bufptr: %lx", \
						msg->opcode, msg->buflen, msg->bufptr));
	D_LOG(D_ENTRY, ("trc__cmd_handler: bufid: %lx, param: 0x%x", \
						msg->bufid, msg->param));


	// Get the trace object for this idd
	trc = idd_get_trc(idd);

	// if no obect exit
	if (trc == NULL || msg->bufid >= 2)
		return;

    /* if here it is a trace frame. param is rx/tx attribute */
    /* establish entry to insert into & update vars */

	/* check if trace enabled */
	if ( trc->stat.state == TRC_ST_STOP )
		return;

	D_LOG(D_ALWAYS, ("trc__cmd_handler: trc: %lx", trc));
	/* check if frame filters in */
	if ( !trc__filter(trc->stat.filter, msg->bufptr, msg->buflen) )
		return;

	/* frames needs to be buffered, establish entry pointer */
	ent = trc->ent_tbl + trc->ent_put;
	trc->ent_put = (trc->ent_put + 1) % trc->stat.depth;
	if ( trc->ent_num < trc->stat.depth )
		trc->ent_num++;

	/* fill up entry */
	ent->seq = trc->ent_seq++;
	KeQuerySystemTime(&ent->time_stamp);
	ent->attr = msg->bufid;
	ent->org_len = msg->buflen;
	ent->len = MIN(msg->buflen, sizeof(ent->data));
	IddGetDataFromAdapter(idd,
	                      (PUCHAR)ent->data,
						  (PUCHAR)msg->bufptr,
						  (USHORT)ent->len);
//	NdisMoveMemory (ent->data, msg->bufptr, ent->len);
}

/* filter trace frame */
INT
trc__filter(ULONG filter, CHAR *buf, ULONG len)
{
    D_LOG(D_ENTRY, ("trc__filter: entry, filter: %ld, buf: 0x%lx, len: %ld",\
                                filter, buf, len));

    /* not implemented, all frames filter in */
    return(1);
}