staging: wlags49_h2: Fix macro termination
Semi-colon terminate various macros (HCFASSERT, IF_PROT_TIME, IF_DMA, PROT_CNT_INI, HCFLOGENTRY, HCFLOGEXIT, DAWA_ACK, DAWA_ZERO_FID) so auto-indent will work correctly. Add appropriate do {} while protection to the macros. Signed-off-by: David Kilroy <kilroyd@googlemail.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
parent
fe4d275594
commit
788c2bce7e
|
@ -703,19 +703,19 @@ hcf_action( IFBP ifbp, hcf_16 action )
|
|||
{
|
||||
int rc = HCF_SUCCESS;
|
||||
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic )
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic );
|
||||
#if HCF_INT_ON
|
||||
HCFLOGENTRY( action == HCF_ACT_INT_FORCE_ON ? HCF_TRACE_ACTION_KLUDGE : HCF_TRACE_ACTION, action ) /* 0 */
|
||||
HCFLOGENTRY( action == HCF_ACT_INT_FORCE_ON ? HCF_TRACE_ACTION_KLUDGE : HCF_TRACE_ACTION, action ); /* 0 */
|
||||
#if (HCF_SLEEP)
|
||||
HCFASSERT( ifbp->IFB_IntOffCnt != 0xFFFE || action == HCF_ACT_INT_OFF,
|
||||
MERGE_2( action, ifbp->IFB_IntOffCnt ) )
|
||||
MERGE_2( action, ifbp->IFB_IntOffCnt ) );
|
||||
#else
|
||||
HCFASSERT( ifbp->IFB_IntOffCnt != 0xFFFE, action )
|
||||
HCFASSERT( ifbp->IFB_IntOffCnt != 0xFFFE, action );
|
||||
#endif // HCF_SLEEP
|
||||
HCFASSERT( ifbp->IFB_IntOffCnt != 0xFFFF ||
|
||||
action == HCF_ACT_INT_OFF || action == HCF_ACT_INT_FORCE_ON, action )
|
||||
action == HCF_ACT_INT_OFF || action == HCF_ACT_INT_FORCE_ON, action );
|
||||
HCFASSERT( ifbp->IFB_IntOffCnt <= 16 || ifbp->IFB_IntOffCnt >= 0xFFFE,
|
||||
MERGE_2( action, ifbp->IFB_IntOffCnt ) ) //nesting more than 16 deep seems unreasonable
|
||||
MERGE_2( action, ifbp->IFB_IntOffCnt ) ); //nesting more than 16 deep seems unreasonable
|
||||
#endif // HCF_INT_ON
|
||||
|
||||
switch (action) {
|
||||
|
@ -789,7 +789,7 @@ hcf_16 i;
|
|||
cmd_exe( ifbp, HCMD_SLEEP, 0 );
|
||||
break;
|
||||
// case HCF_ACT_WAKEUP: // DDS Wakeup request
|
||||
// HCFASSERT( ifbp->IFB_IntOffCnt == 0xFFFE, ifbp->IFB_IntOffCnt )
|
||||
// HCFASSERT( ifbp->IFB_IntOffCnt == 0xFFFE, ifbp->IFB_IntOffCnt );
|
||||
// ifbp->IFB_IntOffCnt++; // restore conventional I/F
|
||||
// OPW( HREG_IO, HREG_IO_WAKEUP_ASYNC );
|
||||
// MSF_WAIT(800); // MSF-defined function to wait n microseconds.
|
||||
|
@ -828,11 +828,11 @@ hcf_16 i;
|
|||
break;
|
||||
|
||||
default:
|
||||
HCFASSERT( DO_ASSERT, action )
|
||||
HCFASSERT( DO_ASSERT, action );
|
||||
break;
|
||||
}
|
||||
//! do not HCFASSERT( rc == HCF_SUCCESS, rc ) /* 30*/
|
||||
HCFLOGEXIT( HCF_TRACE_ACTION )
|
||||
HCFLOGEXIT( HCF_TRACE_ACTION );
|
||||
return rc;
|
||||
} // hcf_action
|
||||
#endif // HCF_DL_ONLY
|
||||
|
@ -959,13 +959,13 @@ int rc = HCF_ERR_INCOMP_FW;
|
|||
x &= ~HFS_TX_CNTL_PORT;
|
||||
}
|
||||
HCFASSERT( x==HCF_CNTL_ENABLE || x==HCF_CNTL_DISABLE || HCF_CNTL_CONTINUE ||
|
||||
x==HCF_CNTL_CONNECT || x==HCF_CNTL_DISCONNECT, cmd )
|
||||
x==HCF_CNTL_CONNECT || x==HCF_CNTL_DISCONNECT, cmd );
|
||||
}
|
||||
#endif // HCF_ASSERT
|
||||
// #if (HCF_SLEEP) & HCF_DDS
|
||||
// HCFASSERT( ifbp->IFB_IntOffCnt != 0xFFFE, cmd )
|
||||
// HCFASSERT( ifbp->IFB_IntOffCnt != 0xFFFE, cmd );
|
||||
// #endif // HCF_DDS
|
||||
HCFLOGENTRY( HCF_TRACE_CNTL, cmd )
|
||||
HCFLOGENTRY( HCF_TRACE_CNTL, cmd );
|
||||
if ( ifbp->IFB_CardStat == 0 ) { /*2*/
|
||||
/*6*/ rc = cmd_exe( ifbp, cmd, 0 );
|
||||
#if (HCF_SLEEP) & HCF_DDS
|
||||
|
@ -989,12 +989,12 @@ int rc = HCF_ERR_INCOMP_FW;
|
|||
* as additional beneficiary side effect, the SOP and EOP bits will also be cleared
|
||||
*/
|
||||
ifbp->IFB_CntlOpt |= DMA_ENABLED;
|
||||
HCFASSERT( NT_ASSERT, NEVER_TESTED )
|
||||
HCFASSERT( NT_ASSERT, NEVER_TESTED );
|
||||
// make the entire rx descriptor chain DMA-owned, so the DMA engine can (re-)use it.
|
||||
p = ifbp->IFB_FirstDesc[DMA_RX];
|
||||
if (p != NULL) { //;? Think this over again in the light of the new chaining strategy
|
||||
if ( 1 ) { //begin alternative
|
||||
HCFASSERT( NT_ASSERT, NEVER_TESTED )
|
||||
HCFASSERT( NT_ASSERT, NEVER_TESTED );
|
||||
put_frame_lst( ifbp, ifbp->IFB_FirstDesc[DMA_RX], DMA_RX );
|
||||
if ( ifbp->IFB_FirstDesc[DMA_RX] ) {
|
||||
put_frame_lst( ifbp, ifbp->IFB_FirstDesc[DMA_RX]->next_desc_addr, DMA_RX );
|
||||
|
@ -1013,8 +1013,8 @@ int rc = HCF_ERR_INCOMP_FW;
|
|||
}
|
||||
}
|
||||
#endif // HCF_DMA
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc )
|
||||
HCFLOGEXIT( HCF_TRACE_CNTL )
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc );
|
||||
HCFLOGEXIT( HCF_TRACE_CNTL );
|
||||
return rc;
|
||||
} // hcf_cntl
|
||||
|
||||
|
@ -1217,19 +1217,19 @@ LTV_STRCT x;
|
|||
ifbp->IFB_AssertStrct.frag_buf[0].frag_addr = &ifbp->IFB_AssertLine;
|
||||
#endif // HCF_ASSERT_MB
|
||||
#endif // HCF_ASSERT
|
||||
IF_PROT_TIME( prot_cnt = ifbp->IFB_TickIni = INI_TICK_INI; )
|
||||
IF_PROT_TIME( prot_cnt = ifbp->IFB_TickIni = INI_TICK_INI );
|
||||
#if ( (HCF_TYPE) & HCF_TYPE_PRELOADED ) == 0
|
||||
//!! No asserts before Reset-bit in HREG_IO is cleared
|
||||
OPW( HREG_IO, 0x0000 ); //OPW useable /* 2b*/
|
||||
HCF_WAIT_WHILE( (IPW( HREG_EV_STAT) & HREG_EV_CMD) == 0 );
|
||||
IF_PROT_TIME( HCFASSERT( prot_cnt, IPW( HREG_EV_STAT) ) )
|
||||
IF_PROT_TIME( if ( prot_cnt ) prot_cnt = ifbp->IFB_TickIni; )
|
||||
IF_PROT_TIME( HCFASSERT( prot_cnt, IPW( HREG_EV_STAT) ) );
|
||||
IF_PROT_TIME( if ( prot_cnt ) prot_cnt = ifbp->IFB_TickIni );
|
||||
#endif // HCF_TYPE_PRELOADED
|
||||
//!! No asserts before Reset-bit in HREG_IO is cleared
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( HCF_ASSERT, 0xCAF0 ) ) //just to proof that the complete assert machinery is working
|
||||
HCFASSERT( xa != CFG_FW_IDENTITY, 0 ) // assert if hcf_connect is called without intervening hcf_disconnect.
|
||||
HCFASSERT( ((hcf_32)(void*)ifbp & (HCF_ALIGN-1) ) == 0, (hcf_32)(void*)ifbp )
|
||||
HCFASSERT( (io_addr & 0x003F) == 0, io_addr )
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( HCF_ASSERT, 0xCAF0 ) ); //just to proof that the complete assert machinery is working
|
||||
HCFASSERT( xa != CFG_FW_IDENTITY, 0 ); // assert if hcf_connect is called without intervening hcf_disconnect.
|
||||
HCFASSERT( ((hcf_32)(void*)ifbp & (HCF_ALIGN-1) ) == 0, (hcf_32)(void*)ifbp );
|
||||
HCFASSERT( (io_addr & 0x003F) == 0, io_addr );
|
||||
//if Busy bit in Cmd register
|
||||
if (IPW( HREG_CMD ) & HCMD_BUSY ) { /* 8 */
|
||||
//. Ack all to unblock a (possibly) blocked cmd pipe line
|
||||
|
@ -1237,7 +1237,7 @@ LTV_STRCT x;
|
|||
//. Wait for Busy bit drop in Cmd register
|
||||
//. Wait for Cmd bit raise in Ev register
|
||||
HCF_WAIT_WHILE( ( IPW( HREG_CMD ) & HCMD_BUSY ) && (IPW( HREG_EV_STAT) & HREG_EV_CMD) == 0 );
|
||||
IF_PROT_TIME( HCFASSERT( prot_cnt, IPW( HREG_EV_STAT) ) ) /* if prot_cnt == 0, cmd_exe will fail, causing DEFUNCT */
|
||||
IF_PROT_TIME( HCFASSERT( prot_cnt, IPW( HREG_EV_STAT) ) ); /* if prot_cnt == 0, cmd_exe will fail, causing DEFUNCT */
|
||||
}
|
||||
OPW( HREG_EV_ACK, ~HREG_EV_SLEEP_REQ );
|
||||
#if ( (HCF_TYPE) & HCF_TYPE_PRELOADED ) == 0 /*12*/
|
||||
|
@ -1307,7 +1307,7 @@ get_frame_lst( IFBP ifbp, int tx_rx_flag )
|
|||
DESC_STRCT *head = ifbp->IFB_FirstDesc[tx_rx_flag];
|
||||
DESC_STRCT *copy, *p, *prev;
|
||||
|
||||
HCFASSERT( tx_rx_flag == DMA_RX || tx_rx_flag == DMA_TX, tx_rx_flag )
|
||||
HCFASSERT( tx_rx_flag == DMA_RX || tx_rx_flag == DMA_TX, tx_rx_flag );
|
||||
//if FrameList
|
||||
if ( head ) {
|
||||
//. search for last descriptor of first FrameList
|
||||
|
@ -1407,27 +1407,27 @@ put_frame_lst( IFBP ifbp, DESC_STRCT *descp, int tx_rx_flag )
|
|||
DESC_STRCT *p = descp;
|
||||
hcf_16 port;
|
||||
|
||||
HCFASSERT( ifbp->IFB_CntlOpt & USE_DMA, ifbp->IFB_CntlOpt) //only hcf_dma_tx_put must also be DMA_ENABLED
|
||||
HCFASSERT( tx_rx_flag == DMA_RX || tx_rx_flag == DMA_TX, tx_rx_flag )
|
||||
HCFASSERT( p , 0 )
|
||||
HCFASSERT( ifbp->IFB_CntlOpt & USE_DMA, ifbp->IFB_CntlOpt); //only hcf_dma_tx_put must also be DMA_ENABLED
|
||||
HCFASSERT( tx_rx_flag == DMA_RX || tx_rx_flag == DMA_TX, tx_rx_flag );
|
||||
HCFASSERT( p , 0 );
|
||||
|
||||
while ( p ) {
|
||||
HCFASSERT( ((hcf_32)p & 3 ) == 0, (hcf_32)p )
|
||||
HCFASSERT( (p->BUF_CNT & ~DESC_CNT_MASK) == 0, p->BUF_CNT )
|
||||
HCFASSERT( (p->BUF_SIZE & ~DESC_CNT_MASK) == 0, p->BUF_SIZE )
|
||||
HCFASSERT( ((hcf_32)p & 3 ) == 0, (hcf_32)p );
|
||||
HCFASSERT( (p->BUF_CNT & ~DESC_CNT_MASK) == 0, p->BUF_CNT );
|
||||
HCFASSERT( (p->BUF_SIZE & ~DESC_CNT_MASK) == 0, p->BUF_SIZE );
|
||||
p->BUF_SIZE &= DESC_CNT_MASK; //!!this SHOULD be superfluous in case of correct MSF
|
||||
p->BUF_CNT &= tx_rx_flag == DMA_RX ? 0 : DESC_CNT_MASK; //!!this SHOULD be superfluous in case of correct MSF
|
||||
p->BUF_CNT |= DESC_DMA_OWNED;
|
||||
if ( p->next_desc_addr ) {
|
||||
// HCFASSERT( p->buf_addr && p->buf_phys_addr && p->BUF_SIZE && +/- p->BUF_SIZE, ... )
|
||||
HCFASSERT( p->next_desc_addr->desc_phys_addr, (hcf_32)p->next_desc_addr )
|
||||
// HCFASSERT( p->buf_addr && p->buf_phys_addr && p->BUF_SIZE && +/- p->BUF_SIZE, ... );
|
||||
HCFASSERT( p->next_desc_addr->desc_phys_addr, (hcf_32)p->next_desc_addr );
|
||||
p->next_desc_phys_addr = p->next_desc_addr->desc_phys_addr;
|
||||
} else { //
|
||||
p->next_desc_phys_addr = 0;
|
||||
if ( p->buf_addr == NULL ) { // DELWA Descriptor
|
||||
HCFASSERT( descp == p, (hcf_32)descp ) //singleton DescriptorList
|
||||
HCFASSERT( ifbp->IFB_FirstDesc[tx_rx_flag] == NULL, (hcf_32)ifbp->IFB_FirstDesc[tx_rx_flag])
|
||||
HCFASSERT( ifbp->IFB_LastDesc[tx_rx_flag] == NULL, (hcf_32)ifbp->IFB_LastDesc[tx_rx_flag])
|
||||
HCFASSERT( descp == p, (hcf_32)descp ); //singleton DescriptorList
|
||||
HCFASSERT( ifbp->IFB_FirstDesc[tx_rx_flag] == NULL, (hcf_32)ifbp->IFB_FirstDesc[tx_rx_flag]);
|
||||
HCFASSERT( ifbp->IFB_LastDesc[tx_rx_flag] == NULL, (hcf_32)ifbp->IFB_LastDesc[tx_rx_flag]);
|
||||
descp->BUF_CNT = 0; //&= ~DESC_DMA_OWNED;
|
||||
ifbp->IFB_FirstDesc[tx_rx_flag] = descp;
|
||||
// part of alternative ifbp->IFB_LastDesc[tx_rx_flag] = ifbp->IFB_FirstDesc[tx_rx_flag] = descp;
|
||||
|
@ -1436,10 +1436,10 @@ put_frame_lst( IFBP ifbp, DESC_STRCT *descp, int tx_rx_flag )
|
|||
// . prepare for activation DMA controller
|
||||
// part of alternative descp = descp->next_desc_addr;
|
||||
} else { //a "real" FrameList, hand it over to the DMA engine
|
||||
HCFASSERT( ifbp->IFB_FirstDesc[tx_rx_flag], (hcf_32)descp )
|
||||
HCFASSERT( ifbp->IFB_LastDesc[tx_rx_flag], (hcf_32)descp )
|
||||
HCFASSERT( ifbp->IFB_FirstDesc[tx_rx_flag], (hcf_32)descp );
|
||||
HCFASSERT( ifbp->IFB_LastDesc[tx_rx_flag], (hcf_32)descp );
|
||||
HCFASSERT( ifbp->IFB_LastDesc[tx_rx_flag]->next_desc_addr == NULL,
|
||||
(hcf_32)ifbp->IFB_LastDesc[tx_rx_flag]->next_desc_addr)
|
||||
(hcf_32)ifbp->IFB_LastDesc[tx_rx_flag]->next_desc_addr);
|
||||
// p->buf_cntl.cntl_stat |= DESC_DMA_OWNED;
|
||||
ifbp->IFB_LastDesc[tx_rx_flag]->next_desc_addr = descp;
|
||||
ifbp->IFB_LastDesc[tx_rx_flag]->next_desc_phys_addr = descp->desc_phys_addr;
|
||||
|
@ -1522,16 +1522,16 @@ DESC_STRCT *descp; // pointer to start of FrameList
|
|||
{
|
||||
int i;
|
||||
DESC_STRCT *p = descp->next_desc_addr; //pointer to 2nd descriptor of frame
|
||||
HCFASSERT(p, 0)
|
||||
HCFASSERT(p, 0);
|
||||
// The 2nd descriptor contains (maybe) a SNAP header plus part or whole of the payload.
|
||||
//determine decapsulation sub-flag in RxFS
|
||||
i = *(wci_recordp)&descp->buf_addr[HFS_STAT] & ( HFS_STAT_MSG_TYPE | HFS_STAT_ERR );
|
||||
if ( i == HFS_STAT_TUNNEL ||
|
||||
( i == HFS_STAT_1042 && hcf_encap( (wci_bufp)&p->buf_addr[HCF_DASA_SIZE] ) != ENC_TUNNEL )) {
|
||||
// The 2nd descriptor contains a SNAP header plus part or whole of the payload.
|
||||
HCFASSERT( p->BUF_CNT == (p->buf_addr[5] + (p->buf_addr[4]<<8) + 2*6 + 2 - 8), p->BUF_CNT )
|
||||
HCFASSERT( p->BUF_CNT == (p->buf_addr[5] + (p->buf_addr[4]<<8) + 2*6 + 2 - 8), p->BUF_CNT );
|
||||
// perform decapsulation
|
||||
HCFASSERT(p->BUF_SIZE >=8, p->BUF_SIZE)
|
||||
HCFASSERT(p->BUF_SIZE >=8, p->BUF_SIZE);
|
||||
// move SA[2:5] in the second buffer to replace part of the SNAP header
|
||||
for ( i=3; i >= 0; i--) p->buf_addr[i+8] = p->buf_addr[i];
|
||||
// copy DA[0:5], SA[0:1] from first buffer to second buffer
|
||||
|
@ -1542,7 +1542,7 @@ DESC_STRCT *p = descp->next_desc_addr; //pointer to 2nd descriptor of frame
|
|||
}
|
||||
#endif // HCF_ENC
|
||||
if ( descp == NULL ) ifbp->IFB_DmaPackets &= (hcf_16)~HREG_EV_RDMAD; //;?could be integrated into get_frame_lst
|
||||
HCFLOGEXIT( HCF_TRACE_DMA_RX_GET )
|
||||
HCFLOGEXIT( HCF_TRACE_DMA_RX_GET );
|
||||
return descp;
|
||||
} // hcf_dma_rx_get
|
||||
|
||||
|
@ -1596,20 +1596,20 @@ void
|
|||
hcf_dma_rx_put( IFBP ifbp, DESC_STRCT *descp )
|
||||
{
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_DMA_RX_PUT, 0xDA01 )
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic )
|
||||
HCFASSERT_INT
|
||||
HCFLOGENTRY( HCF_TRACE_DMA_RX_PUT, 0xDA01 );
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic );
|
||||
HCFASSERT_INT;
|
||||
|
||||
put_frame_lst( ifbp, descp, DMA_RX );
|
||||
#if HCF_ASSERT && (HCF_ENCAP) == HCF_ENC
|
||||
if ( descp->buf_addr ) {
|
||||
HCFASSERT( descp->BUF_SIZE == HCF_DMA_RX_BUF1_SIZE, descp->BUF_SIZE )
|
||||
HCFASSERT( descp->next_desc_addr, 0 ) // first descriptor should be followed by another descriptor
|
||||
HCFASSERT( descp->BUF_SIZE == HCF_DMA_RX_BUF1_SIZE, descp->BUF_SIZE );
|
||||
HCFASSERT( descp->next_desc_addr, 0 ); // first descriptor should be followed by another descriptor
|
||||
// The second DB is for SNAP and payload purposes. It should be a minimum of 12 bytes in size.
|
||||
HCFASSERT( descp->next_desc_addr->BUF_SIZE >= 12, descp->next_desc_addr->BUF_SIZE )
|
||||
HCFASSERT( descp->next_desc_addr->BUF_SIZE >= 12, descp->next_desc_addr->BUF_SIZE );
|
||||
}
|
||||
#endif // HCFASSERT / HCF_ENC
|
||||
HCFLOGEXIT( HCF_TRACE_DMA_RX_PUT )
|
||||
HCFLOGEXIT( HCF_TRACE_DMA_RX_PUT );
|
||||
} // hcf_dma_rx_put
|
||||
|
||||
|
||||
|
@ -1660,7 +1660,7 @@ DESC_STRCT *descp; // pointer to start of FrameList
|
|||
if ( descp == NULL ) { //;?could be integrated into get_frame_lst
|
||||
ifbp->IFB_DmaPackets &= (hcf_16)~HREG_EV_TDMAD;
|
||||
}
|
||||
HCFLOGEXIT( HCF_TRACE_DMA_TX_GET )
|
||||
HCFLOGEXIT( HCF_TRACE_DMA_TX_GET );
|
||||
return descp;
|
||||
} // hcf_dma_tx_get
|
||||
|
||||
|
@ -1788,19 +1788,19 @@ int i;
|
|||
|
||||
#if HCF_ASSERT
|
||||
int x = ifbp->IFB_FWIdentity.comp_id == COMP_ID_FW_AP ? tx_cntl & ~HFS_TX_CNTL_PORT : tx_cntl;
|
||||
HCFASSERT( (x & ~HCF_TX_CNTL_MASK ) == 0, tx_cntl )
|
||||
HCFASSERT( (x & ~HCF_TX_CNTL_MASK ) == 0, tx_cntl );
|
||||
#endif // HCF_ASSERT
|
||||
HCFLOGENTRY( HCF_TRACE_DMA_TX_PUT, 0xDA03 )
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic )
|
||||
HCFASSERT_INT
|
||||
HCFASSERT( ( ifbp->IFB_CntlOpt & (USE_DMA|DMA_ENABLED) ) == (USE_DMA|DMA_ENABLED), ifbp->IFB_CntlOpt)
|
||||
HCFLOGENTRY( HCF_TRACE_DMA_TX_PUT, 0xDA03 );
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic );
|
||||
HCFASSERT_INT;
|
||||
HCFASSERT( ( ifbp->IFB_CntlOpt & (USE_DMA|DMA_ENABLED) ) == (USE_DMA|DMA_ENABLED), ifbp->IFB_CntlOpt);
|
||||
|
||||
if ( descp->buf_addr ) {
|
||||
*(hcf_16*)(descp->buf_addr + HFS_TX_CNTL) = tx_cntl; /*1*/
|
||||
#if (HCF_ENCAP) == HCF_ENC
|
||||
HCFASSERT( descp->next_desc_addr, 0 ) //at least 2 descripors
|
||||
HCFASSERT( descp->BUF_CNT == HFS_ADDR_DEST, descp->BUF_CNT ) //exact length required for 1st buffer
|
||||
HCFASSERT( descp->BUF_SIZE >= HCF_DMA_TX_BUF1_SIZE, descp->BUF_SIZE ) //minimal storage for encapsulation
|
||||
HCFASSERT( descp->next_desc_addr, 0 ); //at least 2 descripors
|
||||
HCFASSERT( descp->BUF_CNT == HFS_ADDR_DEST, descp->BUF_CNT ); //exact length required for 1st buffer
|
||||
HCFASSERT( descp->BUF_SIZE >= HCF_DMA_TX_BUF1_SIZE, descp->BUF_SIZE ); //minimal storage for encapsulation
|
||||
HCFASSERT( p->BUF_CNT >= 14, p->BUF_CNT ); //at least DA, SA and 'type' in 2nd buffer
|
||||
|
||||
#if (HCF_TYPE) & HCF_TYPE_CCX
|
||||
|
@ -1850,7 +1850,7 @@ int i;
|
|||
#endif // HCF_ENC
|
||||
}
|
||||
put_frame_lst( ifbp, descp, DMA_TX );
|
||||
HCFLOGEXIT( HCF_TRACE_DMA_TX_PUT )
|
||||
HCFLOGEXIT( HCF_TRACE_DMA_TX_PUT );
|
||||
} // hcf_dma_tx_put
|
||||
|
||||
#endif // HCF_DMA
|
||||
|
@ -2035,11 +2035,11 @@ hcf_16 *q = NULL; /* source word pointer Note!! DOS COM can't cope with FAR
|
|||
*/
|
||||
int i;
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_GET_INFO, ltvp->typ )
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic )
|
||||
HCFASSERT_INT
|
||||
HCFASSERT( ltvp, 0 )
|
||||
HCFASSERT( 1 < ltvp->len && ltvp->len <= HCF_MAX_LTV + 1, MERGE_2( ltvp->typ, ltvp->len ) )
|
||||
HCFLOGENTRY( HCF_TRACE_GET_INFO, ltvp->typ );
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic );
|
||||
HCFASSERT_INT;
|
||||
HCFASSERT( ltvp, 0 );
|
||||
HCFASSERT( 1 < ltvp->len && ltvp->len <= HCF_MAX_LTV + 1, MERGE_2( ltvp->typ, ltvp->len ) );
|
||||
|
||||
ltvp->len = 0; //default to: No Info Available
|
||||
#if defined MSF_COMPONENT_ID || (HCF_EXT) & HCF_EXT_MB //filter out all specials
|
||||
|
@ -2096,9 +2096,9 @@ wci_bufp pt; //pointer with the "right" type, just to help ease writing macr
|
|||
}
|
||||
} else if ( type == CFG_CMD_HCF ) {
|
||||
#define P ((CFG_CMD_HCF_STRCT FAR *)ltvp)
|
||||
HCFASSERT( P->cmd == CFG_CMD_HCF_REG_ACCESS, P->cmd ) //only Hermes register access supported
|
||||
HCFASSERT( P->cmd == CFG_CMD_HCF_REG_ACCESS, P->cmd ); //only Hermes register access supported
|
||||
if ( P->cmd == CFG_CMD_HCF_REG_ACCESS ) {
|
||||
HCFASSERT( P->mode < ifbp->IFB_IOBase, P->mode ) //Check Register space
|
||||
HCFASSERT( P->mode < ifbp->IFB_IOBase, P->mode ); //Check Register space
|
||||
ltvp->len = min( len, 4 ); //RESTORE ltv length
|
||||
P->add_info = IPW( P->mode );
|
||||
}
|
||||
|
@ -2117,7 +2117,7 @@ wci_bufp pt; //pointer with the "right" type, just to help ease writing macr
|
|||
get_frag( ifbp, (wci_bufp)<vp->len, 2*len+2 BE_PAR(2) );
|
||||
if ( IPW( HREG_STAT ) == 0xFFFF ) { //NIC removal test
|
||||
ltvp->len = 0;
|
||||
HCFASSERT( DO_ASSERT, type )
|
||||
HCFASSERT( DO_ASSERT, type );
|
||||
}
|
||||
}
|
||||
/*12*/ } else HCFASSERT( DO_ASSERT, type ) /*NOP*/; //NOP in case HCFASSERT is dummy
|
||||
|
@ -2129,8 +2129,8 @@ wci_bufp pt; //pointer with the "right" type, just to help ease writing macr
|
|||
}
|
||||
}
|
||||
HCFASSERT( rc == HCF_SUCCESS || ( rc == HCF_ERR_LEN && ifbp->IFB_AssertTrace & 1<<HCF_TRACE_PUT_INFO ),
|
||||
MERGE_2( type, rc ) ) /*20*/
|
||||
HCFLOGEXIT( HCF_TRACE_GET_INFO )
|
||||
MERGE_2( type, rc ) ); /*20*/
|
||||
HCFLOGEXIT( HCF_TRACE_GET_INFO );
|
||||
return rc;
|
||||
} // hcf_get_info
|
||||
|
||||
|
@ -2210,11 +2210,11 @@ hcf_put_info( IFBP ifbp, LTVP ltvp )
|
|||
{
|
||||
int rc = HCF_SUCCESS;
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_PUT_INFO, ltvp->typ )
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic )
|
||||
HCFASSERT_INT
|
||||
HCFASSERT( ltvp, 0 )
|
||||
HCFASSERT( 1 < ltvp->len && ltvp->len <= HCF_MAX_LTV + 1, ltvp->len )
|
||||
HCFLOGENTRY( HCF_TRACE_PUT_INFO, ltvp->typ );
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic );
|
||||
HCFASSERT_INT;
|
||||
HCFASSERT( ltvp, 0 );
|
||||
HCFASSERT( 1 < ltvp->len && ltvp->len <= HCF_MAX_LTV + 1, ltvp->len );
|
||||
|
||||
//all codes between 0xFA00 and 0xFCFF are passed to Hermes
|
||||
#if (HCF_TYPE) & HCF_TYPE_WPA
|
||||
|
@ -2256,7 +2256,7 @@ int rc = HCF_SUCCESS;
|
|||
#define P ((CFG_REG_ASSERT_RTNP_STRCT FAR *)ltvp)
|
||||
ifbp->IFB_AssertRtn = P->rtnp;
|
||||
// ifbp->IFB_AssertLvl = P->lvl; //TODO not yet supported so default is set in hcf_connect
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( HCF_ASSERT, 0xCAF1 ) ) //just to proof that the complete assert machinery is working
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( HCF_ASSERT, 0xCAF1 ) ); //just to proof that the complete assert machinery is working
|
||||
#undef P
|
||||
break;
|
||||
#endif // HCF_ASSERT_RT_MSF_RTN
|
||||
|
@ -2266,22 +2266,22 @@ int rc = HCF_SUCCESS;
|
|||
break;
|
||||
#endif // HCF_EXT_INFO_LOG
|
||||
case CFG_CNTL_OPT: //overrule option
|
||||
HCFASSERT( ( ltvp->val[0] & ~(USE_DMA | USE_16BIT) ) == 0, ltvp->val[0] )
|
||||
HCFASSERT( ( ltvp->val[0] & ~(USE_DMA | USE_16BIT) ) == 0, ltvp->val[0] );
|
||||
if ( ( ltvp->val[0] & USE_DMA ) == 0 ) ifbp->IFB_CntlOpt &= ~USE_DMA;
|
||||
ifbp->IFB_CntlOpt |= ltvp->val[0] & USE_16BIT;
|
||||
break;
|
||||
#if (HCF_EXT) & HCF_EXT_MB
|
||||
case CFG_REG_MB: //Register MailBox
|
||||
#define P ((CFG_REG_MB_STRCT FAR *)ltvp)
|
||||
HCFASSERT( ( (hcf_32)P->mb_addr & 0x0001 ) == 0, (hcf_32)P->mb_addr )
|
||||
HCFASSERT( (P)->mb_size >= 60, (P)->mb_size )
|
||||
HCFASSERT( ( (hcf_32)P->mb_addr & 0x0001 ) == 0, (hcf_32)P->mb_addr );
|
||||
HCFASSERT( (P)->mb_size >= 60, (P)->mb_size );
|
||||
ifbp->IFB_MBp = P->mb_addr;
|
||||
/* if no MB present, size must be 0 for ;?the old;? put_info_mb to work correctly */
|
||||
ifbp->IFB_MBSize = ifbp->IFB_MBp == NULL ? 0 : P->mb_size;
|
||||
ifbp->IFB_MBWp = ifbp->IFB_MBRp = 0;
|
||||
ifbp->IFB_MBp[0] = 0; //flag the MailBox as empty
|
||||
ifbp->IFB_MBInfoLen = 0;
|
||||
HCFASSERT( ifbp->IFB_MBSize >= 60 || ifbp->IFB_MBp == NULL, ifbp->IFB_MBSize )
|
||||
HCFASSERT( ifbp->IFB_MBSize >= 60 || ifbp->IFB_MBp == NULL, ifbp->IFB_MBSize );
|
||||
#undef P
|
||||
break;
|
||||
case CFG_MB_INFO: //store MailBoxInfoBlock
|
||||
|
@ -2306,9 +2306,9 @@ int rc = HCF_SUCCESS;
|
|||
break;
|
||||
case CFG_CMD_HCF:
|
||||
#define P ((CFG_CMD_HCF_STRCT FAR *)ltvp)
|
||||
HCFASSERT( P->cmd == CFG_CMD_HCF_REG_ACCESS, P->cmd ) //only Hermes register access supported
|
||||
HCFASSERT( P->cmd == CFG_CMD_HCF_REG_ACCESS, P->cmd ); //only Hermes register access supported
|
||||
if ( P->cmd == CFG_CMD_HCF_REG_ACCESS ) {
|
||||
HCFASSERT( P->mode < ifbp->IFB_IOBase, P->mode ) //Check Register space
|
||||
HCFASSERT( P->mode < ifbp->IFB_IOBase, P->mode ); //Check Register space
|
||||
OPW( P->mode, P->add_info);
|
||||
}
|
||||
#undef P
|
||||
|
@ -2325,7 +2325,7 @@ int rc = HCF_SUCCESS;
|
|||
rc = put_info( ifbp, ltvp );
|
||||
}
|
||||
//DO NOT !!! HCFASSERT( rc == HCF_SUCCESS, rc ) /* 20 */
|
||||
HCFLOGEXIT( HCF_TRACE_PUT_INFO )
|
||||
HCFLOGEXIT( HCF_TRACE_PUT_INFO );
|
||||
return rc;
|
||||
} // hcf_put_info
|
||||
|
||||
|
@ -2448,21 +2448,21 @@ wci_bufp lap = ifbp->IFB_lap + offset; //start address in LookAhead Buffer
|
|||
hcf_16 lal = ifbp->IFB_lal - offset; //available data within LookAhead Buffer
|
||||
hcf_16 j;
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_RCV_MSG, offset )
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic )
|
||||
HCFASSERT_INT
|
||||
HCFASSERT( descp, HCF_TRACE_RCV_MSG )
|
||||
HCFASSERT( ifbp->IFB_RxLen, HCF_TRACE_RCV_MSG )
|
||||
HCFASSERT( ifbp->IFB_RxLen >= offset, MERGE_2( offset, ifbp->IFB_RxLen ) )
|
||||
HCFASSERT( ifbp->IFB_lal >= offset, offset )
|
||||
HCFASSERT( (ifbp->IFB_CntlOpt & USE_DMA) == 0, 0xDADA )
|
||||
HCFLOGENTRY( HCF_TRACE_RCV_MSG, offset );
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic );
|
||||
HCFASSERT_INT;
|
||||
HCFASSERT( descp, HCF_TRACE_RCV_MSG );
|
||||
HCFASSERT( ifbp->IFB_RxLen, HCF_TRACE_RCV_MSG );
|
||||
HCFASSERT( ifbp->IFB_RxLen >= offset, MERGE_2( offset, ifbp->IFB_RxLen ) );
|
||||
HCFASSERT( ifbp->IFB_lal >= offset, offset );
|
||||
HCFASSERT( (ifbp->IFB_CntlOpt & USE_DMA) == 0, 0xDADA );
|
||||
|
||||
if ( tot_len < 0 ) {
|
||||
lal = 0; tot_len = 0; //suppress all copying activity in the do--while loop
|
||||
}
|
||||
do { //loop over all available fragments
|
||||
// obnoxious hcf.c(1480) : warning C4769: conversion of near pointer to long integer
|
||||
HCFASSERT( ((hcf_32)descp & 3 ) == 0, (hcf_32)descp )
|
||||
HCFASSERT( ((hcf_32)descp & 3 ) == 0, (hcf_32)descp );
|
||||
cp = descp->buf_addr;
|
||||
j = min( (hcf_16)tot_len, descp->BUF_SIZE ); //minimum of "what's` available" and fragment size
|
||||
descp->BUF_CNT = j;
|
||||
|
@ -2486,8 +2486,8 @@ hcf_16 j;
|
|||
}
|
||||
#endif // HCF_TYPE_WPA
|
||||
(void)hcf_action( ifbp, HCF_ACT_RX_ACK ); //only 1 shot to get the data, so free the resources in the NIC
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc )
|
||||
HCFLOGEXIT( HCF_TRACE_RCV_MSG )
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc );
|
||||
HCFLOGEXIT( HCF_TRACE_RCV_MSG );
|
||||
return rc;
|
||||
} // hcf_rcv_msg
|
||||
#endif // HCF_DL_ONLY
|
||||
|
@ -2658,18 +2658,18 @@ hcf_16 i;
|
|||
|
||||
hcf_16 fid = 0;
|
||||
|
||||
HCFASSERT( ifbp->IFB_RscInd || descp == NULL, ifbp->IFB_RscInd )
|
||||
HCFASSERT( (ifbp->IFB_CntlOpt & USE_DMA) == 0, 0xDADB )
|
||||
HCFASSERT( ifbp->IFB_RscInd || descp == NULL, ifbp->IFB_RscInd );
|
||||
HCFASSERT( (ifbp->IFB_CntlOpt & USE_DMA) == 0, 0xDADB );
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_SEND_MSG, tx_cntl )
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic )
|
||||
HCFASSERT_INT
|
||||
HCFLOGENTRY( HCF_TRACE_SEND_MSG, tx_cntl );
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic );
|
||||
HCFASSERT_INT;
|
||||
/* obnoxious c:/hcf/hcf.c(1480) : warning C4769: conversion of near pointer to long integer,
|
||||
* so skip */
|
||||
HCFASSERT( ((hcf_32)descp & 3 ) == 0, (hcf_32)descp )
|
||||
HCFASSERT( ((hcf_32)descp & 3 ) == 0, (hcf_32)descp );
|
||||
#if HCF_ASSERT
|
||||
{ int x = ifbp->IFB_FWIdentity.comp_id == COMP_ID_FW_AP ? tx_cntl & ~HFS_TX_CNTL_PORT : tx_cntl;
|
||||
HCFASSERT( (x & ~HCF_TX_CNTL_MASK ) == 0, tx_cntl )
|
||||
HCFASSERT( (x & ~HCF_TX_CNTL_MASK ) == 0, tx_cntl );
|
||||
}
|
||||
#endif // HCF_ASSERT
|
||||
|
||||
|
@ -2684,7 +2684,7 @@ hcf_16 fid = 0;
|
|||
//copy all the fragments in a transparent fashion
|
||||
for ( p = descp; p; p = p->next_desc_addr ) {
|
||||
/* obnoxious warning C4769: conversion of near pointer to long integer */
|
||||
HCFASSERT( ((hcf_32)p & 3 ) == 0, (hcf_32)p )
|
||||
HCFASSERT( ((hcf_32)p & 3 ) == 0, (hcf_32)p );
|
||||
put_frag( ifbp, p->buf_addr, p->BUF_CNT BE_PAR(0) );
|
||||
}
|
||||
rc = cmd_exe( ifbp, HCMD_THESEUS | HCMD_BUSY | HCMD_STARTPREAMBLE, fid );
|
||||
|
@ -2693,7 +2693,7 @@ hcf_16 fid = 0;
|
|||
}
|
||||
}
|
||||
// een slecht voorbeeld doet goed volgen ;?
|
||||
HCFLOGEXIT( HCF_TRACE_SEND_MSG )
|
||||
HCFLOGEXIT( HCF_TRACE_SEND_MSG );
|
||||
return rc;
|
||||
}
|
||||
#endif // HCF_EXT_TX_CONT
|
||||
|
@ -2716,10 +2716,10 @@ hcf_16 fid = 0;
|
|||
p = descp;
|
||||
do len += p->BUF_CNT; while ( ( p = p->next_desc_addr ) != NULL );
|
||||
p = descp;
|
||||
//;? HCFASSERT( len <= HCF_MAX_MSG, len )
|
||||
//;? HCFASSERT( len <= HCF_MAX_MSG, len );
|
||||
/*7*/ (void)setup_bap( ifbp, fid, HFS_TX_CNTL, IO_OUT );
|
||||
#if (HCF_TYPE) & HCF_TYPE_TX_DELAY
|
||||
HCFASSERT( ( descp != NULL ) ^ ( tx_cntl & HFS_TX_CNTL_TX_DELAY ), tx_cntl )
|
||||
HCFASSERT( ( descp != NULL ) ^ ( tx_cntl & HFS_TX_CNTL_TX_DELAY ), tx_cntl );
|
||||
if ( tx_cntl & HFS_TX_CNTL_TX_DELAY ) {
|
||||
tx_cntl &= ~HFS_TX_CNTL_TX_DELAY; //!!HFS_TX_CNTL_TX_DELAY no longer available
|
||||
ifbp->IFB_TxFID = fid;
|
||||
|
@ -2729,7 +2729,7 @@ hcf_16 fid = 0;
|
|||
OPW( HREG_DATA_1, tx_cntl ) ;
|
||||
OPW( HREG_DATA_1, 0 );
|
||||
#if ! ( (HCF_TYPE) & HCF_TYPE_CCX )
|
||||
HCFASSERT( p->BUF_CNT >= 14, p->BUF_CNT )
|
||||
HCFASSERT( p->BUF_CNT >= 14, p->BUF_CNT );
|
||||
/* assume DestAddr/SrcAddr/Len/Type ALWAYS contained in 1st fragment
|
||||
* otherwise life gets too cumbersome for MIC and Encapsulation !!!!!!!!
|
||||
if ( p->BUF_CNT >= 14 ) { alternatively: add a safety escape !!!!!!!!!!!! } */
|
||||
|
@ -2780,7 +2780,7 @@ hcf_16 fid = 0;
|
|||
while ( ( p = p->next_desc_addr ) != NULL ) {
|
||||
/* obnoxious c:/hcf/hcf.c(1480) : warning C4769: conversion of near pointer to long integer,
|
||||
* so skip */
|
||||
HCFASSERT( ((hcf_32)p & 3 ) == 0, (hcf_32)p )
|
||||
HCFASSERT( ((hcf_32)p & 3 ) == 0, (hcf_32)p );
|
||||
put_frag( ifbp, p->buf_addr, p->BUF_CNT BE_PAR(0) );
|
||||
CALC_TX_MIC( p->buf_addr, p->BUF_CNT );
|
||||
}
|
||||
|
@ -2800,8 +2800,8 @@ hcf_16 fid = 0;
|
|||
}
|
||||
// #endif // ALLOC_15
|
||||
}
|
||||
// HCFASSERT( level::ifbp->IFB_RscInd, ifbp->IFB_RscInd )
|
||||
HCFLOGEXIT( HCF_TRACE_SEND_MSG )
|
||||
// HCFASSERT( level::ifbp->IFB_RscInd, ifbp->IFB_RscInd );
|
||||
HCFLOGEXIT( HCF_TRACE_SEND_MSG );
|
||||
return rc;
|
||||
} // hcf_send_msg
|
||||
#endif // HCF_DL_ONLY
|
||||
|
@ -3068,9 +3068,9 @@ hcf_16 stat;
|
|||
wci_bufp buf_addr;
|
||||
hcf_16 i;
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_SERVICE_NIC, ifbp->IFB_IntOffCnt )
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic )
|
||||
HCFASSERT_INT
|
||||
HCFLOGENTRY( HCF_TRACE_SERVICE_NIC, ifbp->IFB_IntOffCnt );
|
||||
HCFASSERT( ifbp->IFB_Magic == HCF_MAGIC, ifbp->IFB_Magic );
|
||||
HCFASSERT_INT;
|
||||
|
||||
ifbp->IFB_LinkStat = 0; // ;? to be obsoleted ASAP /* 1*/
|
||||
ifbp->IFB_DSLinkStat &= ~CFG_LINK_STAT_CHANGE; /* 1*/
|
||||
|
@ -3084,7 +3084,7 @@ hcf_16 i;
|
|||
if ( ifbp->IFB_RscInd == 0 && stat & HREG_EV_ALLOC ) { //Note: IFB_RscInd is ALWAYS 1 for DMA
|
||||
ifbp->IFB_RscInd = 1;
|
||||
}
|
||||
IF_TALLY( if ( stat & HREG_EV_INFO_DROP ) ifbp->IFB_HCF_Tallies.NoBufInfo++; )
|
||||
IF_TALLY( if ( stat & HREG_EV_INFO_DROP ) { ifbp->IFB_HCF_Tallies.NoBufInfo++; } );
|
||||
#if (HCF_EXT) & HCF_EXT_INT_TICK
|
||||
if ( stat & HREG_EV_TICK ) {
|
||||
ifbp->IFB_TickCnt++;
|
||||
|
@ -3112,7 +3112,7 @@ CFG_DDS_TICK_TIME_STRCT ltv;
|
|||
}
|
||||
#if (HCF_EXT) & HCF_EXT_INT_TX_EX
|
||||
if ( stat & HREG_EV_TX_EXT && ( i = IPW( HREG_TX_COMPL_FID ) ) != 0 /*DAWA*/ ) {
|
||||
DAWA_ZERO_FID( HREG_TX_COMPL_FID )
|
||||
DAWA_ZERO_FID( HREG_TX_COMPL_FID );
|
||||
(void)setup_bap( ifbp, i, 0, IO_IN );
|
||||
get_frag( ifbp, &ifbp->IFB_TxFsStat, HFS_SWSUP BE_PAR(1) );
|
||||
}
|
||||
|
@ -3122,10 +3122,10 @@ CFG_DDS_TICK_TIME_STRCT ltv;
|
|||
if ( !( ifbp->IFB_CntlOpt & USE_DMA ) ) //!! be aware of the logical indentations
|
||||
#endif // HCF_DMA
|
||||
/*16*/ if ( stat & HREG_EV_RX && ( ifbp->IFB_RxFID = IPW( HREG_RX_FID ) ) != 0 ) { //if 0 then DAWA_ACK
|
||||
HCFASSERT( bufp, len )
|
||||
HCFASSERT( len >= HFS_DAT + 2, len )
|
||||
DAWA_ZERO_FID( HREG_RX_FID )
|
||||
HCFASSERT( ifbp->IFB_RxFID < CFG_PROD_DATA, ifbp->IFB_RxFID)
|
||||
HCFASSERT( bufp, len );
|
||||
HCFASSERT( len >= HFS_DAT + 2, len );
|
||||
DAWA_ZERO_FID( HREG_RX_FID );
|
||||
HCFASSERT( ifbp->IFB_RxFID < CFG_PROD_DATA, ifbp->IFB_RxFID);
|
||||
(void)setup_bap( ifbp, ifbp->IFB_RxFID, 0, IO_IN );
|
||||
get_frag( ifbp, bufp, HFS_ADDR_DEST BE_PAR(1) );
|
||||
ifbp->IFB_lap = buf_addr = bufp + HFS_ADDR_DEST;
|
||||
|
@ -3144,7 +3144,7 @@ CFG_DDS_TICK_TIME_STRCT ltv;
|
|||
#endif // HCF_TYPE_CCX
|
||||
{
|
||||
#if (HCF_ENCAP) == HCF_ENC
|
||||
HCFASSERT( len >= HFS_DAT + 2 + sizeof(snap_header), len )
|
||||
HCFASSERT( len >= HFS_DAT + 2 + sizeof(snap_header), len );
|
||||
/*34*/ i = *(wci_recordp)&bufp[HFS_STAT] & ( HFS_STAT_MSG_TYPE | HFS_STAT_ERR );
|
||||
if ( i == HFS_STAT_TUNNEL ||
|
||||
( i == HFS_STAT_1042 && hcf_encap( (wci_bufp)&bufp[HFS_TYPE] ) != ENC_TUNNEL ) ) {
|
||||
|
@ -3174,16 +3174,16 @@ CFG_DDS_TICK_TIME_STRCT ltv;
|
|||
}
|
||||
}
|
||||
// in case of DMA: signal availability of rx and/or tx packets to MSF
|
||||
IF_USE_DMA( ifbp->IFB_DmaPackets |= stat & ( HREG_EV_RDMAD | HREG_EV_TDMAD ); )
|
||||
IF_USE_DMA( ifbp->IFB_DmaPackets |= stat & ( HREG_EV_RDMAD | HREG_EV_TDMAD ) );
|
||||
// rlav : pending HREG_EV_RDMAD or HREG_EV_TDMAD events get acknowledged here.
|
||||
/*54*/ stat &= (hcf_16)~( HREG_EV_SLEEP_REQ | HREG_EV_CMD | HREG_EV_ACK_REG_READY | HREG_EV_ALLOC | HREG_EV_FW_DMA );
|
||||
//a positive mask would be easier to understand /*54*/ stat &= (hcf_16)~( HREG_EV_SLEEP_REQ | HREG_EV_CMD | HREG_EV_ACK_REG_READY | HREG_EV_ALLOC | HREG_EV_FW_DMA );
|
||||
IF_USE_DMA( stat &= (hcf_16)~HREG_EV_RX; )
|
||||
IF_USE_DMA( stat &= (hcf_16)~HREG_EV_RX );
|
||||
if ( stat ) {
|
||||
DAWA_ACK( stat ); /*DAWA*/
|
||||
}
|
||||
}
|
||||
HCFLOGEXIT( HCF_TRACE_SERVICE_NIC )
|
||||
HCFLOGEXIT( HCF_TRACE_SERVICE_NIC );
|
||||
return rc;
|
||||
} // hcf_service_nic
|
||||
#endif // HCF_DL_ONLY
|
||||
|
@ -3507,7 +3507,7 @@ hcf_32 prot_cnt;
|
|||
ifbp->IFB_TickIni = INI_TICK_INI;
|
||||
ifbp->IFB_DefunctStat = HCF_ERR_DEFUNCT_TIMER;
|
||||
ifbp->IFB_CardStat |= CARD_STAT_DEFUNCT;
|
||||
HCFASSERT( DO_ASSERT, prot_cnt )
|
||||
HCFASSERT( DO_ASSERT, prot_cnt );
|
||||
}
|
||||
}
|
||||
ifbp->IFB_TickIni <<= HCF_PROT_TIME_SHFT; /*8*/
|
||||
|
@ -3617,19 +3617,19 @@ HCF_STATIC int
|
|||
cmd_cmpl( IFBP ifbp )
|
||||
{
|
||||
|
||||
PROT_CNT_INI
|
||||
PROT_CNT_INI;
|
||||
int rc = HCF_SUCCESS;
|
||||
hcf_16 stat;
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_CMD_CPL, ifbp->IFB_Cmd )
|
||||
HCFLOGENTRY( HCF_TRACE_CMD_CPL, ifbp->IFB_Cmd );
|
||||
ifbp->IFB_Cmd &= ~HCMD_BUSY; /* 2 */
|
||||
HCF_WAIT_WHILE( (IPW( HREG_EV_STAT) & HREG_EV_CMD) == 0 ); /* 4 */
|
||||
stat = IPW( HREG_STAT );
|
||||
#if HCF_PROT_TIME
|
||||
if ( prot_cnt == 0 ) {
|
||||
IF_TALLY( ifbp->IFB_HCF_Tallies.MiscErr++; )
|
||||
IF_TALLY( ifbp->IFB_HCF_Tallies.MiscErr++ );
|
||||
rc = HCF_ERR_TIME_OUT;
|
||||
HCFASSERT( DO_ASSERT, ifbp->IFB_Cmd )
|
||||
HCFASSERT( DO_ASSERT, ifbp->IFB_Cmd );
|
||||
} else
|
||||
#endif // HCF_PROT_TIME
|
||||
{
|
||||
|
@ -3639,15 +3639,15 @@ hcf_16 stat;
|
|||
rc = ifbp->IFB_DefunctStat = HCF_ERR_DEFUNCT_CMD_SEQ;
|
||||
ifbp->IFB_CardStat |= CARD_STAT_DEFUNCT;
|
||||
}
|
||||
IF_TALLY( ifbp->IFB_HCF_Tallies.MiscErr++; )
|
||||
IF_TALLY( ifbp->IFB_HCF_Tallies.MiscErr++ );
|
||||
ifbp->IFB_ErrCmd = stat;
|
||||
ifbp->IFB_ErrQualifier = IPW( HREG_RESP_0 );
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( IPW( HREG_PARAM_0 ), ifbp->IFB_Cmd ) )
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( ifbp->IFB_ErrQualifier, ifbp->IFB_ErrCmd ) )
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( IPW( HREG_PARAM_0 ), ifbp->IFB_Cmd ) );
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( ifbp->IFB_ErrQualifier, ifbp->IFB_ErrCmd ) );
|
||||
}
|
||||
}
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc)
|
||||
HCFLOGEXIT( HCF_TRACE_CMD_CPL )
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc);
|
||||
HCFLOGEXIT( HCF_TRACE_CMD_CPL );
|
||||
return rc;
|
||||
} // cmd_cmpl
|
||||
|
||||
|
@ -3706,8 +3706,8 @@ cmd_exe( IFBP ifbp, hcf_16 cmd_code, hcf_16 par_0 ) //if HCMD_BUSY of cmd_code s
|
|||
{
|
||||
int rc;
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_CMD_EXE, cmd_code )
|
||||
HCFASSERT( (cmd_code & HCMD_CMD_CODE) != HCMD_TX || cmd_code & HCMD_BUSY, cmd_code ) //Tx must have Busy bit set
|
||||
HCFLOGENTRY( HCF_TRACE_CMD_EXE, cmd_code );
|
||||
HCFASSERT( (cmd_code & HCMD_CMD_CODE) != HCMD_TX || cmd_code & HCMD_BUSY, cmd_code ); //Tx must have Busy bit set
|
||||
OPW( HREG_SW_0, HCF_MAGIC );
|
||||
if ( IPW( HREG_SW_0 ) == HCF_MAGIC ) { /* 1 */
|
||||
rc = ifbp->IFB_DefunctStat;
|
||||
|
@ -3725,8 +3725,8 @@ int rc;
|
|||
rc = cmd_cmpl( ifbp );
|
||||
}
|
||||
}
|
||||
HCFASSERT( rc == HCF_SUCCESS, MERGE_2( rc, cmd_code ) )
|
||||
HCFLOGEXIT( HCF_TRACE_CMD_EXE )
|
||||
HCFASSERT( rc == HCF_SUCCESS, MERGE_2( rc, cmd_code ) );
|
||||
HCFLOGEXIT( HCF_TRACE_CMD_EXE );
|
||||
return rc;
|
||||
} // cmd_exe
|
||||
|
||||
|
@ -3764,9 +3764,9 @@ int rc = HCF_SUCCESS;
|
|||
wci_bufp cp;
|
||||
hcf_io io_port = ifbp->IFB_IOBase + HREG_AUX_DATA;
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_DL, ltvp->typ )
|
||||
HCFLOGENTRY( HCF_TRACE_DL, ltvp->typ );
|
||||
#if (HCF_TYPE) & HCF_TYPE_PRELOADED
|
||||
HCFASSERT( DO_ASSERT, ltvp->mode )
|
||||
HCFASSERT( DO_ASSERT, ltvp->mode );
|
||||
#else
|
||||
//if initial "program" LTV
|
||||
if ( ifbp->IFB_DLMode == CFG_PROG_STOP && ltvp->mode == CFG_PROG_VOLATILE) {
|
||||
|
@ -3818,7 +3818,7 @@ hcf_io io_port = ifbp->IFB_IOBase + HREG_AUX_DATA;
|
|||
} else
|
||||
#endif //;? as long as the above if contains a hard coded 0, might as well leave it out even more obvious
|
||||
{ //. . get number of words to program
|
||||
HCFASSERT( ltvp->segment_size, *ltvp->host_addr )
|
||||
HCFASSERT( ltvp->segment_size, *ltvp->host_addr );
|
||||
i = ltvp->segment_size/2;
|
||||
//. . copy data (words) from LTV via AUX port to NIC
|
||||
cp = (wci_bufp)ltvp->host_addr; //OUT_PORT_STRING_8_16 macro may modify its parameters
|
||||
|
@ -3833,8 +3833,8 @@ hcf_io io_port = ifbp->IFB_IOBase + HREG_AUX_DATA;
|
|||
}
|
||||
ifbp->IFB_DLMode = ltvp->mode; //save state in IFB_DLMode
|
||||
#endif // HCF_TYPE_PRELOADED
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc )
|
||||
HCFLOGEXIT( HCF_TRACE_DL )
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc );
|
||||
HCFLOGEXIT( HCF_TRACE_DL );
|
||||
return rc;
|
||||
} // download
|
||||
|
||||
|
@ -3916,18 +3916,18 @@ get_fid( IFBP ifbp )
|
|||
|
||||
hcf_16 fid = 0;
|
||||
#if ( (HCF_TYPE) & HCF_TYPE_HII5 ) == 0
|
||||
PROT_CNT_INI
|
||||
PROT_CNT_INI;
|
||||
#endif // HCF_TYPE_HII5
|
||||
|
||||
IF_DMA( HCFASSERT(!(ifbp->IFB_CntlOpt & USE_DMA), ifbp->IFB_CntlOpt) )
|
||||
IF_DMA( HCFASSERT(!(ifbp->IFB_CntlOpt & USE_DMA), ifbp->IFB_CntlOpt) );
|
||||
|
||||
if ( IPW( HREG_EV_STAT) & HREG_EV_ALLOC) {
|
||||
fid = IPW( HREG_ALLOC_FID );
|
||||
HCFASSERT( fid, ifbp->IFB_RscInd )
|
||||
DAWA_ZERO_FID( HREG_ALLOC_FID )
|
||||
HCFASSERT( fid, ifbp->IFB_RscInd );
|
||||
DAWA_ZERO_FID( HREG_ALLOC_FID );
|
||||
#if ( (HCF_TYPE) & HCF_TYPE_HII5 ) == 0
|
||||
HCF_WAIT_WHILE( ( IPW( HREG_EV_STAT ) & HREG_EV_ACK_REG_READY ) == 0 );
|
||||
HCFASSERT( prot_cnt, IPW( HREG_EV_STAT ) )
|
||||
HCFASSERT( prot_cnt, IPW( HREG_EV_STAT ) );
|
||||
#endif // HCF_TYPE_HII5
|
||||
DAWA_ACK( HREG_EV_ALLOC ); //!!note that HREG_EV_ALLOC is written only once
|
||||
// 180 degree error in logic ;? #if ALLOC_15
|
||||
|
@ -3989,7 +3989,7 @@ wci_bufp p = bufp; //working pointer
|
|||
int i; //prevent side effects from macro
|
||||
int j;
|
||||
|
||||
HCFASSERT( ((hcf_32)bufp & (HCF_ALIGN-1) ) == 0, (hcf_32)bufp )
|
||||
HCFASSERT( ((hcf_32)bufp & (HCF_ALIGN-1) ) == 0, (hcf_32)bufp );
|
||||
|
||||
/*1: here recovery logic for intervening BAP access between hcf_service_nic and hcf_rcv_msg COULD be added
|
||||
* if current access is RxInitial
|
||||
|
@ -4045,9 +4045,9 @@ hcf_32 FAR *p4; //prevent side effects from macro
|
|||
}
|
||||
}
|
||||
#if HCF_BIG_ENDIAN
|
||||
HCFASSERT( word_len == 0 || word_len == 2 || word_len == 4, word_len )
|
||||
HCFASSERT( word_len == 0 || ((hcf_32)bufp & 1 ) == 0, (hcf_32)bufp )
|
||||
HCFASSERT( word_len <= len, MERGE2( word_len, len ) )
|
||||
HCFASSERT( word_len == 0 || word_len == 2 || word_len == 4, word_len );
|
||||
HCFASSERT( word_len == 0 || ((hcf_32)bufp & 1 ) == 0, (hcf_32)bufp );
|
||||
HCFASSERT( word_len <= len, MERGE2( word_len, len ) );
|
||||
//see put_frag for an alternative implementation, but be careful about what are int's and what are
|
||||
//hcf_16's
|
||||
if ( word_len ) { //. if there is anything to convert
|
||||
|
@ -4158,11 +4158,11 @@ init( IFBP ifbp )
|
|||
|
||||
int rc = HCF_SUCCESS;
|
||||
|
||||
HCFLOGENTRY( HCF_TRACE_INIT, 0 )
|
||||
HCFLOGENTRY( HCF_TRACE_INIT, 0 );
|
||||
|
||||
ifbp->IFB_CardStat = 0; /* 2*/
|
||||
OPW( HREG_EV_ACK, ~HREG_EV_SLEEP_REQ ); /* 4*/
|
||||
IF_PROT_TIME( calibrate( ifbp ); ) /*10*/
|
||||
IF_PROT_TIME( calibrate( ifbp ) ); /*10*/
|
||||
#if 0 // OOR
|
||||
ifbp->IFB_FWIdentity.len = 2; //misuse the IFB space for a put
|
||||
ifbp->IFB_FWIdentity.typ = CFG_TICK_TIME;
|
||||
|
@ -4234,7 +4234,7 @@ int i = sizeof( CFG_FW_IDENTITY_STRCT) + sizeof(CFG_SUP_RANGE_STRCT );
|
|||
#endif // MSF_COMPONENT_ID
|
||||
#if (HCF_DL_ONLY) == 0 /* 28 */
|
||||
if ( rc == HCF_SUCCESS && ifbp->IFB_FWIdentity.comp_id >= COMP_ID_FW_STA ) {
|
||||
PROT_CNT_INI
|
||||
PROT_CNT_INI;
|
||||
/**************************************************************************************
|
||||
* rlav: the DMA engine needs the host to cause a 'hanging alloc event' for it to consume.
|
||||
* not sure if this is the right spot in the HCF, thinking about hcf_enable...
|
||||
|
@ -4245,22 +4245,22 @@ PROT_CNT_INI
|
|||
//#else
|
||||
if ( rc == HCF_SUCCESS ) {
|
||||
HCF_WAIT_WHILE( (IPW( HREG_EV_STAT ) & HREG_EV_ALLOC) == 0 );
|
||||
IF_PROT_TIME( HCFASSERT(prot_cnt, IPW( HREG_EV_STAT ) ) /*NOP*/;)
|
||||
IF_PROT_TIME( HCFASSERT(prot_cnt, IPW( HREG_EV_STAT )) );
|
||||
#if HCF_DMA
|
||||
if ( ! ( ifbp->IFB_CntlOpt & USE_DMA ) )
|
||||
#endif // HCF_DMA
|
||||
{
|
||||
ifbp->IFB_RscInd = get_fid( ifbp );
|
||||
HCFASSERT( ifbp->IFB_RscInd, 0 )
|
||||
HCFASSERT( ifbp->IFB_RscInd, 0 );
|
||||
cmd_exe( ifbp, HCMD_ALLOC, 0 );
|
||||
IF_PROT_TIME( if ( prot_cnt == 0 ) rc = HCF_ERR_TIME_OUT; )
|
||||
IF_PROT_TIME( if ( prot_cnt == 0 ) rc = HCF_ERR_TIME_OUT );
|
||||
}
|
||||
}
|
||||
//#endif // ALLOC_15
|
||||
}
|
||||
#endif // HCF_DL_ONLY
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc )
|
||||
HCFLOGEXIT( HCF_TRACE_INIT )
|
||||
HCFASSERT( rc == HCF_SUCCESS, rc );
|
||||
HCFLOGEXIT( HCF_TRACE_INIT );
|
||||
return rc;
|
||||
} // init
|
||||
|
||||
|
@ -4307,11 +4307,11 @@ RID_LOGP ridp = ifbp->IFB_RIDLogp; //NULL or pointer to array of RID_LOG structu
|
|||
|
||||
HCFTRACE( ifbp, HCF_TRACE_ISR_INFO ); /* 1 */
|
||||
fid = IPW( HREG_INFO_FID );
|
||||
DAWA_ZERO_FID( HREG_INFO_FID )
|
||||
DAWA_ZERO_FID( HREG_INFO_FID );
|
||||
if ( fid ) {
|
||||
(void)setup_bap( ifbp, fid, 0, IO_IN );
|
||||
get_frag( ifbp, (wci_bufp)info, 4 BE_PAR(2) );
|
||||
HCFASSERT( info[0] <= HCF_MAX_LTV + 1, MERGE_2( info[1], info[0] ) ) //;? a smaller value makes more sense
|
||||
HCFASSERT( info[0] <= HCF_MAX_LTV + 1, MERGE_2( info[1], info[0] ) ); //;? a smaller value makes more sense
|
||||
#if (HCF_TALLIES) & HCF_TALLIES_NIC //Hermes tally support
|
||||
if ( info[1] == CFG_TALLIES ) {
|
||||
hcf_32 *p;
|
||||
|
@ -4331,7 +4331,7 @@ hcf_32 *p;
|
|||
/*6*/ while ( 1 ) {
|
||||
if ( ridp->typ == 0 || ridp->typ == info[1] ) {
|
||||
if ( ridp->bufp ) {
|
||||
HCFASSERT( ridp->len >= 2, ridp->typ )
|
||||
HCFASSERT( ridp->len >= 2, ridp->typ );
|
||||
ridp->bufp[0] = min((hcf_16)(ridp->len - 1), info[0] ); //save L
|
||||
ridp->bufp[1] = info[1]; //save T
|
||||
get_frag( ifbp, (wci_bufp)&ridp->bufp[2], (ridp->bufp[0] - 1)*2 BE_PAR(0) );
|
||||
|
@ -4366,7 +4366,7 @@ hcf_32 *p;
|
|||
// /*6*/ while ( 1 ) {
|
||||
// if ( ridp->typ == 0 || ridp->typ == info[1] ) {
|
||||
// if ( ridp->bufp ) {
|
||||
// HCFASSERT( ridp->len >= 2, ridp->typ )
|
||||
// HCFASSERT( ridp->len >= 2, ridp->typ );
|
||||
// (void)setup_bap( ifbp, fid, 2, IO_IN ); //restore BAP for tallies, linkstat and specific type followed by wild card
|
||||
// ridp->bufp[0] = min( ridp->len - 1, info[0] ); //save L
|
||||
// get_frag( ifbp, (wci_bufp)&ridp->bufp[1], ridp->bufp[0]*2 BE_PAR(0) );
|
||||
|
@ -4483,11 +4483,11 @@ put_frag( IFBP ifbp, wci_bufp bufp, int len BE_PAR( int word_len ) )
|
|||
hcf_io io_port = ifbp->IFB_IOBase + HREG_DATA_1; //BAP data register
|
||||
int i; //prevent side effects from macro
|
||||
hcf_16 j;
|
||||
HCFASSERT( ((hcf_32)bufp & (HCF_ALIGN-1) ) == 0, (hcf_32)bufp )
|
||||
HCFASSERT( ((hcf_32)bufp & (HCF_ALIGN-1) ) == 0, (hcf_32)bufp );
|
||||
#if HCF_BIG_ENDIAN
|
||||
HCFASSERT( word_len == 0 || word_len == 2 || word_len == 4, word_len )
|
||||
HCFASSERT( word_len == 0 || ((hcf_32)bufp & 1 ) == 0, (hcf_32)bufp )
|
||||
HCFASSERT( word_len <= len, MERGE_2( word_len, len ) )
|
||||
HCFASSERT( word_len == 0 || word_len == 2 || word_len == 4, word_len );
|
||||
HCFASSERT( word_len == 0 || ((hcf_32)bufp & 1 ) == 0, (hcf_32)bufp );
|
||||
HCFASSERT( word_len <= len, MERGE_2( word_len, len ) );
|
||||
|
||||
if ( word_len ) { //if there is anything to convert
|
||||
//. convert and write the 1st hcf_16
|
||||
|
@ -4635,8 +4635,8 @@ put_info( IFBP ifbp, LTVP ltvp )
|
|||
|
||||
int rc = HCF_SUCCESS;
|
||||
|
||||
HCFASSERT( ifbp->IFB_CardStat == 0, MERGE_2( ltvp->typ, ifbp->IFB_CardStat ) )
|
||||
HCFASSERT( CFG_RID_CFG_MIN <= ltvp->typ && ltvp->typ <= CFG_RID_CFG_MAX, ltvp->typ )
|
||||
HCFASSERT( ifbp->IFB_CardStat == 0, MERGE_2( ltvp->typ, ifbp->IFB_CardStat ) );
|
||||
HCFASSERT( CFG_RID_CFG_MIN <= ltvp->typ && ltvp->typ <= CFG_RID_CFG_MAX, ltvp->typ );
|
||||
|
||||
if ( ifbp->IFB_CardStat == 0 && /* 20*/
|
||||
( ( CFG_RID_CFG_MIN <= ltvp->typ && ltvp->typ <= CFG_RID_CFG_MAX ) ||
|
||||
|
@ -4654,7 +4654,7 @@ int rc = HCF_SUCCESS;
|
|||
t != CFG_DEAUTHENTICATE_ADDR
|
||||
)
|
||||
) {
|
||||
HCFASSERT( DO_ASSERT, ltvp->typ )
|
||||
HCFASSERT( DO_ASSERT, ltvp->typ );
|
||||
}
|
||||
}
|
||||
#endif // HCF_ASSERT
|
||||
|
@ -4738,8 +4738,8 @@ hcf_16 len; //total length to copy to MailBox
|
|||
hcf_16 tlen; //free length/working length/offset in WMP frame
|
||||
|
||||
if ( ifbp->IFB_MBp == NULL ) return rc; //;?not sufficient
|
||||
HCFASSERT( ifbp->IFB_MBp != NULL, 0 ) //!!!be careful, don't get into an endless recursion
|
||||
HCFASSERT( ifbp->IFB_MBSize, 0 )
|
||||
HCFASSERT( ifbp->IFB_MBp != NULL, 0 ); //!!!be careful, don't get into an endless recursion
|
||||
HCFASSERT( ifbp->IFB_MBSize, 0 );
|
||||
|
||||
len = 1; /* 1 */
|
||||
for ( i = 0; i < ltvp->frag_cnt; i++ ) {
|
||||
|
@ -4765,7 +4765,7 @@ hcf_16 tlen; //free length/working length/offset in WMP frame
|
|||
}
|
||||
if ( len + 2 >= tlen ){ /* 6 */
|
||||
//Do Not ASSERT, this is a normal condition
|
||||
IF_TALLY( ifbp->IFB_HCF_Tallies.NoBufMB++; ) /*NOP to cover against analomies with empty compound*/;
|
||||
IF_TALLY( ifbp->IFB_HCF_Tallies.NoBufMB++ );
|
||||
rc = HCF_ERR_LEN;
|
||||
} else {
|
||||
*dp++ = len; //write Len (= size of T+V in words to MB_Info block
|
||||
|
@ -4861,7 +4861,7 @@ hcf_16 tlen; //free length/working length/offset in WMP frame
|
|||
HCF_STATIC int
|
||||
setup_bap( IFBP ifbp, hcf_16 fid, int offset, int type )
|
||||
{
|
||||
PROT_CNT_INI
|
||||
PROT_CNT_INI;
|
||||
int rc;
|
||||
|
||||
HCFTRACE( ifbp, HCF_TRACE_STRIO );
|
||||
|
@ -4874,9 +4874,9 @@ int rc;
|
|||
}
|
||||
else ifbp->IFB_CarryOut = 0;
|
||||
HCF_WAIT_WHILE( IPW( HREG_OFFSET_1) & HCMD_BUSY );
|
||||
HCFASSERT( !( IPW( HREG_OFFSET_1) & HREG_OFFSET_ERR ), MERGE_2( fid, offset ) ) /*8*/
|
||||
HCFASSERT( !( IPW( HREG_OFFSET_1) & HREG_OFFSET_ERR ), MERGE_2( fid, offset ) ); /*8*/
|
||||
if ( prot_cnt == 0 ) {
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( fid, offset ) )
|
||||
HCFASSERT( DO_ASSERT, MERGE_2( fid, offset ) );
|
||||
rc = ifbp->IFB_DefunctStat = HCF_ERR_DEFUNCT_TIME_OUT;
|
||||
ifbp->IFB_CardStat |= CARD_STAT_DEFUNCT;
|
||||
}
|
||||
|
|
|
@ -557,17 +557,13 @@ err: ;
|
|||
/************************************************************************************************/
|
||||
|
||||
#ifdef HCF_SLEEP
|
||||
#if defined MSF_WAIT
|
||||
err: MSF should no longer supply this macro;
|
||||
#define MSF_WAIT(x) do { \
|
||||
PROT_CNT_INI; \
|
||||
HCF_WAIT_WHILE((IPW(HREG_IO) & HREG_IO_WOKEN_UP) == 0); \
|
||||
HCFASSERT( prot_cnt, IPW( HREG_IO ) ); \
|
||||
} while (0)
|
||||
#else
|
||||
#define MSF_WAIT(x) \
|
||||
{ PROT_CNT_INI \
|
||||
HCF_WAIT_WHILE( ( IPW( HREG_IO ) & HREG_IO_WOKEN_UP ) == 0 ); \
|
||||
HCFASSERT( prot_cnt, IPW( HREG_IO ) ) \
|
||||
}
|
||||
#endif // MSF_WAIT
|
||||
#else
|
||||
#define MSF_WAIT(x) /*NOP*/
|
||||
#define MSF_WAIT(x) do { } while (0)
|
||||
#endif // HCF_SLEEP
|
||||
|
||||
#define LOF(x) (sizeof(x)/sizeof(hcf_16)-1)
|
||||
|
@ -583,13 +579,14 @@ err: MSF should no longer supply this macro;
|
|||
#endif // HCF_STATIC
|
||||
|
||||
#if ( (HCF_TYPE) & HCF_TYPE_HII5 ) == 0
|
||||
#define DAWA_ACK( mask) { \
|
||||
#define DAWA_ACK( mask) do { \
|
||||
OPW( HREG_EV_ACK, mask | HREG_EV_ACK_REG_READY ); \
|
||||
OPW( HREG_EV_ACK, (mask & ~HREG_EV_ALLOC) | HREG_EV_ACK_REG_READY ); }
|
||||
#define DAWA_ZERO_FID(reg) OPW( reg, 0 );
|
||||
OPW( HREG_EV_ACK, (mask & ~HREG_EV_ALLOC) | HREG_EV_ACK_REG_READY ); \
|
||||
} while (0)
|
||||
#define DAWA_ZERO_FID(reg) OPW( reg, 0 )
|
||||
#else
|
||||
#define DAWA_ACK( mask) OPW( HREG_EV_ACK, mask );
|
||||
#define DAWA_ZERO_FID(reg)
|
||||
#define DAWA_ACK( mask) OPW( HREG_EV_ACK, mask )
|
||||
#define DAWA_ZERO_FID(reg) do { } while (0)
|
||||
#endif // HCF_TYPE_HII5
|
||||
|
||||
#if (HCF_TYPE) & HCF_TYPE_WPA
|
||||
|
@ -607,22 +604,22 @@ err: MSF should no longer supply this macro;
|
|||
#endif // HCF_TYPE_WPA
|
||||
|
||||
#if HCF_TALLIES & HCF_TALLIES_HCF //HCF tally support
|
||||
#define IF_TALLY(x) x
|
||||
#define IF_TALLY(x) do { x; } while (0)
|
||||
#else
|
||||
#define IF_TALLY(x)
|
||||
#define IF_TALLY(x) do { } while (0)
|
||||
#endif // HCF_TALLIES_HCF
|
||||
|
||||
|
||||
#if HCF_DMA
|
||||
#define IF_DMA(x) x
|
||||
#define IF_NOT_DMA(x)
|
||||
#define IF_USE_DMA(x) if ( ifbp->IFB_CntlOpt & USE_DMA ) x
|
||||
#define IF_NOT_USE_DMA(x) if ( !(ifbp->IFB_CntlOpt & USE_DMA) ) x
|
||||
#define IF_DMA(x) do { x; } while(0)
|
||||
#define IF_NOT_DMA(x) do { } while(0)
|
||||
#define IF_USE_DMA(x) if ( ifbp->IFB_CntlOpt & USE_DMA ) { x; }
|
||||
#define IF_NOT_USE_DMA(x) if ( !(ifbp->IFB_CntlOpt & USE_DMA) ) { x; }
|
||||
#else
|
||||
#define IF_DMA(x)
|
||||
#define IF_NOT_DMA(x) x
|
||||
#define IF_USE_DMA(x)
|
||||
#define IF_NOT_USE_DMA(x) x
|
||||
#define IF_DMA(x) do { } while(0)
|
||||
#define IF_NOT_DMA(x) do { x; } while(0)
|
||||
#define IF_USE_DMA(x) do { } while(0)
|
||||
#define IF_NOT_USE_DMA(x) do { x; } while(0)
|
||||
#endif // HCF_DMA
|
||||
|
||||
|
||||
|
@ -632,16 +629,16 @@ err: MSF should no longer supply this macro;
|
|||
* in a row and that when one fails all subsequent fail immediately without reinitialization of prot_cnt
|
||||
*/
|
||||
#if HCF_PROT_TIME == 0
|
||||
#define PROT_CNT_INI
|
||||
#define IF_PROT_TIME(x)
|
||||
#define PROT_CNT_INI do { } while(0)
|
||||
#define IF_PROT_TIME(x) do { } while(0)
|
||||
#if defined HCF_YIELD
|
||||
#define HCF_WAIT_WHILE( x ) while ( (x) && (HCF_YIELD) ) /*NOP*/;
|
||||
#define HCF_WAIT_WHILE( x ) do { } while( (x) && (HCF_YIELD) )
|
||||
#else
|
||||
#define HCF_WAIT_WHILE( x ) while ( x ) /*NOP*/;
|
||||
#define HCF_WAIT_WHILE( x ) do { } while ( x )
|
||||
#endif // HCF_YIELD
|
||||
#else
|
||||
#define PROT_CNT_INI hcf_32 prot_cnt = ifbp->IFB_TickIni;
|
||||
#define IF_PROT_TIME(x) x
|
||||
#define PROT_CNT_INI hcf_32 prot_cnt = ifbp->IFB_TickIni
|
||||
#define IF_PROT_TIME(x) do { x; } while(0)
|
||||
#if defined HCF_YIELD
|
||||
#define HCF_WAIT_WHILE( x ) while ( prot_cnt && (x) && (HCF_YIELD) ) prot_cnt--;
|
||||
#else
|
||||
|
@ -684,32 +681,32 @@ err: someone redefined these macros while the implemenation assumes they are equ
|
|||
* on the if-statement
|
||||
*/
|
||||
#if HCF_ASSERT
|
||||
#define HCFASSERT(x,q) {if (!(x)) {mdd_assert( ifbp, __LINE__ , q );}}
|
||||
#define HCFASSERT(x,q) do { if (!(x)) {mdd_assert(ifbp, __LINE__, q );} } while(0)
|
||||
#define MMDASSERT(x,q) {if (!(x)) {mdd_assert( assert_ifbp, __LINE__ + FILE_NAME_OFFSET, q );}}
|
||||
|
||||
#define HCFLOGENTRY( where, what ) \
|
||||
{if ( (ifbp->IFB_AssertWhere = where) <= 15 ) { \
|
||||
#define HCFLOGENTRY( where, what ) do { \
|
||||
if ( (ifbp->IFB_AssertWhere = where) <= 15 ) { \
|
||||
HCF_ENTRY( ifbp ); \
|
||||
HCFASSERT( (ifbp->IFB_AssertTrace & 1<<((where)&0xF)) == 0, ifbp->IFB_AssertTrace ); \
|
||||
ifbp->IFB_AssertTrace |= 1<<((where)&0xF); \
|
||||
} \
|
||||
HCFTRACE(ifbp, where ) \
|
||||
HCFTRACEVALUE(ifbp, what ) \
|
||||
}
|
||||
HCFTRACE(ifbp, where ); \
|
||||
HCFTRACEVALUE(ifbp, what ); \
|
||||
} while (0)
|
||||
|
||||
#define HCFLOGEXIT( where ) \
|
||||
{if ( (ifbp->IFB_AssertWhere = where) <= 15 ) { \
|
||||
#define HCFLOGEXIT( where ) do { \
|
||||
if ( (ifbp->IFB_AssertWhere = where) <= 15 ) { \
|
||||
HCF_EXIT( ifbp ); \
|
||||
ifbp->IFB_AssertTrace &= ~(1<<((where)&0xF)); \
|
||||
} \
|
||||
HCFTRACE(ifbp, (where)|HCF_TRACE_EXIT ) \
|
||||
}
|
||||
HCFTRACE(ifbp, (where)|HCF_TRACE_EXIT ); \
|
||||
} while (0)
|
||||
|
||||
#else // HCF_ASSERT
|
||||
#define HCFASSERT( x, q )
|
||||
#define HCFASSERT( x, q ) do { } while(0)
|
||||
#define MMDASSERT( x, q )
|
||||
#define HCFLOGENTRY( where, what ) {HCF_ENTRY( ifbp );}
|
||||
#define HCFLOGEXIT( where ) {HCF_EXIT( ifbp );}
|
||||
#define HCFLOGENTRY( where, what ) do {HCF_ENTRY( ifbp );} while (0)
|
||||
#define HCFLOGEXIT( where ) do {HCF_EXIT( ifbp );} while(0)
|
||||
#endif // HCF_ASSERT
|
||||
|
||||
#if HCF_INT_ON
|
||||
|
@ -727,13 +724,13 @@ err: someone redefined these macros while the implemenation assumes they are equ
|
|||
|
||||
|
||||
#if defined HCF_TRACE
|
||||
#define HCFTRACE(ifbp, where ) {OPW( HREG_SW_1, where );}
|
||||
#define HCFTRACE(ifbp, where ) do {OPW( HREG_SW_1, where );} while(0)
|
||||
//#define HCFTRACE(ifbp, where ) {HCFASSERT( DO_ASSERT, where );}
|
||||
#define HCFTRACEVALUE(ifbp, what ) {OPW( HREG_SW_2, what );}
|
||||
#define HCFTRACEVALUE(ifbp, what ) do {OPW( HREG_SW_2, what );} while (0)
|
||||
//#define HCFTRACEVALUE(ifbp, what ) {HCFASSERT( DO_ASSERT, what );}
|
||||
#else
|
||||
#define HCFTRACE(ifbp, where )
|
||||
#define HCFTRACEVALUE(ifbp, what )
|
||||
#define HCFTRACE(ifbp, where ) do { } while(0)
|
||||
#define HCFTRACEVALUE(ifbp, what ) do { } while(0)
|
||||
#endif // HCF_TRACE
|
||||
|
||||
|
||||
|
|
Loading…
Reference in New Issue