/*
 * CM_CONN.C - connection managment code
 */

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

/* mark connection as ready to accept calls (listening mode) */
INT
cm_listen(VOID *cm_1)
{
	CM		*cm = (CM*)cm_1;
    D_LOG(D_ENTRY, ("cm_listen: entry, cm: 0x%lx", cm));

    /* connection must be idle */
    if ( cm->state != CM_ST_IDLE )
        return(CM_E_BUSY);

    /* mark & return */
    cm->dprof = cm->oprof;
    cm->state = CM_ST_LISTEN;
	cm->StateChangeFlag = TRUE;
    cm->PPPToDKF = 0;
    return(CM_E_SUCC);
}

/* initiate a connection */
INT
cm_connect(VOID *cm_1)
{
#define     ABORT(_ret)     { ret = _ret; goto aborting; }
	CM		*cm = (CM*)cm_1;
    ULONG   n;
    INT     ret = CM_E_SUCC;

    D_LOG(D_ENTRY, ("cm_connect: entry, cm: 0x%lx", cm));

    /* connection must be idle or listening */
    if ( (cm->state != CM_ST_IDLE) && (cm->state != CM_ST_LISTEN) )
        return(CM_E_BUSY);

    /* switch connection state to waiting for activation for now */
    cm->state = CM_ST_WAIT_ACT;
	cm->StateChangeFlag = TRUE;

    /* copy original profile to dynamic */
    cm->dprof = cm->oprof;


    /* initialize other fields */
    cm->was_listen = 0;
    cm->active_chan_num = 0;
    cm->speed = 0;
    cm->rx_last_frame_time = cm->tx_last_frame_time = ut_time_now();
    cm->timeout = cm->rx_last_frame_time;
    cm->remote_conn_index = 0xff;
	cm->CauseValue = 0x7F;
	cm->SignalValue = 0xFF;
	cm->NoActiveLine = 0;
	cm->PPPToDKF = 0;
    NdisZeroMemory(cm->DstAddr, sizeof(cm->DstAddr));
    NdisZeroMemory(cm->remote_name, sizeof(cm->remote_name));

    /* init & check channel vector */
    for ( n = 0 ; n < cm->dprof.chan_num ; n++ )
    {
        CM_CHAN     *chan = cm->dprof.chan_tbl + n;

        /* assign index */
        chan->num = (USHORT)n;
        chan->cm = cm;
        chan->ustate = 0;
        chan->active = 0;
        chan->gave_up = 0;

        /* if connection is nailed, channal must be explicit */
        if ( cm->dprof.nailed && !CM_BCHAN_ASSIGNED(chan->bchan) )
            ABORT(CM_E_BADCHAN);
    }

    /* if connection is to be activated by frame, exit here */
    if ( cm->dprof.frame_activated )
        return(CM_E_SUCC);

    /* if here, connection has to be activated now! */
    cm->state = CM_ST_IN_ACT;
	cm->StateChangeFlag = TRUE;
    if ( (ret = cm__initiate_conn(cm)) == CM_E_SUCC )
        return(CM_E_SUCC);

    /* if here, aborting connection */
    aborting:
    cm->state = CM_ST_IDLE;
	cm->StateChangeFlag = TRUE;
    return(ret);
}

/* disconnect a connection, back to idle state */
INT
cm_disconnect(VOID *cm_1)
{
	CM		*cm = (CM*)cm_1;
    ULONG    n;

    D_LOG(D_ENTRY, ("cm_disconnect: entry, cm: 0x%lx", cm));

    /* branch on connection state */
    switch ( cm->state )
    {
        case CM_ST_IDLE :               /* already idle, do nothing */
        default :
            break;

        case CM_ST_LISTEN :             /* waiting for a connection, cancel */
        case CM_ST_WAIT_ACT :           /* waiting for activation, cancel */
        case CM_ST_DEACT :              /* deactivated, cancel */
            cm->state = CM_ST_IDLE;
			cm->StateChangeFlag = TRUE;
            break;

        case CM_ST_IN_ACT :             /* in activation */
        case CM_ST_IN_SYNC :            /* syncronizing */
        case CM_ST_ACTIVE :             /* is active */
        case CM_ST_IN_ANS :             /* in answering process */

            /* scan channel, issue a disconnect */
            for ( n = 0 ; n < cm->dprof.chan_num ; n++)
            {
                CM_CHAN         *chan = cm->dprof.chan_tbl + n;

                /* check is channel is used in this connection */
                if ( chan->gave_up || !chan->ustate )
                    continue;

                /* disconnect it */
                cm__disc_rq(chan);
                chan->cid = 0;
            }

            /* deactivate connection (not by idle timer) */
            cm__deactivate_conn(cm, 0);
            break;
    }

    return(CM_E_SUCC);
}

