void CMultiXProcess::Reject()
{
CMultiXL5Msg Msg(CMultiXL5Msg::RejectMsgCode,*Owner());
SendMsg(Msg);
EnableReceiver(false);
EnableSender(false);
}
void CMultiXProcess::Accept(std::string sPassword)
{
if(!sPassword.empty())
PasswordToSend() = sPassword;
CMultiXL5Msg Msg(CMultiXL5Msg::AcceptMsgCode,*Owner());
Msg.AddItem(LoginPasswordItemCode,PasswordToSend());
SendMsg(Msg);
EnableReceiver(true);
}
bool CMultiXProcess::OnL5Msg(CMultiXMsg &Msg)
{
std::string Password;
switch(Msg.MsgCode())
{
case CMultiXL5Msg::LoginMsgCode :
if(OnLoginReq(Msg.Find(LoginPasswordItemCode,Password,false)))
{
EnableReceiver(true);
} else
{
EnableReceiver(false);
}
break;
case CMultiXL5Msg::AcceptMsgCode :
if(OnAccepted(Msg.Find(LoginPasswordItemCode,Password,false)))
{
EnableReceiver(true);
EnableSender(true);
} else
{
EnableReceiver(false);
EnableSender(false);
}
break;
case CMultiXL5Msg::RejectMsgCode :
EnableSender(false);
OnRejected();
break;
case CMultiXL5Msg::EnableSenderMsgCode :
EnableSender(true);
OnSenderEnabled();
break;
case CMultiXL5Msg::DisableSenderMsgCode :
EnableSender(false);
OnSenderDisabled();
break;
}
return false;
}
/* Do a hardware reset on the card, and set up necessary registers.
*
* This should be called as little as possible, because it disrupts the
* token on the network (causes a RECON) and requires a significant delay.
*
* However, it does make sure the card is in a defined state.
*/
int arcrimi_reset(struct device *dev,int reset_delay)
{
struct arcnet_local *lp=(struct arcnet_local *)dev->priv;
short ioaddr=dev->mem_start + 0x800;
int recbuf=lp->recbuf;
if (reset_delay==3)
{
ARCRESET;
return 0;
}
/* no IRQ's, please! */
lp->intmask=0;
SETMASK;
BUGMSG(D_INIT,"Resetting %s (status=%Xh)\n",
dev->name,ARCSTATUS);
ACOMMAND(CFLAGScmd|RESETclear); /* clear flags & end reset */
ACOMMAND(CFLAGScmd|CONFIGclear);
/* clear out status variables */
recbuf=lp->recbuf=0;
lp->txbuf=2;
/* enable extended (512-byte) packets */
ACOMMAND(CONFIGcmd|EXTconf);
#ifndef SLOW_XMIT_COPY
/* clean out all the memory to make debugging make more sense :) */
BUGLVL(D_DURING)
memset_io(dev->mem_start,0x42,2048);
#endif
/* and enable receive of our first packet to the first buffer */
EnableReceiver();
/* re-enable interrupts */
lp->intmask|=NORXflag;
#ifdef DETECT_RECONFIGS
lp->intmask|=RECONflag;
#endif
SETMASK;
/* done! return success. */
return 0;
}
/* The actual interrupt handler routine - handle various IRQ's generated
* by the card.
*/
static void
arcrimi_inthandler(struct device *dev)
{
struct arcnet_local *lp=(struct arcnet_local *)dev->priv;
int ioaddr=dev->mem_start+0x800, status, boguscount = 3, didsomething;
AINTMASK(0);
BUGMSG(D_DURING,"in arcrimi_inthandler (status=%Xh, intmask=%Xh)\n",
ARCSTATUS,lp->intmask);
do
{
status = ARCSTATUS;
didsomething=0;
/* RESET flag was enabled - card is resetting and if RX
* is disabled, it's NOT because we just got a packet.
*/
if (status & RESETflag)
{
BUGMSG(D_NORMAL,"spurious reset (status=%Xh)\n",
status);
arcrimi_reset(dev,0);
/* all other flag values are just garbage */
break;
}
/* RX is inhibited - we must have received something. */
if (status & lp->intmask & NORXflag)
{
int recbuf=lp->recbuf=!lp->recbuf;
BUGMSG(D_DURING,"receive irq (status=%Xh)\n",
status);
/* enable receive of our next packet */
EnableReceiver();
/* Got a packet. */
arcrimi_rx(dev,!recbuf);
didsomething++;
}
/* it can only be an xmit-done irq if we're xmitting :) */
/*if (status&TXFREEflag && !lp->in_txhandler && lp->sending)*/
if (status & lp->intmask & TXFREEflag)
{
struct Outgoing *out=&(lp->outgoing);
int was_sending=lp->sending;
lp->intmask &= ~TXFREEflag;
lp->in_txhandler++;
if (was_sending) lp->sending--;
BUGMSG(D_DURING,"TX IRQ (stat=%Xh, numsegs=%d, segnum=%d, skb=%ph)\n",
status,out->numsegs,out->segnum,out->skb);
if (was_sending && !(status&TXACKflag))
{
if (lp->lasttrans_dest != 0)
{
BUGMSG(D_EXTRA,"transmit was not acknowledged! (status=%Xh, dest=%02Xh)\n",
status,lp->lasttrans_dest);
lp->stats.tx_errors++;
lp->stats.tx_carrier_errors++;
}
else
{
BUGMSG(D_DURING,"broadcast was not acknowledged; that's normal (status=%Xh, dest=%02Xh)\n",
status,
lp->lasttrans_dest);
}
}
/* send packet if there is one */
arcnet_go_tx(dev,0);
didsomething++;
if (lp->intx)
{
BUGMSG(D_DURING,"TXDONE while intx! (status=%Xh, intx=%d)\n",
ARCSTATUS,lp->intx);
lp->in_txhandler--;
continue;
}
if (!lp->outgoing.skb)
{
BUGMSG(D_DURING,"TX IRQ done: no split to continue.\n");
/* inform upper layers */
if (!lp->txready) arcnet_tx_done(dev, lp);
lp->in_txhandler--;
continue;
}
/* if more than one segment, and not all segments
* are done, then continue xmit.
*/
if (out->segnum<out->numsegs)
arcnetA_continue_tx(dev);
arcnet_go_tx(dev,0);
/* if segnum==numsegs, the transmission is finished;
* free the skb.
*/
if (out->segnum>=out->numsegs)
{
/* transmit completed */
out->segnum++;
if (out->skb)
{
lp->stats.tx_bytes += out->skb->len;
dev_kfree_skb(out->skb);
}
out->skb=NULL;
/* inform upper layers */
if (!lp->txready) arcnet_tx_done(dev, lp);
}
didsomething++;
lp->in_txhandler--;
}
else if (lp->txready && !lp->sending && !lp->intx)
{
BUGMSG(D_NORMAL,"recovery from silent TX (status=%Xh)\n",
status);
arcnet_go_tx(dev,0);
didsomething++;
}
#ifdef DETECT_RECONFIGS
if (status & (lp->intmask) & RECONflag)
{
ACOMMAND(CFLAGScmd|CONFIGclear);
lp->stats.tx_carrier_errors++;
#ifdef SHOW_RECONFIGS
BUGMSG(D_NORMAL,"Network reconfiguration detected (status=%Xh)\n",
status);
#endif /* SHOW_RECONFIGS */
#ifdef RECON_THRESHOLD
/* is the RECON info empty or old? */
if (!lp->first_recon || !lp->last_recon ||
jiffies-lp->last_recon > HZ*10)
{
if (lp->network_down)
BUGMSG(D_NORMAL,"reconfiguration detected: cabling restored?\n");
lp->first_recon=lp->last_recon=jiffies;
lp->num_recons=lp->network_down=0;
BUGMSG(D_DURING,"recon: clearing counters.\n");
}
else /* add to current RECON counter */
{
lp->last_recon=jiffies;
lp->num_recons++;
BUGMSG(D_DURING,"recon: counter=%d, time=%lds, net=%d\n",
lp->num_recons,
(lp->last_recon-lp->first_recon)/HZ,
lp->network_down);
/* if network is marked up;
* and first_recon and last_recon are 60+ sec
* apart;
* and the average no. of recons counted is
* > RECON_THRESHOLD/min;
* then print a warning message.
*/
if (!lp->network_down
&& (lp->last_recon-lp->first_recon)<=HZ*60
&& lp->num_recons >= RECON_THRESHOLD)
{
lp->network_down=1;
BUGMSG(D_NORMAL,"many reconfigurations detected: cabling problem?\n");
}
else if (!lp->network_down
&& lp->last_recon-lp->first_recon > HZ*60)
{
/* reset counters if we've gone for
* over a minute.
*/
lp->first_recon=lp->last_recon;
lp->num_recons=1;
}
}
}
else if (lp->network_down && jiffies-lp->last_recon > HZ*10)
{
if (lp->network_down)
BUGMSG(D_NORMAL,"cabling restored?\n");
lp->first_recon=lp->last_recon=0;
lp->num_recons=lp->network_down=0;
BUGMSG(D_DURING,"not recon: clearing counters anyway.\n");
#endif
}
#endif /* DETECT_RECONFIGS */
} while (--boguscount && didsomething);
BUGMSG(D_DURING,"net_interrupt complete (status=%Xh, count=%d)\n",
ARCSTATUS,boguscount);
BUGMSG(D_DURING,"\n");
SETMASK; /* put back interrupt mask */
}
