mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-23 12:43:55 +08:00
632155e659
I have made a tool to parse the kernel that does not pre-process the source. That means that my parser tries to parse all the code, including code in the #else branch or code that is not often compiled because the driver is not very used (or not used at all). So, my parser sometimes reports parse error not originally detected by gcc. Here is my (first) patch. [akpm@linux-foundation.org: fix amd8111e.c] Signed-off-by: Yoann Padioleau <padator@wanadoo.fr> Acked-by: Matthew Wilcox <matthew@wil.cx> Acked-by: Wim Van Sebroeck <wim@iguana.be> Acked-by: David Woodhouse <dwmw2@infradead.org> Acked-by: Jeff Garzik <jeff@garzik.org> Acked-by: James Bottomley <James.Bottomley@steeleye.com> Cc: Russell King <rmk@arm.linux.org.uk> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2058 lines
52 KiB
C
2058 lines
52 KiB
C
/******************************************************************************
|
|
*
|
|
* (C)Copyright 1998,1999 SysKonnect,
|
|
* a business unit of Schneider & Koch & Co. Datensysteme GmbH.
|
|
*
|
|
* See the file "skfddi.c" for further information.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* The information in this file is provided "AS IS" without warranty.
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include "h/types.h"
|
|
#include "h/fddi.h"
|
|
#include "h/smc.h"
|
|
#include "h/smt_p.h"
|
|
#include <linux/bitrev.h>
|
|
|
|
#define KERNEL
|
|
#include "h/smtstate.h"
|
|
|
|
#ifndef lint
|
|
static const char ID_sccs[] = "@(#)smt.c 2.43 98/11/23 (C) SK " ;
|
|
#endif
|
|
|
|
/*
|
|
* FC in SMbuf
|
|
*/
|
|
#define m_fc(mb) ((mb)->sm_data[0])
|
|
|
|
#define SMT_TID_MAGIC 0x1f0a7b3c
|
|
|
|
#ifdef DEBUG
|
|
static const char *const smt_type_name[] = {
|
|
"SMT_00??", "SMT_INFO", "SMT_02??", "SMT_03??",
|
|
"SMT_04??", "SMT_05??", "SMT_06??", "SMT_07??",
|
|
"SMT_08??", "SMT_09??", "SMT_0A??", "SMT_0B??",
|
|
"SMT_0C??", "SMT_0D??", "SMT_0E??", "SMT_NSA"
|
|
} ;
|
|
|
|
static const char *const smt_class_name[] = {
|
|
"UNKNOWN","NIF","SIF_CONFIG","SIF_OPER","ECF","RAF","RDF",
|
|
"SRF","PMF_GET","PMF_SET","ESF"
|
|
} ;
|
|
#endif
|
|
#define LAST_CLASS (SMT_PMF_SET)
|
|
|
|
static const struct fddi_addr SMT_Unknown = {
|
|
{ 0,0,0x1f,0,0,0 }
|
|
} ;
|
|
|
|
/*
|
|
* external variables
|
|
*/
|
|
extern const struct fddi_addr fddi_broadcast ;
|
|
|
|
/*
|
|
* external functions
|
|
*/
|
|
int pcm_status_twisted(struct s_smc *smc);
|
|
|
|
/*
|
|
* function prototypes
|
|
*/
|
|
#ifdef LITTLE_ENDIAN
|
|
static int smt_swap_short(u_short s);
|
|
#endif
|
|
static int mac_index(struct s_smc *smc, int mac);
|
|
static int phy_index(struct s_smc *smc, int phy);
|
|
static int mac_con_resource_index(struct s_smc *smc, int mac);
|
|
static int phy_con_resource_index(struct s_smc *smc, int phy);
|
|
static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
|
|
int local);
|
|
static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
|
|
int fc, u_long tid, int type, int local);
|
|
static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
|
|
u_long tid, int type, int len);
|
|
static void smt_echo_test(struct s_smc *smc, int dna);
|
|
static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
|
|
u_long tid, int local);
|
|
static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
|
|
u_long tid, int local);
|
|
#ifdef LITTLE_ENDIAN
|
|
static void smt_string_swap(char *data, const char *format, int len);
|
|
#endif
|
|
static void smt_add_frame_len(SMbuf *mb, int len);
|
|
static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una);
|
|
static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde);
|
|
static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state);
|
|
static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts);
|
|
static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy);
|
|
static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency);
|
|
static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor);
|
|
static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path);
|
|
static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st);
|
|
static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy);
|
|
static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers);
|
|
static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc);
|
|
static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc);
|
|
static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc);
|
|
static void smt_fill_manufacturer(struct s_smc *smc,
|
|
struct smp_p_manufacturer *man);
|
|
static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user);
|
|
static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount);
|
|
static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
|
|
int len);
|
|
|
|
static void smt_clear_una_dna(struct s_smc *smc);
|
|
static void smt_clear_old_una_dna(struct s_smc *smc);
|
|
#ifdef CONCENTRATOR
|
|
static int entity_to_index(void);
|
|
#endif
|
|
static void update_dac(struct s_smc *smc, int report);
|
|
static int div_ratio(u_long upper, u_long lower);
|
|
#ifdef USE_CAN_ADDR
|
|
static void hwm_conv_can(struct s_smc *smc, char *data, int len);
|
|
#else
|
|
#define hwm_conv_can(smc,data,len)
|
|
#endif
|
|
|
|
|
|
static inline int is_my_addr(const struct s_smc *smc,
|
|
const struct fddi_addr *addr)
|
|
{
|
|
return(*(short *)(&addr->a[0]) ==
|
|
*(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[0])
|
|
&& *(short *)(&addr->a[2]) ==
|
|
*(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[2])
|
|
&& *(short *)(&addr->a[4]) ==
|
|
*(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[4])) ;
|
|
}
|
|
|
|
static inline int is_broadcast(const struct fddi_addr *addr)
|
|
{
|
|
return(*(u_short *)(&addr->a[0]) == 0xffff &&
|
|
*(u_short *)(&addr->a[2]) == 0xffff &&
|
|
*(u_short *)(&addr->a[4]) == 0xffff ) ;
|
|
}
|
|
|
|
static inline int is_individual(const struct fddi_addr *addr)
|
|
{
|
|
return(!(addr->a[0] & GROUP_ADDR)) ;
|
|
}
|
|
|
|
static inline int is_equal(const struct fddi_addr *addr1,
|
|
const struct fddi_addr *addr2)
|
|
{
|
|
return(*(u_short *)(&addr1->a[0]) == *(u_short *)(&addr2->a[0]) &&
|
|
*(u_short *)(&addr1->a[2]) == *(u_short *)(&addr2->a[2]) &&
|
|
*(u_short *)(&addr1->a[4]) == *(u_short *)(&addr2->a[4]) ) ;
|
|
}
|
|
|
|
/*
|
|
* list of mandatory paras in frames
|
|
*/
|
|
static const u_short plist_nif[] = { SMT_P_UNA,SMT_P_SDE,SMT_P_STATE,0 } ;
|
|
|
|
/*
|
|
* init SMT agent
|
|
*/
|
|
void smt_agent_init(struct s_smc *smc)
|
|
{
|
|
int i ;
|
|
|
|
/*
|
|
* get MAC address
|
|
*/
|
|
smc->mib.m[MAC0].fddiMACSMTAddress = smc->hw.fddi_home_addr ;
|
|
|
|
/*
|
|
* get OUI address from driver (bia == built-in-address)
|
|
*/
|
|
smc->mib.fddiSMTStationId.sid_oem[0] = 0 ;
|
|
smc->mib.fddiSMTStationId.sid_oem[1] = 0 ;
|
|
driver_get_bia(smc,&smc->mib.fddiSMTStationId.sid_node) ;
|
|
for (i = 0 ; i < 6 ; i ++) {
|
|
smc->mib.fddiSMTStationId.sid_node.a[i] =
|
|
bitrev8(smc->mib.fddiSMTStationId.sid_node.a[i]);
|
|
}
|
|
smc->mib.fddiSMTManufacturerData[0] =
|
|
smc->mib.fddiSMTStationId.sid_node.a[0] ;
|
|
smc->mib.fddiSMTManufacturerData[1] =
|
|
smc->mib.fddiSMTStationId.sid_node.a[1] ;
|
|
smc->mib.fddiSMTManufacturerData[2] =
|
|
smc->mib.fddiSMTStationId.sid_node.a[2] ;
|
|
smc->sm.smt_tid = 0 ;
|
|
smc->mib.m[MAC0].fddiMACDupAddressTest = DA_NONE ;
|
|
smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
|
|
#ifndef SLIM_SMT
|
|
smt_clear_una_dna(smc) ;
|
|
smt_clear_old_una_dna(smc) ;
|
|
#endif
|
|
for (i = 0 ; i < SMT_MAX_TEST ; i++)
|
|
smc->sm.pend[i] = 0 ;
|
|
smc->sm.please_reconnect = 0 ;
|
|
smc->sm.uniq_ticks = 0 ;
|
|
}
|
|
|
|
/*
|
|
* SMT task
|
|
* forever
|
|
* delay 30 seconds
|
|
* send NIF
|
|
* check tvu & tvd
|
|
* end
|
|
*/
|
|
void smt_agent_task(struct s_smc *smc)
|
|
{
|
|
smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
|
|
EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
|
|
DB_SMT("SMT agent task\n",0,0) ;
|
|
}
|
|
|
|
#ifndef SMT_REAL_TOKEN_CT
|
|
void smt_emulate_token_ct(struct s_smc *smc, int mac_index)
|
|
{
|
|
u_long count;
|
|
u_long time;
|
|
|
|
|
|
time = smt_get_time();
|
|
count = ((time - smc->sm.last_tok_time[mac_index]) *
|
|
100)/TICKS_PER_SECOND;
|
|
|
|
/*
|
|
* Only when ring is up we will have a token count. The
|
|
* flag is unfortunatly a single instance value. This
|
|
* doesn't matter now, because we currently have only
|
|
* one MAC instance.
|
|
*/
|
|
if (smc->hw.mac_ring_is_up){
|
|
smc->mib.m[mac_index].fddiMACToken_Ct += count;
|
|
}
|
|
|
|
/* Remember current time */
|
|
smc->sm.last_tok_time[mac_index] = time;
|
|
|
|
}
|
|
#endif
|
|
|
|
/*ARGSUSED1*/
|
|
void smt_event(struct s_smc *smc, int event)
|
|
{
|
|
u_long time ;
|
|
#ifndef SMT_REAL_TOKEN_CT
|
|
int i ;
|
|
#endif
|
|
|
|
|
|
if (smc->sm.please_reconnect) {
|
|
smc->sm.please_reconnect -- ;
|
|
if (smc->sm.please_reconnect == 0) {
|
|
/* Counted down */
|
|
queue_event(smc,EVENT_ECM,EC_CONNECT) ;
|
|
}
|
|
}
|
|
|
|
if (event == SM_FAST)
|
|
return ;
|
|
|
|
/*
|
|
* timer for periodic cleanup in driver
|
|
* reset and start the watchdog (FM2)
|
|
* ESS timer
|
|
* SBA timer
|
|
*/
|
|
smt_timer_poll(smc) ;
|
|
smt_start_watchdog(smc) ;
|
|
#ifndef SLIM_SMT
|
|
#ifndef BOOT
|
|
#ifdef ESS
|
|
ess_timer_poll(smc) ;
|
|
#endif
|
|
#endif
|
|
#ifdef SBA
|
|
sba_timer_poll(smc) ;
|
|
#endif
|
|
|
|
smt_srf_event(smc,0,0,0) ;
|
|
|
|
#endif /* no SLIM_SMT */
|
|
|
|
time = smt_get_time() ;
|
|
|
|
if (time - smc->sm.smt_last_lem >= TICKS_PER_SECOND*8) {
|
|
/*
|
|
* Use 8 sec. for the time intervall, it simplifies the
|
|
* LER estimation.
|
|
*/
|
|
struct fddi_mib_m *mib ;
|
|
u_long upper ;
|
|
u_long lower ;
|
|
int cond ;
|
|
int port;
|
|
struct s_phy *phy ;
|
|
/*
|
|
* calculate LEM bit error rate
|
|
*/
|
|
sm_lem_evaluate(smc) ;
|
|
smc->sm.smt_last_lem = time ;
|
|
|
|
/*
|
|
* check conditions
|
|
*/
|
|
#ifndef SLIM_SMT
|
|
mac_update_counter(smc) ;
|
|
mib = smc->mib.m ;
|
|
upper =
|
|
(mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) +
|
|
(mib->fddiMACError_Ct - mib->fddiMACOld_Error_Ct) ;
|
|
lower =
|
|
(mib->fddiMACFrame_Ct - mib->fddiMACOld_Frame_Ct) +
|
|
(mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) ;
|
|
mib->fddiMACFrameErrorRatio = div_ratio(upper,lower) ;
|
|
|
|
cond =
|
|
((!mib->fddiMACFrameErrorThreshold &&
|
|
mib->fddiMACError_Ct != mib->fddiMACOld_Error_Ct) ||
|
|
(mib->fddiMACFrameErrorRatio >
|
|
mib->fddiMACFrameErrorThreshold)) ;
|
|
|
|
if (cond != mib->fddiMACFrameErrorFlag)
|
|
smt_srf_event(smc,SMT_COND_MAC_FRAME_ERROR,
|
|
INDEX_MAC,cond) ;
|
|
|
|
upper =
|
|
(mib->fddiMACNotCopied_Ct - mib->fddiMACOld_NotCopied_Ct) ;
|
|
lower =
|
|
upper +
|
|
(mib->fddiMACCopied_Ct - mib->fddiMACOld_Copied_Ct) ;
|
|
mib->fddiMACNotCopiedRatio = div_ratio(upper,lower) ;
|
|
|
|
cond =
|
|
((!mib->fddiMACNotCopiedThreshold &&
|
|
mib->fddiMACNotCopied_Ct !=
|
|
mib->fddiMACOld_NotCopied_Ct)||
|
|
(mib->fddiMACNotCopiedRatio >
|
|
mib->fddiMACNotCopiedThreshold)) ;
|
|
|
|
if (cond != mib->fddiMACNotCopiedFlag)
|
|
smt_srf_event(smc,SMT_COND_MAC_NOT_COPIED,
|
|
INDEX_MAC,cond) ;
|
|
|
|
/*
|
|
* set old values
|
|
*/
|
|
mib->fddiMACOld_Frame_Ct = mib->fddiMACFrame_Ct ;
|
|
mib->fddiMACOld_Copied_Ct = mib->fddiMACCopied_Ct ;
|
|
mib->fddiMACOld_Error_Ct = mib->fddiMACError_Ct ;
|
|
mib->fddiMACOld_Lost_Ct = mib->fddiMACLost_Ct ;
|
|
mib->fddiMACOld_NotCopied_Ct = mib->fddiMACNotCopied_Ct ;
|
|
|
|
/*
|
|
* Check port EBError Condition
|
|
*/
|
|
for (port = 0; port < NUMPHYS; port ++) {
|
|
phy = &smc->y[port] ;
|
|
|
|
if (!phy->mib->fddiPORTHardwarePresent) {
|
|
continue;
|
|
}
|
|
|
|
cond = (phy->mib->fddiPORTEBError_Ct -
|
|
phy->mib->fddiPORTOldEBError_Ct > 5) ;
|
|
|
|
/* If ratio is more than 5 in 8 seconds
|
|
* Set the condition.
|
|
*/
|
|
smt_srf_event(smc,SMT_COND_PORT_EB_ERROR,
|
|
(int) (INDEX_PORT+ phy->np) ,cond) ;
|
|
|
|
/*
|
|
* set old values
|
|
*/
|
|
phy->mib->fddiPORTOldEBError_Ct =
|
|
phy->mib->fddiPORTEBError_Ct ;
|
|
}
|
|
|
|
#endif /* no SLIM_SMT */
|
|
}
|
|
|
|
#ifndef SLIM_SMT
|
|
|
|
if (time - smc->sm.smt_last_notify >= (u_long)
|
|
(smc->mib.fddiSMTTT_Notify * TICKS_PER_SECOND) ) {
|
|
/*
|
|
* we can either send an announcement or a request
|
|
* a request will trigger a reply so that we can update
|
|
* our dna
|
|
* note: same tid must be used until reply is received
|
|
*/
|
|
if (!smc->sm.pend[SMT_TID_NIF])
|
|
smc->sm.pend[SMT_TID_NIF] = smt_get_tid(smc) ;
|
|
smt_send_nif(smc,&fddi_broadcast, FC_SMT_NSA,
|
|
smc->sm.pend[SMT_TID_NIF], SMT_REQUEST,0) ;
|
|
smc->sm.smt_last_notify = time ;
|
|
}
|
|
|
|
/*
|
|
* check timer
|
|
*/
|
|
if (smc->sm.smt_tvu &&
|
|
time - smc->sm.smt_tvu > 228*TICKS_PER_SECOND) {
|
|
DB_SMT("SMT : UNA expired\n",0,0) ;
|
|
smc->sm.smt_tvu = 0 ;
|
|
|
|
if (!is_equal(&smc->mib.m[MAC0].fddiMACUpstreamNbr,
|
|
&SMT_Unknown)){
|
|
/* Do not update unknown address */
|
|
smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
|
|
smc->mib.m[MAC0].fddiMACUpstreamNbr ;
|
|
}
|
|
smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
|
|
smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
|
|
/*
|
|
* Make sure the fddiMACUNDA_Flag = FALSE is
|
|
* included in the SRF so we don't generate
|
|
* a separate SRF for the deassertion of this
|
|
* condition
|
|
*/
|
|
update_dac(smc,0) ;
|
|
smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
|
|
INDEX_MAC,0) ;
|
|
}
|
|
if (smc->sm.smt_tvd &&
|
|
time - smc->sm.smt_tvd > 228*TICKS_PER_SECOND) {
|
|
DB_SMT("SMT : DNA expired\n",0,0) ;
|
|
smc->sm.smt_tvd = 0 ;
|
|
if (!is_equal(&smc->mib.m[MAC0].fddiMACDownstreamNbr,
|
|
&SMT_Unknown)){
|
|
/* Do not update unknown address */
|
|
smc->mib.m[MAC0].fddiMACOldDownstreamNbr=
|
|
smc->mib.m[MAC0].fddiMACDownstreamNbr ;
|
|
}
|
|
smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
|
|
smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
|
|
INDEX_MAC,0) ;
|
|
}
|
|
|
|
#endif /* no SLIM_SMT */
|
|
|
|
#ifndef SMT_REAL_TOKEN_CT
|
|
/*
|
|
* Token counter emulation section. If hardware supports the token
|
|
* count, the token counter will be updated in mac_update_counter.
|
|
*/
|
|
for (i = MAC0; i < NUMMACS; i++ ){
|
|
if (time - smc->sm.last_tok_time[i] > 2*TICKS_PER_SECOND ){
|
|
smt_emulate_token_ct( smc, i );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
|
|
EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
|
|
}
|
|
|
|
static int div_ratio(u_long upper, u_long lower)
|
|
{
|
|
if ((upper<<16L) < upper)
|
|
upper = 0xffff0000L ;
|
|
else
|
|
upper <<= 16L ;
|
|
if (!lower)
|
|
return(0) ;
|
|
return((int)(upper/lower)) ;
|
|
}
|
|
|
|
#ifndef SLIM_SMT
|
|
|
|
/*
|
|
* receive packet handler
|
|
*/
|
|
void smt_received_pack(struct s_smc *smc, SMbuf *mb, int fs)
|
|
/* int fs; frame status */
|
|
{
|
|
struct smt_header *sm ;
|
|
int local ;
|
|
|
|
int illegal = 0 ;
|
|
|
|
switch (m_fc(mb)) {
|
|
case FC_SMT_INFO :
|
|
case FC_SMT_LAN_LOC :
|
|
case FC_SMT_LOC :
|
|
case FC_SMT_NSA :
|
|
break ;
|
|
default :
|
|
smt_free_mbuf(smc,mb) ;
|
|
return ;
|
|
}
|
|
|
|
smc->mib.m[MAC0].fddiMACSMTCopied_Ct++ ;
|
|
sm = smtod(mb,struct smt_header *) ;
|
|
local = ((fs & L_INDICATOR) != 0) ;
|
|
hwm_conv_can(smc,(char *)sm,12) ;
|
|
|
|
/* check destination address */
|
|
if (is_individual(&sm->smt_dest) && !is_my_addr(smc,&sm->smt_dest)) {
|
|
smt_free_mbuf(smc,mb) ;
|
|
return ;
|
|
}
|
|
#if 0 /* for DUP recognition, do NOT filter them */
|
|
/* ignore loop back packets */
|
|
if (is_my_addr(smc,&sm->smt_source) && !local) {
|
|
smt_free_mbuf(smc,mb) ;
|
|
return ;
|
|
}
|
|
#endif
|
|
|
|
smt_swap_para(sm,(int) mb->sm_len,1) ;
|
|
DB_SMT("SMT : received packet [%s] at 0x%x\n",
|
|
smt_type_name[m_fc(mb) & 0xf],sm) ;
|
|
DB_SMT("SMT : version %d, class %s\n",sm->smt_version,
|
|
smt_class_name[(sm->smt_class>LAST_CLASS)?0 : sm->smt_class]) ;
|
|
|
|
#ifdef SBA
|
|
/*
|
|
* check if NSA frame
|
|
*/
|
|
if (m_fc(mb) == FC_SMT_NSA && sm->smt_class == SMT_NIF &&
|
|
(sm->smt_type == SMT_ANNOUNCE || sm->smt_type == SMT_REQUEST)) {
|
|
smc->sba.sm = sm ;
|
|
sba(smc,NIF) ;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* ignore any packet with NSA and A-indicator set
|
|
*/
|
|
if ( (fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) {
|
|
DB_SMT("SMT : ignoring NSA with A-indicator set from %s\n",
|
|
addr_to_string(&sm->smt_source),0) ;
|
|
smt_free_mbuf(smc,mb) ;
|
|
return ;
|
|
}
|
|
|
|
/*
|
|
* ignore frames with illegal length
|
|
*/
|
|
if (((sm->smt_class == SMT_ECF) && (sm->smt_len > SMT_MAX_ECHO_LEN)) ||
|
|
((sm->smt_class != SMT_ECF) && (sm->smt_len > SMT_MAX_INFO_LEN))) {
|
|
smt_free_mbuf(smc,mb) ;
|
|
return ;
|
|
}
|
|
|
|
/*
|
|
* check SMT version
|
|
*/
|
|
switch (sm->smt_class) {
|
|
case SMT_NIF :
|
|
case SMT_SIF_CONFIG :
|
|
case SMT_SIF_OPER :
|
|
case SMT_ECF :
|
|
if (sm->smt_version != SMT_VID)
|
|
illegal = 1;
|
|
break ;
|
|
default :
|
|
if (sm->smt_version != SMT_VID_2)
|
|
illegal = 1;
|
|
break ;
|
|
}
|
|
if (illegal) {
|
|
DB_SMT("SMT : version = %d, dest = %s\n",
|
|
sm->smt_version,addr_to_string(&sm->smt_source)) ;
|
|
smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_VERSION,local) ;
|
|
smt_free_mbuf(smc,mb) ;
|
|
return ;
|
|
}
|
|
if ((sm->smt_len > mb->sm_len - sizeof(struct smt_header)) ||
|
|
((sm->smt_len & 3) && (sm->smt_class != SMT_ECF))) {
|
|
DB_SMT("SMT: info length error, len = %d\n",sm->smt_len,0) ;
|
|
smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,local) ;
|
|
smt_free_mbuf(smc,mb) ;
|
|
return ;
|
|
}
|
|
switch (sm->smt_class) {
|
|
case SMT_NIF :
|
|
if (smt_check_para(smc,sm,plist_nif)) {
|
|
DB_SMT("SMT: NIF with para problem, ignoring\n",0,0) ;
|
|
break ;
|
|
} ;
|
|
switch (sm->smt_type) {
|
|
case SMT_ANNOUNCE :
|
|
case SMT_REQUEST :
|
|
if (!(fs & C_INDICATOR) && m_fc(mb) == FC_SMT_NSA
|
|
&& is_broadcast(&sm->smt_dest)) {
|
|
struct smt_p_state *st ;
|
|
|
|
/* set my UNA */
|
|
if (!is_equal(
|
|
&smc->mib.m[MAC0].fddiMACUpstreamNbr,
|
|
&sm->smt_source)) {
|
|
DB_SMT("SMT : updated my UNA = %s\n",
|
|
addr_to_string(&sm->smt_source),0) ;
|
|
if (!is_equal(&smc->mib.m[MAC0].
|
|
fddiMACUpstreamNbr,&SMT_Unknown)){
|
|
/* Do not update unknown address */
|
|
smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
|
|
smc->mib.m[MAC0].fddiMACUpstreamNbr ;
|
|
}
|
|
|
|
smc->mib.m[MAC0].fddiMACUpstreamNbr =
|
|
sm->smt_source ;
|
|
smt_srf_event(smc,
|
|
SMT_EVENT_MAC_NEIGHBOR_CHANGE,
|
|
INDEX_MAC,0) ;
|
|
smt_echo_test(smc,0) ;
|
|
}
|
|
smc->sm.smt_tvu = smt_get_time() ;
|
|
st = (struct smt_p_state *)
|
|
sm_to_para(smc,sm,SMT_P_STATE) ;
|
|
if (st) {
|
|
smc->mib.m[MAC0].fddiMACUNDA_Flag =
|
|
(st->st_dupl_addr & SMT_ST_MY_DUPA) ?
|
|
TRUE : FALSE ;
|
|
update_dac(smc,1) ;
|
|
}
|
|
}
|
|
if ((sm->smt_type == SMT_REQUEST) &&
|
|
is_individual(&sm->smt_source) &&
|
|
((!(fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) ||
|
|
(m_fc(mb) != FC_SMT_NSA))) {
|
|
DB_SMT("SMT : replying to NIF request %s\n",
|
|
addr_to_string(&sm->smt_source),0) ;
|
|
smt_send_nif(smc,&sm->smt_source,
|
|
FC_SMT_INFO,
|
|
sm->smt_tid,
|
|
SMT_REPLY,local) ;
|
|
}
|
|
break ;
|
|
case SMT_REPLY :
|
|
DB_SMT("SMT : received NIF response from %s\n",
|
|
addr_to_string(&sm->smt_source),0) ;
|
|
if (fs & A_INDICATOR) {
|
|
smc->sm.pend[SMT_TID_NIF] = 0 ;
|
|
DB_SMT("SMT : duplicate address\n",0,0) ;
|
|
smc->mib.m[MAC0].fddiMACDupAddressTest =
|
|
DA_FAILED ;
|
|
smc->r.dup_addr_test = DA_FAILED ;
|
|
queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
|
|
smc->mib.m[MAC0].fddiMACDA_Flag = TRUE ;
|
|
update_dac(smc,1) ;
|
|
break ;
|
|
}
|
|
if (sm->smt_tid == smc->sm.pend[SMT_TID_NIF]) {
|
|
smc->sm.pend[SMT_TID_NIF] = 0 ;
|
|
/* set my DNA */
|
|
if (!is_equal(
|
|
&smc->mib.m[MAC0].fddiMACDownstreamNbr,
|
|
&sm->smt_source)) {
|
|
DB_SMT("SMT : updated my DNA\n",0,0) ;
|
|
if (!is_equal(&smc->mib.m[MAC0].
|
|
fddiMACDownstreamNbr, &SMT_Unknown)){
|
|
/* Do not update unknown address */
|
|
smc->mib.m[MAC0].fddiMACOldDownstreamNbr =
|
|
smc->mib.m[MAC0].fddiMACDownstreamNbr ;
|
|
}
|
|
|
|
smc->mib.m[MAC0].fddiMACDownstreamNbr =
|
|
sm->smt_source ;
|
|
smt_srf_event(smc,
|
|
SMT_EVENT_MAC_NEIGHBOR_CHANGE,
|
|
INDEX_MAC,0) ;
|
|
smt_echo_test(smc,1) ;
|
|
}
|
|
smc->mib.m[MAC0].fddiMACDA_Flag = FALSE ;
|
|
update_dac(smc,1) ;
|
|
smc->sm.smt_tvd = smt_get_time() ;
|
|
smc->mib.m[MAC0].fddiMACDupAddressTest =
|
|
DA_PASSED ;
|
|
if (smc->r.dup_addr_test != DA_PASSED) {
|
|
smc->r.dup_addr_test = DA_PASSED ;
|
|
queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
|
|
}
|
|
}
|
|
else if (sm->smt_tid ==
|
|
smc->sm.pend[SMT_TID_NIF_TEST]) {
|
|
DB_SMT("SMT : NIF test TID ok\n",0,0) ;
|
|
}
|
|
else {
|
|
DB_SMT("SMT : expected TID %lx, got %lx\n",
|
|
smc->sm.pend[SMT_TID_NIF],sm->smt_tid) ;
|
|
}
|
|
break ;
|
|
default :
|
|
illegal = 2 ;
|
|
break ;
|
|
}
|
|
break ;
|
|
case SMT_SIF_CONFIG : /* station information */
|
|
if (sm->smt_type != SMT_REQUEST)
|
|
break ;
|
|
DB_SMT("SMT : replying to SIF Config request from %s\n",
|
|
addr_to_string(&sm->smt_source),0) ;
|
|
smt_send_sif_config(smc,&sm->smt_source,sm->smt_tid,local) ;
|
|
break ;
|
|
case SMT_SIF_OPER : /* station information */
|
|
if (sm->smt_type != SMT_REQUEST)
|
|
break ;
|
|
DB_SMT("SMT : replying to SIF Operation request from %s\n",
|
|
addr_to_string(&sm->smt_source),0) ;
|
|
smt_send_sif_operation(smc,&sm->smt_source,sm->smt_tid,local) ;
|
|
break ;
|
|
case SMT_ECF : /* echo frame */
|
|
switch (sm->smt_type) {
|
|
case SMT_REPLY :
|
|
smc->mib.priv.fddiPRIVECF_Reply_Rx++ ;
|
|
DB_SMT("SMT: received ECF reply from %s\n",
|
|
addr_to_string(&sm->smt_source),0) ;
|
|
if (sm_to_para(smc,sm,SMT_P_ECHODATA) == 0) {
|
|
DB_SMT("SMT: ECHODATA missing\n",0,0) ;
|
|
break ;
|
|
}
|
|
if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF]) {
|
|
DB_SMT("SMT : ECF test TID ok\n",0,0) ;
|
|
}
|
|
else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_UNA]) {
|
|
DB_SMT("SMT : ECF test UNA ok\n",0,0) ;
|
|
}
|
|
else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_DNA]) {
|
|
DB_SMT("SMT : ECF test DNA ok\n",0,0) ;
|
|
}
|
|
else {
|
|
DB_SMT("SMT : expected TID %lx, got %lx\n",
|
|
smc->sm.pend[SMT_TID_ECF],
|
|
sm->smt_tid) ;
|
|
}
|
|
break ;
|
|
case SMT_REQUEST :
|
|
smc->mib.priv.fddiPRIVECF_Req_Rx++ ;
|
|
{
|
|
if (sm->smt_len && !sm_to_para(smc,sm,SMT_P_ECHODATA)) {
|
|
DB_SMT("SMT: ECF with para problem,sending RDF\n",0,0) ;
|
|
smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,
|
|
local) ;
|
|
break ;
|
|
}
|
|
DB_SMT("SMT - sending ECF reply to %s\n",
|
|
addr_to_string(&sm->smt_source),0) ;
|
|
|
|
/* set destination addr. & reply */
|
|
sm->smt_dest = sm->smt_source ;
|
|
sm->smt_type = SMT_REPLY ;
|
|
dump_smt(smc,sm,"ECF REPLY") ;
|
|
smc->mib.priv.fddiPRIVECF_Reply_Tx++ ;
|
|
smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
|
|
return ; /* DON'T free mbuf */
|
|
}
|
|
default :
|
|
illegal = 1 ;
|
|
break ;
|
|
}
|
|
break ;
|
|
#ifndef BOOT
|
|
case SMT_RAF : /* resource allocation */
|
|
#ifdef ESS
|
|
DB_ESSN(2,"ESS: RAF frame received\n",0,0) ;
|
|
fs = ess_raf_received_pack(smc,mb,sm,fs) ;
|
|
#endif
|
|
|
|
#ifdef SBA
|
|
DB_SBAN(2,"SBA: RAF frame received\n",0,0) ;
|
|
sba_raf_received_pack(smc,sm,fs) ;
|
|
#endif
|
|
break ;
|
|
case SMT_RDF : /* request denied */
|
|
smc->mib.priv.fddiPRIVRDF_Rx++ ;
|
|
break ;
|
|
case SMT_ESF : /* extended service - not supported */
|
|
if (sm->smt_type == SMT_REQUEST) {
|
|
DB_SMT("SMT - received ESF, sending RDF\n",0,0) ;
|
|
smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
|
|
}
|
|
break ;
|
|
case SMT_PMF_GET :
|
|
case SMT_PMF_SET :
|
|
if (sm->smt_type != SMT_REQUEST)
|
|
break ;
|
|
/* update statistics */
|
|
if (sm->smt_class == SMT_PMF_GET)
|
|
smc->mib.priv.fddiPRIVPMF_Get_Rx++ ;
|
|
else
|
|
smc->mib.priv.fddiPRIVPMF_Set_Rx++ ;
|
|
/*
|
|
* ignore PMF SET with I/G set
|
|
*/
|
|
if ((sm->smt_class == SMT_PMF_SET) &&
|
|
!is_individual(&sm->smt_dest)) {
|
|
DB_SMT("SMT: ignoring PMF-SET with I/G set\n",0,0) ;
|
|
break ;
|
|
}
|
|
smt_pmf_received_pack(smc,mb, local) ;
|
|
break ;
|
|
case SMT_SRF :
|
|
dump_smt(smc,sm,"SRF received") ;
|
|
break ;
|
|
default :
|
|
if (sm->smt_type != SMT_REQUEST)
|
|
break ;
|
|
/*
|
|
* For frames with unknown class:
|
|
* we need to send a RDF frame according to 8.1.3.1.1,
|
|
* only if it is a REQUEST.
|
|
*/
|
|
DB_SMT("SMT : class = %d, send RDF to %s\n",
|
|
sm->smt_class, addr_to_string(&sm->smt_source)) ;
|
|
|
|
smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
|
|
break ;
|
|
#endif
|
|
}
|
|
if (illegal) {
|
|
DB_SMT("SMT: discarding invalid frame, reason = %d\n",
|
|
illegal,0) ;
|
|
}
|
|
smt_free_mbuf(smc,mb) ;
|
|
}
|
|
|
|
static void update_dac(struct s_smc *smc, int report)
|
|
{
|
|
int cond ;
|
|
|
|
cond = ( smc->mib.m[MAC0].fddiMACUNDA_Flag |
|
|
smc->mib.m[MAC0].fddiMACDA_Flag) != 0 ;
|
|
if (report && (cond != smc->mib.m[MAC0].fddiMACDuplicateAddressCond))
|
|
smt_srf_event(smc, SMT_COND_MAC_DUP_ADDR,INDEX_MAC,cond) ;
|
|
else
|
|
smc->mib.m[MAC0].fddiMACDuplicateAddressCond = cond ;
|
|
}
|
|
|
|
/*
|
|
* send SMT frame
|
|
* set source address
|
|
* set station ID
|
|
* send frame
|
|
*/
|
|
void smt_send_frame(struct s_smc *smc, SMbuf *mb, int fc, int local)
|
|
/* SMbuf *mb; buffer to send */
|
|
/* int fc; FC value */
|
|
{
|
|
struct smt_header *sm ;
|
|
|
|
if (!smc->r.sm_ma_avail && !local) {
|
|
smt_free_mbuf(smc,mb) ;
|
|
return ;
|
|
}
|
|
sm = smtod(mb,struct smt_header *) ;
|
|
sm->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
|
|
sm->smt_sid = smc->mib.fddiSMTStationId ;
|
|
|
|
smt_swap_para(sm,(int) mb->sm_len,0) ; /* swap para & header */
|
|
hwm_conv_can(smc,(char *)sm,12) ; /* convert SA and DA */
|
|
smc->mib.m[MAC0].fddiMACSMTTransmit_Ct++ ;
|
|
smt_send_mbuf(smc,mb,local ? FC_SMT_LOC : fc) ;
|
|
}
|
|
|
|
/*
|
|
* generate and send RDF
|
|
*/
|
|
static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
|
|
int local)
|
|
/* SMbuf *rej; mbuf of offending frame */
|
|
/* int fc; FC of denied frame */
|
|
/* int reason; reason code */
|
|
{
|
|
SMbuf *mb ;
|
|
struct smt_header *sm ; /* header of offending frame */
|
|
struct smt_rdf *rdf ;
|
|
int len ;
|
|
int frame_len ;
|
|
|
|
sm = smtod(rej,struct smt_header *) ;
|
|
if (sm->smt_type != SMT_REQUEST)
|
|
return ;
|
|
|
|
DB_SMT("SMT: sending RDF to %s,reason = 0x%x\n",
|
|
addr_to_string(&sm->smt_source),reason) ;
|
|
|
|
|
|
/*
|
|
* note: get framelength from MAC length, NOT from SMT header
|
|
* smt header length is included in sm_len
|
|
*/
|
|
frame_len = rej->sm_len ;
|
|
|
|
if (!(mb=smt_build_frame(smc,SMT_RDF,SMT_REPLY,sizeof(struct smt_rdf))))
|
|
return ;
|
|
rdf = smtod(mb,struct smt_rdf *) ;
|
|
rdf->smt.smt_tid = sm->smt_tid ; /* use TID from sm */
|
|
rdf->smt.smt_dest = sm->smt_source ; /* set dest = source */
|
|
|
|
/* set P12 */
|
|
rdf->reason.para.p_type = SMT_P_REASON ;
|
|
rdf->reason.para.p_len = sizeof(struct smt_p_reason) - PARA_LEN ;
|
|
rdf->reason.rdf_reason = reason ;
|
|
|
|
/* set P14 */
|
|
rdf->version.para.p_type = SMT_P_VERSION ;
|
|
rdf->version.para.p_len = sizeof(struct smt_p_version) - PARA_LEN ;
|
|
rdf->version.v_pad = 0 ;
|
|
rdf->version.v_n = 1 ;
|
|
rdf->version.v_index = 1 ;
|
|
rdf->version.v_version[0] = SMT_VID_2 ;
|
|
rdf->version.v_pad2 = 0 ;
|
|
|
|
/* set P13 */
|
|
if ((unsigned) frame_len <= SMT_MAX_INFO_LEN - sizeof(*rdf) +
|
|
2*sizeof(struct smt_header))
|
|
len = frame_len ;
|
|
else
|
|
len = SMT_MAX_INFO_LEN - sizeof(*rdf) +
|
|
2*sizeof(struct smt_header) ;
|
|
/* make length multiple of 4 */
|
|
len &= ~3 ;
|
|
rdf->refused.para.p_type = SMT_P_REFUSED ;
|
|
/* length of para is smt_frame + ref_fc */
|
|
rdf->refused.para.p_len = len + 4 ;
|
|
rdf->refused.ref_fc = fc ;
|
|
|
|
/* swap it back */
|
|
smt_swap_para(sm,frame_len,0) ;
|
|
|
|
memcpy((char *) &rdf->refused.ref_header,(char *) sm,len) ;
|
|
|
|
len -= sizeof(struct smt_header) ;
|
|
mb->sm_len += len ;
|
|
rdf->smt.smt_len += len ;
|
|
|
|
dump_smt(smc,(struct smt_header *)rdf,"RDF") ;
|
|
smc->mib.priv.fddiPRIVRDF_Tx++ ;
|
|
smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
|
|
}
|
|
|
|
/*
|
|
* generate and send NIF
|
|
*/
|
|
static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
|
|
int fc, u_long tid, int type, int local)
|
|
/* struct fddi_addr *dest; dest address */
|
|
/* int fc; frame control */
|
|
/* u_long tid; transaction id */
|
|
/* int type; frame type */
|
|
{
|
|
struct smt_nif *nif ;
|
|
SMbuf *mb ;
|
|
|
|
if (!(mb = smt_build_frame(smc,SMT_NIF,type,sizeof(struct smt_nif))))
|
|
return ;
|
|
nif = smtod(mb, struct smt_nif *) ;
|
|
smt_fill_una(smc,&nif->una) ; /* set UNA */
|
|
smt_fill_sde(smc,&nif->sde) ; /* set station descriptor */
|
|
smt_fill_state(smc,&nif->state) ; /* set state information */
|
|
#ifdef SMT6_10
|
|
smt_fill_fsc(smc,&nif->fsc) ; /* set frame status cap. */
|
|
#endif
|
|
nif->smt.smt_dest = *dest ; /* destination address */
|
|
nif->smt.smt_tid = tid ; /* transaction ID */
|
|
dump_smt(smc,(struct smt_header *)nif,"NIF") ;
|
|
smt_send_frame(smc,mb,fc,local) ;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
/*
|
|
* send NIF request (test purpose)
|
|
*/
|
|
static void smt_send_nif_request(struct s_smc *smc, struct fddi_addr *dest)
|
|
{
|
|
smc->sm.pend[SMT_TID_NIF_TEST] = smt_get_tid(smc) ;
|
|
smt_send_nif(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_NIF_TEST],
|
|
SMT_REQUEST,0) ;
|
|
}
|
|
|
|
/*
|
|
* send ECF request (test purpose)
|
|
*/
|
|
static void smt_send_ecf_request(struct s_smc *smc, struct fddi_addr *dest,
|
|
int len)
|
|
{
|
|
smc->sm.pend[SMT_TID_ECF] = smt_get_tid(smc) ;
|
|
smt_send_ecf(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_ECF],
|
|
SMT_REQUEST,len) ;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* echo test
|
|
*/
|
|
static void smt_echo_test(struct s_smc *smc, int dna)
|
|
{
|
|
u_long tid ;
|
|
|
|
smc->sm.pend[dna ? SMT_TID_ECF_DNA : SMT_TID_ECF_UNA] =
|
|
tid = smt_get_tid(smc) ;
|
|
smt_send_ecf(smc, dna ?
|
|
&smc->mib.m[MAC0].fddiMACDownstreamNbr :
|
|
&smc->mib.m[MAC0].fddiMACUpstreamNbr,
|
|
FC_SMT_INFO,tid, SMT_REQUEST, (SMT_TEST_ECHO_LEN & ~3)-8) ;
|
|
}
|
|
|
|
/*
|
|
* generate and send ECF
|
|
*/
|
|
static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
|
|
u_long tid, int type, int len)
|
|
/* struct fddi_addr *dest; dest address */
|
|
/* int fc; frame control */
|
|
/* u_long tid; transaction id */
|
|
/* int type; frame type */
|
|
/* int len; frame length */
|
|
{
|
|
struct smt_ecf *ecf ;
|
|
SMbuf *mb ;
|
|
|
|
if (!(mb = smt_build_frame(smc,SMT_ECF,type,SMT_ECF_LEN + len)))
|
|
return ;
|
|
ecf = smtod(mb, struct smt_ecf *) ;
|
|
|
|
smt_fill_echo(smc,&ecf->ec_echo,tid,len) ; /* set ECHO */
|
|
ecf->smt.smt_dest = *dest ; /* destination address */
|
|
ecf->smt.smt_tid = tid ; /* transaction ID */
|
|
smc->mib.priv.fddiPRIVECF_Req_Tx++ ;
|
|
smt_send_frame(smc,mb,fc,0) ;
|
|
}
|
|
|
|
/*
|
|
* generate and send SIF config response
|
|
*/
|
|
|
|
static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
|
|
u_long tid, int local)
|
|
/* struct fddi_addr *dest; dest address */
|
|
/* u_long tid; transaction id */
|
|
{
|
|
struct smt_sif_config *sif ;
|
|
SMbuf *mb ;
|
|
int len ;
|
|
if (!(mb = smt_build_frame(smc,SMT_SIF_CONFIG,SMT_REPLY,
|
|
SIZEOF_SMT_SIF_CONFIG)))
|
|
return ;
|
|
|
|
sif = smtod(mb, struct smt_sif_config *) ;
|
|
smt_fill_timestamp(smc,&sif->ts) ; /* set time stamp */
|
|
smt_fill_sde(smc,&sif->sde) ; /* set station descriptor */
|
|
smt_fill_version(smc,&sif->version) ; /* set version information */
|
|
smt_fill_state(smc,&sif->state) ; /* set state information */
|
|
smt_fill_policy(smc,&sif->policy) ; /* set station policy */
|
|
smt_fill_latency(smc,&sif->latency); /* set station latency */
|
|
smt_fill_neighbor(smc,&sif->neighbor); /* set station neighbor */
|
|
smt_fill_setcount(smc,&sif->setcount) ; /* set count */
|
|
len = smt_fill_path(smc,&sif->path); /* set station path descriptor*/
|
|
sif->smt.smt_dest = *dest ; /* destination address */
|
|
sif->smt.smt_tid = tid ; /* transaction ID */
|
|
smt_add_frame_len(mb,len) ; /* adjust length fields */
|
|
dump_smt(smc,(struct smt_header *)sif,"SIF Configuration Reply") ;
|
|
smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
|
|
}
|
|
|
|
/*
|
|
* generate and send SIF operation response
|
|
*/
|
|
|
|
static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
|
|
u_long tid, int local)
|
|
/* struct fddi_addr *dest; dest address */
|
|
/* u_long tid; transaction id */
|
|
{
|
|
struct smt_sif_operation *sif ;
|
|
SMbuf *mb ;
|
|
int ports ;
|
|
int i ;
|
|
|
|
ports = NUMPHYS ;
|
|
#ifndef CONCENTRATOR
|
|
if (smc->s.sas == SMT_SAS)
|
|
ports = 1 ;
|
|
#endif
|
|
|
|
if (!(mb = smt_build_frame(smc,SMT_SIF_OPER,SMT_REPLY,
|
|
SIZEOF_SMT_SIF_OPERATION+ports*sizeof(struct smt_p_lem))))
|
|
return ;
|
|
sif = smtod(mb, struct smt_sif_operation *) ;
|
|
smt_fill_timestamp(smc,&sif->ts) ; /* set time stamp */
|
|
smt_fill_mac_status(smc,&sif->status) ; /* set mac status */
|
|
smt_fill_mac_counter(smc,&sif->mc) ; /* set mac counter field */
|
|
smt_fill_mac_fnc(smc,&sif->fnc) ; /* set frame not copied counter */
|
|
smt_fill_manufacturer(smc,&sif->man) ; /* set manufacturer field */
|
|
smt_fill_user(smc,&sif->user) ; /* set user field */
|
|
smt_fill_setcount(smc,&sif->setcount) ; /* set count */
|
|
/*
|
|
* set link error mon information
|
|
*/
|
|
if (ports == 1) {
|
|
smt_fill_lem(smc,sif->lem,PS) ;
|
|
}
|
|
else {
|
|
for (i = 0 ; i < ports ; i++) {
|
|
smt_fill_lem(smc,&sif->lem[i],i) ;
|
|
}
|
|
}
|
|
|
|
sif->smt.smt_dest = *dest ; /* destination address */
|
|
sif->smt.smt_tid = tid ; /* transaction ID */
|
|
dump_smt(smc,(struct smt_header *)sif,"SIF Operation Reply") ;
|
|
smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
|
|
}
|
|
|
|
/*
|
|
* get and initialize SMT frame
|
|
*/
|
|
SMbuf *smt_build_frame(struct s_smc *smc, int class, int type,
|
|
int length)
|
|
{
|
|
SMbuf *mb ;
|
|
struct smt_header *smt ;
|
|
|
|
#if 0
|
|
if (!smc->r.sm_ma_avail) {
|
|
return(0) ;
|
|
}
|
|
#endif
|
|
if (!(mb = smt_get_mbuf(smc)))
|
|
return(mb) ;
|
|
|
|
mb->sm_len = length ;
|
|
smt = smtod(mb, struct smt_header *) ;
|
|
smt->smt_dest = fddi_broadcast ; /* set dest = broadcast */
|
|
smt->smt_class = class ;
|
|
smt->smt_type = type ;
|
|
switch (class) {
|
|
case SMT_NIF :
|
|
case SMT_SIF_CONFIG :
|
|
case SMT_SIF_OPER :
|
|
case SMT_ECF :
|
|
smt->smt_version = SMT_VID ;
|
|
break ;
|
|
default :
|
|
smt->smt_version = SMT_VID_2 ;
|
|
break ;
|
|
}
|
|
smt->smt_tid = smt_get_tid(smc) ; /* set transaction ID */
|
|
smt->smt_pad = 0 ;
|
|
smt->smt_len = length - sizeof(struct smt_header) ;
|
|
return(mb) ;
|
|
}
|
|
|
|
static void smt_add_frame_len(SMbuf *mb, int len)
|
|
{
|
|
struct smt_header *smt ;
|
|
|
|
smt = smtod(mb, struct smt_header *) ;
|
|
smt->smt_len += len ;
|
|
mb->sm_len += len ;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* fill values in UNA parameter
|
|
*/
|
|
static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una)
|
|
{
|
|
SMTSETPARA(una,SMT_P_UNA) ;
|
|
una->una_pad = 0 ;
|
|
una->una_node = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
|
|
}
|
|
|
|
/*
|
|
* fill values in SDE parameter
|
|
*/
|
|
static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde)
|
|
{
|
|
SMTSETPARA(sde,SMT_P_SDE) ;
|
|
sde->sde_non_master = smc->mib.fddiSMTNonMaster_Ct ;
|
|
sde->sde_master = smc->mib.fddiSMTMaster_Ct ;
|
|
sde->sde_mac_count = NUMMACS ; /* only 1 MAC */
|
|
#ifdef CONCENTRATOR
|
|
sde->sde_type = SMT_SDE_CONCENTRATOR ;
|
|
#else
|
|
sde->sde_type = SMT_SDE_STATION ;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* fill in values in station state parameter
|
|
*/
|
|
static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state)
|
|
{
|
|
int top ;
|
|
int twist ;
|
|
|
|
SMTSETPARA(state,SMT_P_STATE) ;
|
|
state->st_pad = 0 ;
|
|
|
|
/* determine topology */
|
|
top = 0 ;
|
|
if (smc->mib.fddiSMTPeerWrapFlag) {
|
|
top |= SMT_ST_WRAPPED ; /* state wrapped */
|
|
}
|
|
#ifdef CONCENTRATOR
|
|
if (cfm_status_unattached(smc)) {
|
|
top |= SMT_ST_UNATTACHED ; /* unattached concentrator */
|
|
}
|
|
#endif
|
|
if ((twist = pcm_status_twisted(smc)) & 1) {
|
|
top |= SMT_ST_TWISTED_A ; /* twisted cable */
|
|
}
|
|
if (twist & 2) {
|
|
top |= SMT_ST_TWISTED_B ; /* twisted cable */
|
|
}
|
|
#ifdef OPT_SRF
|
|
top |= SMT_ST_SRF ;
|
|
#endif
|
|
if (pcm_rooted_station(smc))
|
|
top |= SMT_ST_ROOTED_S ;
|
|
if (smc->mib.a[0].fddiPATHSbaPayload != 0)
|
|
top |= SMT_ST_SYNC_SERVICE ;
|
|
state->st_topology = top ;
|
|
state->st_dupl_addr =
|
|
((smc->mib.m[MAC0].fddiMACDA_Flag ? SMT_ST_MY_DUPA : 0 ) |
|
|
(smc->mib.m[MAC0].fddiMACUNDA_Flag ? SMT_ST_UNA_DUPA : 0)) ;
|
|
}
|
|
|
|
/*
|
|
* fill values in timestamp parameter
|
|
*/
|
|
static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts)
|
|
{
|
|
|
|
SMTSETPARA(ts,SMT_P_TIMESTAMP) ;
|
|
smt_set_timestamp(smc,ts->ts_time) ;
|
|
}
|
|
|
|
void smt_set_timestamp(struct s_smc *smc, u_char *p)
|
|
{
|
|
u_long time ;
|
|
u_long utime ;
|
|
|
|
/*
|
|
* timestamp is 64 bits long ; resolution is 80 nS
|
|
* our clock resolution is 10mS
|
|
* 10mS/80ns = 125000 ~ 2^17 = 131072
|
|
*/
|
|
utime = smt_get_time() ;
|
|
time = utime * 100 ;
|
|
time /= TICKS_PER_SECOND ;
|
|
p[0] = 0 ;
|
|
p[1] = (u_char)((time>>(8+8+8+8-1)) & 1) ;
|
|
p[2] = (u_char)(time>>(8+8+8-1)) ;
|
|
p[3] = (u_char)(time>>(8+8-1)) ;
|
|
p[4] = (u_char)(time>>(8-1)) ;
|
|
p[5] = (u_char)(time<<1) ;
|
|
p[6] = (u_char)(smc->sm.uniq_ticks>>8) ;
|
|
p[7] = (u_char)smc->sm.uniq_ticks ;
|
|
/*
|
|
* make sure we don't wrap: restart whenever the upper digits change
|
|
*/
|
|
if (utime != smc->sm.uniq_time) {
|
|
smc->sm.uniq_ticks = 0 ;
|
|
}
|
|
smc->sm.uniq_ticks++ ;
|
|
smc->sm.uniq_time = utime ;
|
|
}
|
|
|
|
/*
|
|
* fill values in station policy parameter
|
|
*/
|
|
static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy)
|
|
{
|
|
int i ;
|
|
u_char *map ;
|
|
u_short in ;
|
|
u_short out ;
|
|
|
|
/*
|
|
* MIB para 101b (fddiSMTConnectionPolicy) coding
|
|
* is different from 0005 coding
|
|
*/
|
|
static u_char ansi_weirdness[16] = {
|
|
0,7,5,3,8,1,6,4,9,10,2,11,12,13,14,15
|
|
} ;
|
|
SMTSETPARA(policy,SMT_P_POLICY) ;
|
|
|
|
out = 0 ;
|
|
in = smc->mib.fddiSMTConnectionPolicy ;
|
|
for (i = 0, map = ansi_weirdness ; i < 16 ; i++) {
|
|
if (in & 1)
|
|
out |= (1<<*map) ;
|
|
in >>= 1 ;
|
|
map++ ;
|
|
}
|
|
policy->pl_config = smc->mib.fddiSMTConfigPolicy ;
|
|
policy->pl_connect = out ;
|
|
}
|
|
|
|
/*
|
|
* fill values in latency equivalent parameter
|
|
*/
|
|
static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency)
|
|
{
|
|
SMTSETPARA(latency,SMT_P_LATENCY) ;
|
|
|
|
latency->lt_phyout_idx1 = phy_index(smc,0) ;
|
|
latency->lt_latency1 = 10 ; /* in octets (byte clock) */
|
|
/*
|
|
* note: latency has two phy entries by definition
|
|
* for a SAS, the 2nd one is null
|
|
*/
|
|
if (smc->s.sas == SMT_DAS) {
|
|
latency->lt_phyout_idx2 = phy_index(smc,1) ;
|
|
latency->lt_latency2 = 10 ; /* in octets (byte clock) */
|
|
}
|
|
else {
|
|
latency->lt_phyout_idx2 = 0 ;
|
|
latency->lt_latency2 = 0 ;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* fill values in MAC neighbors parameter
|
|
*/
|
|
static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor)
|
|
{
|
|
SMTSETPARA(neighbor,SMT_P_NEIGHBORS) ;
|
|
|
|
neighbor->nb_mib_index = INDEX_MAC ;
|
|
neighbor->nb_mac_index = mac_index(smc,1) ;
|
|
neighbor->nb_una = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
|
|
neighbor->nb_dna = smc->mib.m[MAC0].fddiMACDownstreamNbr ;
|
|
}
|
|
|
|
/*
|
|
* fill values in path descriptor
|
|
*/
|
|
#ifdef CONCENTRATOR
|
|
#define ALLPHYS NUMPHYS
|
|
#else
|
|
#define ALLPHYS ((smc->s.sas == SMT_SAS) ? 1 : 2)
|
|
#endif
|
|
|
|
static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path)
|
|
{
|
|
SK_LOC_DECL(int,type) ;
|
|
SK_LOC_DECL(int,state) ;
|
|
SK_LOC_DECL(int,remote) ;
|
|
SK_LOC_DECL(int,mac) ;
|
|
int len ;
|
|
int p ;
|
|
int physp ;
|
|
struct smt_phy_rec *phy ;
|
|
struct smt_mac_rec *pd_mac ;
|
|
|
|
len = PARA_LEN +
|
|
sizeof(struct smt_mac_rec) * NUMMACS +
|
|
sizeof(struct smt_phy_rec) * ALLPHYS ;
|
|
path->para.p_type = SMT_P_PATH ;
|
|
path->para.p_len = len - PARA_LEN ;
|
|
|
|
/* PHYs */
|
|
for (p = 0,phy = path->pd_phy ; p < ALLPHYS ; p++, phy++) {
|
|
physp = p ;
|
|
#ifndef CONCENTRATOR
|
|
if (smc->s.sas == SMT_SAS)
|
|
physp = PS ;
|
|
#endif
|
|
pcm_status_state(smc,physp,&type,&state,&remote,&mac) ;
|
|
#ifdef LITTLE_ENDIAN
|
|
phy->phy_mib_index = smt_swap_short((u_short)p+INDEX_PORT) ;
|
|
#else
|
|
phy->phy_mib_index = p+INDEX_PORT ;
|
|
#endif
|
|
phy->phy_type = type ;
|
|
phy->phy_connect_state = state ;
|
|
phy->phy_remote_type = remote ;
|
|
phy->phy_remote_mac = mac ;
|
|
phy->phy_resource_idx = phy_con_resource_index(smc,p) ;
|
|
}
|
|
|
|
/* MAC */
|
|
pd_mac = (struct smt_mac_rec *) phy ;
|
|
pd_mac->mac_addr = smc->mib.m[MAC0].fddiMACSMTAddress ;
|
|
pd_mac->mac_resource_idx = mac_con_resource_index(smc,1) ;
|
|
return(len) ;
|
|
}
|
|
|
|
/*
|
|
* fill values in mac status
|
|
*/
|
|
static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st)
|
|
{
|
|
SMTSETPARA(st,SMT_P_MAC_STATUS) ;
|
|
|
|
st->st_mib_index = INDEX_MAC ;
|
|
st->st_mac_index = mac_index(smc,1) ;
|
|
|
|
mac_update_counter(smc) ;
|
|
/*
|
|
* timer values are represented in SMT as 2's complement numbers
|
|
* units : internal : 2's complement BCLK
|
|
*/
|
|
st->st_t_req = smc->mib.m[MAC0].fddiMACT_Req ;
|
|
st->st_t_neg = smc->mib.m[MAC0].fddiMACT_Neg ;
|
|
st->st_t_max = smc->mib.m[MAC0].fddiMACT_Max ;
|
|
st->st_tvx_value = smc->mib.m[MAC0].fddiMACTvxValue ;
|
|
st->st_t_min = smc->mib.m[MAC0].fddiMACT_Min ;
|
|
|
|
st->st_sba = smc->mib.a[PATH0].fddiPATHSbaPayload ;
|
|
st->st_frame_ct = smc->mib.m[MAC0].fddiMACFrame_Ct ;
|
|
st->st_error_ct = smc->mib.m[MAC0].fddiMACError_Ct ;
|
|
st->st_lost_ct = smc->mib.m[MAC0].fddiMACLost_Ct ;
|
|
}
|
|
|
|
/*
|
|
* fill values in LEM status
|
|
*/
|
|
static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy)
|
|
{
|
|
struct fddi_mib_p *mib ;
|
|
|
|
mib = smc->y[phy].mib ;
|
|
|
|
SMTSETPARA(lem,SMT_P_LEM) ;
|
|
lem->lem_mib_index = phy+INDEX_PORT ;
|
|
lem->lem_phy_index = phy_index(smc,phy) ;
|
|
lem->lem_pad2 = 0 ;
|
|
lem->lem_cutoff = mib->fddiPORTLer_Cutoff ;
|
|
lem->lem_alarm = mib->fddiPORTLer_Alarm ;
|
|
/* long term bit error rate */
|
|
lem->lem_estimate = mib->fddiPORTLer_Estimate ;
|
|
/* # of rejected connections */
|
|
lem->lem_reject_ct = mib->fddiPORTLem_Reject_Ct ;
|
|
lem->lem_ct = mib->fddiPORTLem_Ct ; /* total number of errors */
|
|
}
|
|
|
|
/*
|
|
* fill version parameter
|
|
*/
|
|
static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers)
|
|
{
|
|
SK_UNUSED(smc) ;
|
|
SMTSETPARA(vers,SMT_P_VERSION) ;
|
|
vers->v_pad = 0 ;
|
|
vers->v_n = 1 ; /* one version is enough .. */
|
|
vers->v_index = 1 ;
|
|
vers->v_version[0] = SMT_VID_2 ;
|
|
vers->v_pad2 = 0 ;
|
|
}
|
|
|
|
#ifdef SMT6_10
|
|
/*
|
|
* fill frame status capabilities
|
|
*/
|
|
/*
|
|
* note: this para 200B is NOT in swap table, because it's also set in
|
|
* PMF add_para
|
|
*/
|
|
static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc)
|
|
{
|
|
SK_UNUSED(smc) ;
|
|
SMTSETPARA(fsc,SMT_P_FSC) ;
|
|
fsc->fsc_pad0 = 0 ;
|
|
fsc->fsc_mac_index = INDEX_MAC ; /* this is MIB ; MIB is NOT
|
|
* mac_index ()i !
|
|
*/
|
|
fsc->fsc_pad1 = 0 ;
|
|
fsc->fsc_value = FSC_TYPE0 ; /* "normal" node */
|
|
#ifdef LITTLE_ENDIAN
|
|
fsc->fsc_mac_index = smt_swap_short(INDEX_MAC) ;
|
|
fsc->fsc_value = smt_swap_short(FSC_TYPE0) ;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* fill mac counter field
|
|
*/
|
|
static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc)
|
|
{
|
|
SMTSETPARA(mc,SMT_P_MAC_COUNTER) ;
|
|
mc->mc_mib_index = INDEX_MAC ;
|
|
mc->mc_index = mac_index(smc,1) ;
|
|
mc->mc_receive_ct = smc->mib.m[MAC0].fddiMACCopied_Ct ;
|
|
mc->mc_transmit_ct = smc->mib.m[MAC0].fddiMACTransmit_Ct ;
|
|
}
|
|
|
|
/*
|
|
* fill mac frame not copied counter
|
|
*/
|
|
static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc)
|
|
{
|
|
SMTSETPARA(fnc,SMT_P_MAC_FNC) ;
|
|
fnc->nc_mib_index = INDEX_MAC ;
|
|
fnc->nc_index = mac_index(smc,1) ;
|
|
fnc->nc_counter = smc->mib.m[MAC0].fddiMACNotCopied_Ct ;
|
|
}
|
|
|
|
|
|
/*
|
|
* fill manufacturer field
|
|
*/
|
|
static void smt_fill_manufacturer(struct s_smc *smc,
|
|
struct smp_p_manufacturer *man)
|
|
{
|
|
SMTSETPARA(man,SMT_P_MANUFACTURER) ;
|
|
memcpy((char *) man->mf_data,
|
|
(char *) smc->mib.fddiSMTManufacturerData,
|
|
sizeof(man->mf_data)) ;
|
|
}
|
|
|
|
/*
|
|
* fill user field
|
|
*/
|
|
static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user)
|
|
{
|
|
SMTSETPARA(user,SMT_P_USER) ;
|
|
memcpy((char *) user->us_data,
|
|
(char *) smc->mib.fddiSMTUserData,
|
|
sizeof(user->us_data)) ;
|
|
}
|
|
|
|
/*
|
|
* fill set count
|
|
*/
|
|
static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount)
|
|
{
|
|
SK_UNUSED(smc) ;
|
|
SMTSETPARA(setcount,SMT_P_SETCOUNT) ;
|
|
setcount->count = smc->mib.fddiSMTSetCount.count ;
|
|
memcpy((char *)setcount->timestamp,
|
|
(char *)smc->mib.fddiSMTSetCount.timestamp,8) ;
|
|
}
|
|
|
|
/*
|
|
* fill echo data
|
|
*/
|
|
static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
|
|
int len)
|
|
{
|
|
u_char *p ;
|
|
|
|
SK_UNUSED(smc) ;
|
|
SMTSETPARA(echo,SMT_P_ECHODATA) ;
|
|
echo->para.p_len = len ;
|
|
for (p = echo->ec_data ; len ; len--) {
|
|
*p++ = (u_char) seed ;
|
|
seed += 13 ;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* clear DNA and UNA
|
|
* called from CFM if configuration changes
|
|
*/
|
|
static void smt_clear_una_dna(struct s_smc *smc)
|
|
{
|
|
smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
|
|
smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
|
|
}
|
|
|
|
static void smt_clear_old_una_dna(struct s_smc *smc)
|
|
{
|
|
smc->mib.m[MAC0].fddiMACOldUpstreamNbr = SMT_Unknown ;
|
|
smc->mib.m[MAC0].fddiMACOldDownstreamNbr = SMT_Unknown ;
|
|
}
|
|
|
|
u_long smt_get_tid(struct s_smc *smc)
|
|
{
|
|
u_long tid ;
|
|
while ((tid = ++(smc->sm.smt_tid) ^ SMT_TID_MAGIC) == 0)
|
|
;
|
|
return(tid & 0x3fffffffL) ;
|
|
}
|
|
|
|
|
|
/*
|
|
* table of parameter lengths
|
|
*/
|
|
static const struct smt_pdef {
|
|
int ptype ;
|
|
int plen ;
|
|
const char *pswap ;
|
|
} smt_pdef[] = {
|
|
{ SMT_P_UNA, sizeof(struct smt_p_una) ,
|
|
SWAP_SMT_P_UNA } ,
|
|
{ SMT_P_SDE, sizeof(struct smt_p_sde) ,
|
|
SWAP_SMT_P_SDE } ,
|
|
{ SMT_P_STATE, sizeof(struct smt_p_state) ,
|
|
SWAP_SMT_P_STATE } ,
|
|
{ SMT_P_TIMESTAMP,sizeof(struct smt_p_timestamp) ,
|
|
SWAP_SMT_P_TIMESTAMP } ,
|
|
{ SMT_P_POLICY, sizeof(struct smt_p_policy) ,
|
|
SWAP_SMT_P_POLICY } ,
|
|
{ SMT_P_LATENCY, sizeof(struct smt_p_latency) ,
|
|
SWAP_SMT_P_LATENCY } ,
|
|
{ SMT_P_NEIGHBORS,sizeof(struct smt_p_neighbor) ,
|
|
SWAP_SMT_P_NEIGHBORS } ,
|
|
{ SMT_P_PATH, sizeof(struct smt_p_path) ,
|
|
SWAP_SMT_P_PATH } ,
|
|
{ SMT_P_MAC_STATUS,sizeof(struct smt_p_mac_status) ,
|
|
SWAP_SMT_P_MAC_STATUS } ,
|
|
{ SMT_P_LEM, sizeof(struct smt_p_lem) ,
|
|
SWAP_SMT_P_LEM } ,
|
|
{ SMT_P_MAC_COUNTER,sizeof(struct smt_p_mac_counter) ,
|
|
SWAP_SMT_P_MAC_COUNTER } ,
|
|
{ SMT_P_MAC_FNC,sizeof(struct smt_p_mac_fnc) ,
|
|
SWAP_SMT_P_MAC_FNC } ,
|
|
{ SMT_P_PRIORITY,sizeof(struct smt_p_priority) ,
|
|
SWAP_SMT_P_PRIORITY } ,
|
|
{ SMT_P_EB,sizeof(struct smt_p_eb) ,
|
|
SWAP_SMT_P_EB } ,
|
|
{ SMT_P_MANUFACTURER,sizeof(struct smp_p_manufacturer) ,
|
|
SWAP_SMT_P_MANUFACTURER } ,
|
|
{ SMT_P_REASON, sizeof(struct smt_p_reason) ,
|
|
SWAP_SMT_P_REASON } ,
|
|
{ SMT_P_REFUSED, sizeof(struct smt_p_refused) ,
|
|
SWAP_SMT_P_REFUSED } ,
|
|
{ SMT_P_VERSION, sizeof(struct smt_p_version) ,
|
|
SWAP_SMT_P_VERSION } ,
|
|
#ifdef ESS
|
|
{ SMT_P0015, sizeof(struct smt_p_0015) , SWAP_SMT_P0015 } ,
|
|
{ SMT_P0016, sizeof(struct smt_p_0016) , SWAP_SMT_P0016 } ,
|
|
{ SMT_P0017, sizeof(struct smt_p_0017) , SWAP_SMT_P0017 } ,
|
|
{ SMT_P0018, sizeof(struct smt_p_0018) , SWAP_SMT_P0018 } ,
|
|
{ SMT_P0019, sizeof(struct smt_p_0019) , SWAP_SMT_P0019 } ,
|
|
{ SMT_P001A, sizeof(struct smt_p_001a) , SWAP_SMT_P001A } ,
|
|
{ SMT_P001B, sizeof(struct smt_p_001b) , SWAP_SMT_P001B } ,
|
|
{ SMT_P001C, sizeof(struct smt_p_001c) , SWAP_SMT_P001C } ,
|
|
{ SMT_P001D, sizeof(struct smt_p_001d) , SWAP_SMT_P001D } ,
|
|
#endif
|
|
#if 0
|
|
{ SMT_P_FSC, sizeof(struct smt_p_fsc) ,
|
|
SWAP_SMT_P_FSC } ,
|
|
#endif
|
|
|
|
{ SMT_P_SETCOUNT,0, SWAP_SMT_P_SETCOUNT } ,
|
|
{ SMT_P1048, 0, SWAP_SMT_P1048 } ,
|
|
{ SMT_P208C, 0, SWAP_SMT_P208C } ,
|
|
{ SMT_P208D, 0, SWAP_SMT_P208D } ,
|
|
{ SMT_P208E, 0, SWAP_SMT_P208E } ,
|
|
{ SMT_P208F, 0, SWAP_SMT_P208F } ,
|
|
{ SMT_P2090, 0, SWAP_SMT_P2090 } ,
|
|
#ifdef ESS
|
|
{ SMT_P320B, sizeof(struct smt_p_320b) , SWAP_SMT_P320B } ,
|
|
{ SMT_P320F, sizeof(struct smt_p_320f) , SWAP_SMT_P320F } ,
|
|
{ SMT_P3210, sizeof(struct smt_p_3210) , SWAP_SMT_P3210 } ,
|
|
#endif
|
|
{ SMT_P4050, 0, SWAP_SMT_P4050 } ,
|
|
{ SMT_P4051, 0, SWAP_SMT_P4051 } ,
|
|
{ SMT_P4052, 0, SWAP_SMT_P4052 } ,
|
|
{ SMT_P4053, 0, SWAP_SMT_P4053 } ,
|
|
} ;
|
|
|
|
#define N_SMT_PLEN (sizeof(smt_pdef)/sizeof(smt_pdef[0]))
|
|
|
|
int smt_check_para(struct s_smc *smc, struct smt_header *sm,
|
|
const u_short list[])
|
|
{
|
|
const u_short *p = list ;
|
|
while (*p) {
|
|
if (!sm_to_para(smc,sm,(int) *p)) {
|
|
DB_SMT("SMT: smt_check_para - missing para %x\n",*p,0);
|
|
return(-1) ;
|
|
}
|
|
p++ ;
|
|
}
|
|
return(0) ;
|
|
}
|
|
|
|
void *sm_to_para(struct s_smc *smc, struct smt_header *sm, int para)
|
|
{
|
|
char *p ;
|
|
int len ;
|
|
int plen ;
|
|
void *found = NULL;
|
|
|
|
SK_UNUSED(smc) ;
|
|
|
|
len = sm->smt_len ;
|
|
p = (char *)(sm+1) ; /* pointer to info */
|
|
while (len > 0 ) {
|
|
if (((struct smt_para *)p)->p_type == para)
|
|
found = (void *) p ;
|
|
plen = ((struct smt_para *)p)->p_len + PARA_LEN ;
|
|
p += plen ;
|
|
len -= plen ;
|
|
if (len < 0) {
|
|
DB_SMT("SMT : sm_to_para - length error %d\n",plen,0) ;
|
|
return NULL;
|
|
}
|
|
if ((plen & 3) && (para != SMT_P_ECHODATA)) {
|
|
DB_SMT("SMT : sm_to_para - odd length %d\n",plen,0) ;
|
|
return NULL;
|
|
}
|
|
if (found)
|
|
return(found) ;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
#if 0
|
|
/*
|
|
* send ANTC data test frame
|
|
*/
|
|
void fddi_send_antc(struct s_smc *smc, struct fddi_addr *dest)
|
|
{
|
|
SK_UNUSED(smc) ;
|
|
SK_UNUSED(dest) ;
|
|
#if 0
|
|
SMbuf *mb ;
|
|
struct smt_header *smt ;
|
|
int i ;
|
|
char *p ;
|
|
|
|
mb = smt_get_mbuf() ;
|
|
mb->sm_len = 3000+12 ;
|
|
p = smtod(mb, char *) + 12 ;
|
|
for (i = 0 ; i < 3000 ; i++)
|
|
*p++ = 1 << (i&7) ;
|
|
|
|
smt = smtod(mb, struct smt_header *) ;
|
|
smt->smt_dest = *dest ;
|
|
smt->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
|
|
smt_send_mbuf(smc,mb,FC_ASYNC_LLC) ;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
#define hextoasc(x) "0123456789abcdef"[x]
|
|
|
|
char *addr_to_string(struct fddi_addr *addr)
|
|
{
|
|
int i ;
|
|
static char string[6*3] = "****" ;
|
|
|
|
for (i = 0 ; i < 6 ; i++) {
|
|
string[i*3] = hextoasc((addr->a[i]>>4)&0xf) ;
|
|
string[i*3+1] = hextoasc((addr->a[i])&0xf) ;
|
|
string[i*3+2] = ':' ;
|
|
}
|
|
string[5*3+2] = 0 ;
|
|
return(string) ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef AM29K
|
|
int smt_ifconfig(int argc, char *argv[])
|
|
{
|
|
if (argc >= 2 && !strcmp(argv[0],"opt_bypass") &&
|
|
!strcmp(argv[1],"yes")) {
|
|
smc->mib.fddiSMTBypassPresent = 1 ;
|
|
return(0) ;
|
|
}
|
|
return(amdfddi_config(0,argc,argv)) ;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* return static mac index
|
|
*/
|
|
static int mac_index(struct s_smc *smc, int mac)
|
|
{
|
|
SK_UNUSED(mac) ;
|
|
#ifdef CONCENTRATOR
|
|
SK_UNUSED(smc) ;
|
|
return(NUMPHYS+1) ;
|
|
#else
|
|
return((smc->s.sas == SMT_SAS) ? 2 : 3) ;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* return static phy index
|
|
*/
|
|
static int phy_index(struct s_smc *smc, int phy)
|
|
{
|
|
SK_UNUSED(smc) ;
|
|
return(phy+1);
|
|
}
|
|
|
|
/*
|
|
* return dynamic mac connection resource index
|
|
*/
|
|
static int mac_con_resource_index(struct s_smc *smc, int mac)
|
|
{
|
|
#ifdef CONCENTRATOR
|
|
SK_UNUSED(smc) ;
|
|
SK_UNUSED(mac) ;
|
|
return(entity_to_index(smc,cem_get_downstream(smc,ENTITY_MAC))) ;
|
|
#else
|
|
SK_UNUSED(mac) ;
|
|
switch (smc->mib.fddiSMTCF_State) {
|
|
case SC9_C_WRAP_A :
|
|
case SC5_THRU_B :
|
|
case SC11_C_WRAP_S :
|
|
return(1) ;
|
|
case SC10_C_WRAP_B :
|
|
case SC4_THRU_A :
|
|
return(2) ;
|
|
}
|
|
return(smc->s.sas == SMT_SAS ? 2 : 3) ;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* return dynamic phy connection resource index
|
|
*/
|
|
static int phy_con_resource_index(struct s_smc *smc, int phy)
|
|
{
|
|
#ifdef CONCENTRATOR
|
|
return(entity_to_index(smc,cem_get_downstream(smc,ENTITY_PHY(phy)))) ;
|
|
#else
|
|
switch (smc->mib.fddiSMTCF_State) {
|
|
case SC9_C_WRAP_A :
|
|
return(phy == PA ? 3 : 2) ;
|
|
case SC10_C_WRAP_B :
|
|
return(phy == PA ? 1 : 3) ;
|
|
case SC4_THRU_A :
|
|
return(phy == PA ? 3 : 1) ;
|
|
case SC5_THRU_B :
|
|
return(phy == PA ? 2 : 3) ;
|
|
case SC11_C_WRAP_S :
|
|
return(2) ;
|
|
}
|
|
return(phy) ;
|
|
#endif
|
|
}
|
|
|
|
#ifdef CONCENTRATOR
|
|
static int entity_to_index(struct s_smc *smc, int e)
|
|
{
|
|
if (e == ENTITY_MAC)
|
|
return(mac_index(smc,1)) ;
|
|
else
|
|
return(phy_index(smc,e - ENTITY_PHY(0))) ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef LITTLE_ENDIAN
|
|
static int smt_swap_short(u_short s)
|
|
{
|
|
return(((s>>8)&0xff)|((s&0xff)<<8)) ;
|
|
}
|
|
|
|
void smt_swap_para(struct smt_header *sm, int len, int direction)
|
|
/* int direction; 0 encode 1 decode */
|
|
{
|
|
struct smt_para *pa ;
|
|
const struct smt_pdef *pd ;
|
|
char *p ;
|
|
int plen ;
|
|
int type ;
|
|
int i ;
|
|
|
|
/* printf("smt_swap_para sm %x len %d dir %d\n",
|
|
sm,len,direction) ;
|
|
*/
|
|
smt_string_swap((char *)sm,SWAP_SMTHEADER,len) ;
|
|
|
|
/* swap args */
|
|
len -= sizeof(struct smt_header) ;
|
|
|
|
p = (char *) (sm + 1) ;
|
|
while (len > 0) {
|
|
pa = (struct smt_para *) p ;
|
|
plen = pa->p_len ;
|
|
type = pa->p_type ;
|
|
pa->p_type = smt_swap_short(pa->p_type) ;
|
|
pa->p_len = smt_swap_short(pa->p_len) ;
|
|
if (direction) {
|
|
plen = pa->p_len ;
|
|
type = pa->p_type ;
|
|
}
|
|
/*
|
|
* note: paras can have 0 length !
|
|
*/
|
|
if (plen < 0)
|
|
break ;
|
|
plen += PARA_LEN ;
|
|
for (i = N_SMT_PLEN, pd = smt_pdef; i ; i--,pd++) {
|
|
if (pd->ptype == type)
|
|
break ;
|
|
}
|
|
if (i && pd->pswap) {
|
|
smt_string_swap(p+PARA_LEN,pd->pswap,len) ;
|
|
}
|
|
len -= plen ;
|
|
p += plen ;
|
|
}
|
|
}
|
|
|
|
static void smt_string_swap(char *data, const char *format, int len)
|
|
{
|
|
const char *open_paren = NULL ;
|
|
int x ;
|
|
|
|
while (len > 0 && *format) {
|
|
switch (*format) {
|
|
case '[' :
|
|
open_paren = format ;
|
|
break ;
|
|
case ']' :
|
|
format = open_paren ;
|
|
break ;
|
|
case '1' :
|
|
case '2' :
|
|
case '3' :
|
|
case '4' :
|
|
case '5' :
|
|
case '6' :
|
|
case '7' :
|
|
case '8' :
|
|
case '9' :
|
|
data += *format - '0' ;
|
|
len -= *format - '0' ;
|
|
break ;
|
|
case 'c':
|
|
data++ ;
|
|
len-- ;
|
|
break ;
|
|
case 's' :
|
|
x = data[0] ;
|
|
data[0] = data[1] ;
|
|
data[1] = x ;
|
|
data += 2 ;
|
|
len -= 2 ;
|
|
break ;
|
|
case 'l' :
|
|
x = data[0] ;
|
|
data[0] = data[3] ;
|
|
data[3] = x ;
|
|
x = data[1] ;
|
|
data[1] = data[2] ;
|
|
data[2] = x ;
|
|
data += 4 ;
|
|
len -= 4 ;
|
|
break ;
|
|
}
|
|
format++ ;
|
|
}
|
|
}
|
|
#else
|
|
void smt_swap_para(struct smt_header *sm, int len, int direction)
|
|
/* int direction; 0 encode 1 decode */
|
|
{
|
|
SK_UNUSED(sm) ;
|
|
SK_UNUSED(len) ;
|
|
SK_UNUSED(direction) ;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* PMF actions
|
|
*/
|
|
int smt_action(struct s_smc *smc, int class, int code, int index)
|
|
{
|
|
int event ;
|
|
int port ;
|
|
DB_SMT("SMT: action %d code %d\n",class,code) ;
|
|
switch(class) {
|
|
case SMT_STATION_ACTION :
|
|
switch(code) {
|
|
case SMT_STATION_ACTION_CONNECT :
|
|
smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;
|
|
queue_event(smc,EVENT_ECM,EC_CONNECT) ;
|
|
break ;
|
|
case SMT_STATION_ACTION_DISCONNECT :
|
|
queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
|
|
smc->mib.fddiSMTRemoteDisconnectFlag = TRUE ;
|
|
RS_SET(smc,RS_DISCONNECT) ;
|
|
AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
|
|
FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_DISCONNECT,
|
|
smt_get_event_word(smc));
|
|
break ;
|
|
case SMT_STATION_ACTION_PATHTEST :
|
|
AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
|
|
FDDI_SMT_EVENT, (u_long) FDDI_PATH_TEST,
|
|
smt_get_event_word(smc));
|
|
break ;
|
|
case SMT_STATION_ACTION_SELFTEST :
|
|
AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
|
|
FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_SELF_TEST,
|
|
smt_get_event_word(smc));
|
|
break ;
|
|
case SMT_STATION_ACTION_DISABLE_A :
|
|
if (smc->y[PA].pc_mode == PM_PEER) {
|
|
RS_SET(smc,RS_EVENT) ;
|
|
queue_event(smc,EVENT_PCM+PA,PC_DISABLE) ;
|
|
}
|
|
break ;
|
|
case SMT_STATION_ACTION_DISABLE_B :
|
|
if (smc->y[PB].pc_mode == PM_PEER) {
|
|
RS_SET(smc,RS_EVENT) ;
|
|
queue_event(smc,EVENT_PCM+PB,PC_DISABLE) ;
|
|
}
|
|
break ;
|
|
case SMT_STATION_ACTION_DISABLE_M :
|
|
for (port = 0 ; port < NUMPHYS ; port++) {
|
|
if (smc->mib.p[port].fddiPORTMy_Type != TM)
|
|
continue ;
|
|
RS_SET(smc,RS_EVENT) ;
|
|
queue_event(smc,EVENT_PCM+port,PC_DISABLE) ;
|
|
}
|
|
break ;
|
|
default :
|
|
return(1) ;
|
|
}
|
|
break ;
|
|
case SMT_PORT_ACTION :
|
|
switch(code) {
|
|
case SMT_PORT_ACTION_ENABLE :
|
|
event = PC_ENABLE ;
|
|
break ;
|
|
case SMT_PORT_ACTION_DISABLE :
|
|
event = PC_DISABLE ;
|
|
break ;
|
|
case SMT_PORT_ACTION_MAINT :
|
|
event = PC_MAINT ;
|
|
break ;
|
|
case SMT_PORT_ACTION_START :
|
|
event = PC_START ;
|
|
break ;
|
|
case SMT_PORT_ACTION_STOP :
|
|
event = PC_STOP ;
|
|
break ;
|
|
default :
|
|
return(1) ;
|
|
}
|
|
queue_event(smc,EVENT_PCM+index,event) ;
|
|
break ;
|
|
default :
|
|
return(1) ;
|
|
}
|
|
return(0) ;
|
|
}
|
|
|
|
/*
|
|
* canonical conversion of <len> bytes beginning form *data
|
|
*/
|
|
#ifdef USE_CAN_ADDR
|
|
static void hwm_conv_can(struct s_smc *smc, char *data, int len)
|
|
{
|
|
int i ;
|
|
|
|
SK_UNUSED(smc) ;
|
|
|
|
for (i = len; i ; i--, data++)
|
|
*data = bitrev8(*data);
|
|
}
|
|
#endif
|
|
|
|
#endif /* no SLIM_SMT */
|
|
|