/* initiate a connection waiting for activation */
INT
cm__initiate_conn(CM *cm)
{
    ULONG     n;

   D_LOG(D_ENTRY|DIGIQ931, ("cm__initiate_conn: entry, cm: 0x%lx\n", cm));

    /* if connection is nailed, handle here */
    if ( cm->dprof.nailed )
        return(cm__activate_conn(cm, cm->dprof.HWCompression));

    /* if here, connection is on demand, initate call setup on all chans */
    for ( n = 0 ; n < cm->dprof.chan_num ; n++)
    {
        CM_CHAN         *chan = cm->dprof.chan_tbl + n;
        USHORT          my_cid = MAKEWORD(chan->num, cm->local_conn_index);

        chan->cid = my_cid;
        chan->ustate = CM_US_WAIT_CID;
        chan->timeout = ut_time_now();


        cm__est_rq(chan);

    }

    return(CM_E_SUCC);
}

/* activate a connection */
INT
cm__activate_conn(CM *cm, ULONG CompressionFlag)
{
    ULONG   n;

    D_LOG(D_ENTRY, ("cm__activate_conn: entry, cm: 0x%lx", cm));

    /* mark change of state & time */
    cm->state = CM_ST_ACTIVE;
	cm->StateChangeFlag = TRUE;
    cm->rx_last_frame_time = cm->tx_last_frame_time = cm->timeout = ut_time_now();

    /* scan active channel, notify mtl, etc. */
    cm->active_chan_num = 0;
    for ( n = 0 ; n < cm->dprof.chan_num ; n++)
    {
        CM_CHAN         *chan = cm->dprof.chan_tbl + n;

        /* check is channel is used in this connection */
        if ( chan->gave_up )
            continue;

		// Give Compression command for this channel
		cm__bchan_ctrl_comp(chan, CompressionFlag);

        /* turn channel on (may be redundant in demand connections */
        cm__bchan_ctrl(chan, 1);

        /* notify mtl of channel */
        mtl_add_chan(cm->mtl,
		             chan->idd,
					 chan->bchan,
					 chan->speed,
					 cm->ConnectionType);

        /* accumulate */
        cm->active_chan_num++;
    }


    /* get speed from mtl, tell mtl is connected now! */
    mtl_get_conn_speed(cm->mtl, &cm->speed);

    return(CM_E_SUCC);
}

/* deactivate a connection */
INT
cm__deactivate_conn(CM *cm, BOOL by_idle_timer)
{
    ULONG   n;

    D_LOG(D_ENTRY, ("cm__deactivate_conn: entry, cm: 0x%lx", cm));

//	DbgPrint ("DeactivateConn\n");
    /* mark change of state & time */
    cm->state = CM_ST_DEACT;
	cm->StateChangeFlag = TRUE;
    cm->rx_last_frame_time = cm->tx_last_frame_time = cm->timeout = ut_time_now();

    /* tell mtl not connected now */
    mtl_set_conn_state(cm->mtl, cm->dprof.chan_num, 0);

    /* scan active channel, notify mtl, etc. */
    for ( n = 0 ; n < cm->dprof.chan_num ; n++)
    {
        CM_CHAN         *chan = cm->dprof.chan_tbl + n;

        /* check is channel is used in this connection */
        if ( chan->gave_up )
            continue;

        /* turn channel off */
        cm__bchan_ctrl(chan, 0);

        /* notify mtl of channel */
        mtl_del_chan(cm->mtl, chan->idd, chan->bchan);

        /* clear channel state */
        chan->ustate = 0;
        chan->active = 0;
    }

    /* if connection originated as listening, back to idle here */
    if ( cm->was_listen )
    {
        make_idle:
        cm->state = CM_ST_IDLE;
		cm->StateChangeFlag = TRUE;
        return(CM_E_SUCC);
    }

    /* if connection is not persistant, back to idle */
    if ( !cm->dprof.persist )
        goto make_idle;

    /* if deactivate not by idle timer, back to idle */
    if ( !by_idle_timer )
        goto make_idle;

    /* if here, connection reverts to waiting for activation */
    cm->state = CM_ST_WAIT_ACT;
	cm->StateChangeFlag = TRUE;
    return(CM_E_SUCC);
}

/* calc next channel, not implemented yet */
INT
cm__get_next_chan(CM_CHAN *chan)
{
	CM		*cm = (CM*)chan->cm;

	/* restore modified fields */
	chan->bchan = cm->oprof.chan_tbl[chan->num].bchan;

	/* step to next channel type */
	switch ( chan->type )
	{
		case CM_CT_D64 :
			chan->type = CM_CT_D56;
			break;

		case CM_CT_D56 :
			chan->type = CM_CT_VOICE;
			break;

		case CM_CT_VOICE :
		default:
			return(CM_E_NOSUCH);
	}

   /* if here, succ */
   return(CM_E_SUCC);
}