Quelle  smt.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0-or-later */
/******************************************************************************
 *
 * (C)Copyright 1998,1999 SysKonnect,
 * a business unit of Schneider & Koch & Co. Datensysteme GmbH.
 *
 * The information in this file is provided "AS IS" without warranty.
 *
 ******************************************************************************/

/*
 * SMT 7.2 frame definitions
 */

#ifndef _SMT_
#define _SMT_

/* #define SMT5_10 */
#define SMT6_10
#define SMT7_20

#define OPT_PMF  /* if parameter management is supported */
#define OPT_SRF  /* if status report is supported */

/*
 * SMT frame version 5.1
 */

#define SMT_VID 0x0001   /* V 5.1 .. 6.1 */
#define SMT_VID_2 0x0002  /* V 7.2 */

struct smt_sid {
 u_char sid_oem[2] ;   /* implementation spec. */
 struct fddi_addr sid_node ;  /* node address */
} ;

typedef u_char t_station_id[8] ;

/*
 * note on alignment :
 * sizeof(struct smt_header) = 32
 * all parameters are long aligned
 * if struct smt_header starts at offset 0, all longs are aligned correctly
 * (FC starts at offset 3)
 */
_packed struct smt_header {
 struct fddi_addr     smt_dest ; /* destination address */
 struct fddi_addr smt_source ; /* source address */
 u_char   smt_class ; /* NIF, SIF ... */
 u_char   smt_type ; /* req., response .. */
 u_short   smt_version ; /* version id */
 u_int   smt_tid ; /* transaction ID */
 struct smt_sid  smt_sid ; /* station ID */
 u_short   smt_pad ; /* pad with 0 */
 u_short   smt_len ; /* length of info field */
} ;
#define SWAP_SMTHEADER "662sl8ss"

#if 0
/*
 * MAC FC values
 */
#define FC_SMT_INFO 0x41  /* SMT info */
#define FC_SMT_NSA 0x4f  /* SMT Next Station Addressing */
#endif


/*
 * type codes
 */
#define SMT_ANNOUNCE 0x01  /* announcement */
#define SMT_REQUEST 0x02  /* request */
#define SMT_REPLY 0x03  /* reply */

/*
 * class codes
 */
#define SMT_NIF  0x01  /* neighbor information frames */
#define SMT_SIF_CONFIG 0x02  /* station information configuration */
#define SMT_SIF_OPER 0x03  /* station information operation */
#define SMT_ECF  0x04  /* echo frames */
#define SMT_RAF  0x05  /* resource allocation */
#define SMT_RDF  0x06  /* request denied */
#define SMT_SRF  0x07  /* status report */
#define SMT_PMF_GET 0x08  /* parameter management get */
#define SMT_PMF_SET 0x09  /* parameter management set */
#define SMT_ESF  0xff  /* extended service */

#define SMT_MAX_ECHO_LEN 4458 /* max length of SMT Echo */
#if defined(CONC) || defined(CONC_II)
#define SMT_TEST_ECHO_LEN 50 /* test length of SMT Echo */
#else
#define SMT_TEST_ECHO_LEN SMT_MAX_ECHO_LEN /* test length */
#endif

#define SMT_MAX_INFO_LEN (4352-20) /* max length for SMT info */


/*
 * parameter types
 */

struct smt_para {
 u_short p_type ;  /* type */
 u_short p_len ;   /* length of parameter */
} ;

#define PARA_LEN (sizeof(struct smt_para))

#define SMTSETPARA(p,t)  (p)->para.p_type = (t),\
    (p)->para.p_len = sizeof(*(p)) - PARA_LEN

/*
 * P01 : Upstream Neighbor Address, UNA
 */
#define SMT_P_UNA 0x0001  /* upstream neighbor address */
#define SWAP_SMT_P_UNA "s6"

struct smt_p_una {
 struct smt_para para ;  /* generic parameter header */
 u_short una_pad ;
 struct fddi_addr una_node ; /* node address, zero if unknown */
} ;

/*
 * P02 : Station Descriptor
 */
#define SMT_P_SDE 0x0002  /* station descriptor */
#define SWAP_SMT_P_SDE "1111"

#define SMT_SDE_STATION  0 /* end node */
#define SMT_SDE_CONCENTRATOR 1 /* concentrator */

struct smt_p_sde {
 struct smt_para para ;  /* generic parameter header */
 u_char sde_type ;  /* station type */
 u_char sde_mac_count ;  /* number of MACs */
 u_char sde_non_master ; /* number of A,B or S ports */
 u_char sde_master ;  /* number of S ports on conc. */
} ;

/*
 * P03 : Station State
 */
#define SMT_P_STATE 0x0003  /* station state */
#define SWAP_SMT_P_STATE "scc"

struct smt_p_state {
 struct smt_para para ;  /* generic parameter header */
 u_short st_pad ;
 u_char st_topology ;  /* topology */
 u_char st_dupl_addr ;  /* duplicate address detected */
} ;
#define SMT_ST_WRAPPED  (1<<0) /* station wrapped */
#define SMT_ST_UNATTACHED (1<<1) /* unattached concentrator */
#define SMT_ST_TWISTED_A (1<<2) /* A-A connection, twisted ring */
#define SMT_ST_TWISTED_B (1<<3) /* B-B connection, twisted ring */
#define SMT_ST_ROOTED_S  (1<<4) /* rooted station */
#define SMT_ST_SRF  (1<<5) /* SRF protocol supported */
#define SMT_ST_SYNC_SERVICE (1<<6) /* use synchronous bandwidth */

#define SMT_ST_MY_DUPA  (1<<0) /* my station detected dupl. */
#define SMT_ST_UNA_DUPA  (1<<1) /* my UNA detected duplicate */

/*
 * P04 : timestamp
 */
#define SMT_P_TIMESTAMP 0x0004  /* time stamp */
#define SWAP_SMT_P_TIMESTAMP "8"
struct smt_p_timestamp {
 struct smt_para para ;  /* generic parameter header */
 u_char ts_time[8] ;  /* time, resolution 80nS, unique */
} ;

/*
 * P05 : station policies
 */
#define SMT_P_POLICY 0x0005  /* station policies */
#define SWAP_SMT_P_POLICY "ss"

struct smt_p_policy {
 struct smt_para para ;  /* generic parameter header */
 u_short pl_config ;
 u_short pl_connect ;  /* bit string POLICY_AA ... */
} ;
#define SMT_PL_HOLD  1 /* hold policy supported (Dual MAC) */

/*
 * P06 : latency equivalent
 */
#define SMT_P_LATENCY 0x0006  /* latency */
#define SWAP_SMT_P_LATENCY "ssss"

/*
 * note: latency has two phy entries by definition
 * for a SAS, the 2nd one is null
 */
struct smt_p_latency {
 struct smt_para para ;  /* generic parameter header */
 u_short lt_phyout_idx1 ; /* index */
 u_short lt_latency1 ;  /* latency , unit : byte clock */
 u_short lt_phyout_idx2 ; /* 0 if SAS */
 u_short lt_latency2 ;  /* 0 if SAS */
} ;

/*
 * P07 : MAC neighbors
 */
#define SMT_P_NEIGHBORS 0x0007  /* MAC neighbor description */
#define SWAP_SMT_P_NEIGHBORS "ss66"

struct smt_p_neighbor {
 struct smt_para para ;  /* generic parameter header */
 u_short nb_mib_index ;  /* MIB index */
 u_short nb_mac_index ;  /* n+1 .. n+m, m = #MACs, n = #PHYs */
 struct fddi_addr nb_una ; /* UNA , 0 for unknown */
 struct fddi_addr nb_dna ; /* DNA , 0 for unknown */
} ;

/*
 * PHY record
 */
#define SMT_PHY_A 0  /* A port */
#define SMT_PHY_B 1  /* B port */
#define SMT_PHY_S 2  /* slave port */
#define SMT_PHY_M 3  /* master port */

#define SMT_CS_DISABLED 0  /* connect state : disabled */
#define SMT_CS_CONNECTING 1 /* connect state : connecting */
#define SMT_CS_STANDBY 2  /* connect state : stand by */
#define SMT_CS_ACTIVE 3  /* connect state : active */

#define SMT_RM_NONE 0
#define SMT_RM_MAC 1

struct smt_phy_rec {
 u_short phy_mib_index ;  /* MIB index */
 u_char phy_type ;  /* A/B/S/M */
 u_char phy_connect_state ; /* disabled/connecting/active */
 u_char phy_remote_type ; /* A/B/S/M */
 u_char phy_remote_mac ; /* none/remote */
 u_short phy_resource_idx ; /* 1 .. n */
} ;

/*
 * MAC record
 */
struct smt_mac_rec {
 struct fddi_addr mac_addr ;  /* MAC address */
 u_short  mac_resource_idx ; /* n+1 .. n+m */
} ;

/*
 * P08 : path descriptors
 * should be really an array ; however our environment has a fixed number of
 * PHYs and MACs
 */
#define SMT_P_PATH 0x0008   /* path descriptor */
#define SWAP_SMT_P_PATH "[6s]"

struct smt_p_path {
 struct smt_para para ;  /* generic parameter header */
 struct smt_phy_rec pd_phy[2] ; /* PHY A */
 struct smt_mac_rec pd_mac ; /* MAC record */
} ;

/*
 * P09 : MAC status
 */
#define SMT_P_MAC_STATUS 0x0009  /* MAC status */
#define SWAP_SMT_P_MAC_STATUS "sslllllllll"

struct smt_p_mac_status {
 struct smt_para para ;  /* generic parameter header */
 u_short st_mib_index ;  /* MIB index */
 u_short st_mac_index ;  /* n+1 .. n+m */
 u_int st_t_req ;  /* T_Req */
 u_int st_t_neg ;  /* T_Neg */
 u_int st_t_max ;  /* T_Max */
 u_int st_tvx_value ;  /* TVX_Value */
 u_int st_t_min ;  /* T_Min */
 u_int st_sba ;  /* synchr. bandwidth alloc */
 u_int st_frame_ct ;  /* frame counter */
 u_int st_error_ct ;  /* error counter */
 u_int st_lost_ct ;  /* lost frames counter */
} ;

/*
 * P0A : PHY link error rate monitoring
 */
#define SMT_P_LEM 0x000a  /* link error monitor */
#define SWAP_SMT_P_LEM "ssccccll"
/*
 * units of lem_cutoff,lem_alarm,lem_estimate : 10**-x
 */
struct smt_p_lem {
 struct smt_para para ;  /* generic parameter header */
 u_short lem_mib_index ;  /* MIB index */
 u_short lem_phy_index ;  /* 1 .. n */
 u_char lem_pad2 ;  /* be nice and make it even . */
 u_char lem_cutoff ;  /* 0x4 .. 0xf, default 0x7 */
 u_char lem_alarm ;  /* 0x4 .. 0xf, default 0x8 */
 u_char lem_estimate ;  /* 0x0 .. 0xff */
 u_int lem_reject_ct ;  /* 0x00000000 .. 0xffffffff */
 u_int lem_ct ;  /* 0x00000000 .. 0xffffffff */
} ;

/*
 * P0B : MAC frame counters
 */
#define SMT_P_MAC_COUNTER 0x000b /* MAC frame counters */
#define SWAP_SMT_P_MAC_COUNTER "ssll"

struct smt_p_mac_counter {
 struct smt_para para ;  /* generic parameter header */
 u_short mc_mib_index ;  /* MIB index */
 u_short mc_index ;  /* mac index */
 u_int mc_receive_ct ;  /* receive counter */
 u_int mc_transmit_ct ; /* transmit counter */
} ;

/*
 * P0C : MAC frame not copied counter
 */
#define SMT_P_MAC_FNC 0x000c  /* MAC frame not copied counter */
#define SWAP_SMT_P_MAC_FNC "ssl"

struct smt_p_mac_fnc {
 struct smt_para para ;  /* generic parameter header */
 u_short nc_mib_index ;  /* MIB index */
 u_short nc_index ;  /* mac index */
 u_int nc_counter ;  /* not copied counter */
} ;


/*
 * P0D : MAC priority values
 */
#define SMT_P_PRIORITY 0x000d  /* MAC priority values */
#define SWAP_SMT_P_PRIORITY "ssl"

struct smt_p_priority {
 struct smt_para para ;  /* generic parameter header */
 u_short pr_mib_index ;  /* MIB index */
 u_short pr_index ;  /* mac index */
 u_int pr_priority[7] ; /* priority values */
} ;

/*
 * P0E : PHY elasticity buffer status
 */
#define SMT_P_EB 0x000e  /* PHY EB status */
#define SWAP_SMT_P_EB "ssl"

struct smt_p_eb {
 struct smt_para para ;  /* generic parameter header */
 u_short eb_mib_index ;  /* MIB index */
 u_short eb_index ;  /* phy index */
 u_int eb_error_ct ;  /* # of eb overflows */
} ;

/*
 * P0F : manufacturer field
 */
#define SMT_P_MANUFACTURER 0x000f /* manufacturer field */
#define SWAP_SMT_P_MANUFACTURER ""

struct smp_p_manufacturer {
 struct smt_para para ;  /* generic parameter header */
 u_char mf_data[32] ;  /* OUI + arbitrary data */
} ;

/*
 * P10 : user field
 */
#define SMT_P_USER  0x0010 /* manufacturer field */
#define SWAP_SMT_P_USER ""

struct smp_p_user {
 struct smt_para para ;  /* generic parameter header */
 u_char us_data[32] ;  /* arbitrary data */
} ;



/*
 * P11 : echo data
 */
#define SMT_P_ECHODATA 0x0011  /* echo data */
#define SWAP_SMT_P_ECHODATA ""

struct smt_p_echo {
 struct smt_para para ;  /* generic parameter header */
 u_char ec_data[SMT_MAX_ECHO_LEN-4] ; /* echo data */
} ;

/*
 * P12 : reason code
 */
#define SMT_P_REASON 0x0012  /* reason code */
#define SWAP_SMT_P_REASON "l"

struct smt_p_reason {
 struct smt_para para ;  /* generic parameter header */
 u_int rdf_reason ;  /* CLASS/VERSION */
} ;
#define SMT_RDF_CLASS 0x00000001 /* class not supported */
#define SMT_RDF_VERSION 0x00000002 /* version not supported */
#define SMT_RDF_SUCCESS 0x00000003 /* success (PMF) */
#define SMT_RDF_BADSET 0x00000004 /* bad set count (PMF) */
#define SMT_RDF_ILLEGAL 0x00000005 /* read only (PMF) */
#define SMT_RDF_NOPARAM 0x6  /* parameter not supported (PMF) */
#define SMT_RDF_RANGE 0x8  /* out of range */
#define SMT_RDF_AUTHOR 0x9  /* not authorized */
#define SMT_RDF_LENGTH 0x0a  /* length error */
#define SMT_RDF_TOOLONG 0x0b  /* length error */
#define SMT_RDF_SBA 0x0d  /* SBA denied */

/*
 * P13 : refused frame beginning
 */
#define SMT_P_REFUSED 0x0013  /* refused frame beginning */
#define SWAP_SMT_P_REFUSED "l"

struct smt_p_refused {
 struct smt_para para ;  /* generic parameter header */
 u_int ref_fc ;  /* 3 bytes 0 + FC */
 struct smt_header ref_header ; /* refused header */
} ;

/*
 * P14 : supported SMT versions
 */
#define SMT_P_VERSION 0x0014  /* SMT supported versions */
#define SWAP_SMT_P_VERSION "sccss"

struct smt_p_version {
 struct smt_para para ;  /* generic parameter header */
 u_short v_pad ;
 u_char v_n ;   /* 1 .. 0xff, #versions */
 u_char v_index ;  /* 1 .. 0xff, index of op. v. */
 u_short v_version[1] ;  /* list of min. 1 version */
 u_short v_pad2 ;  /* pad if necessary */
} ;

/*
 * P15 : Resource Type
 */
#define SWAP_SMT_P0015  "l"

struct smt_p_0015 {
 struct smt_para para ;  /* generic parameter header */
 u_int  res_type ; /* resource type */
} ;

#define SYNC_BW  0x00000001L /* Synchronous Bandwidth */

/*
 * P16 : SBA Command
 */
#define SWAP_SMT_P0016  "l"

struct smt_p_0016 {
 struct smt_para para ;  /* generic parameter header */
 u_int  sba_cmd ; /* command for the SBA */
} ;

#define REQUEST_ALLOCATION 0x1 /* req allocation of sync bandwidth */
#define REPORT_ALLOCATION 0x2 /* rep of sync bandwidth allocation */
#define CHANGE_ALLOCATION 0x3 /* forces a station using sync band-*/
     /* width to change its current allo-*/
     /* cation */

/*
 * P17 : SBA Payload Request
 */
#define SWAP_SMT_P0017  "l"

struct smt_p_0017 {
 struct smt_para para ;  /* generic parameter header */
 int  sba_pl_req ; /* total sync bandwidth measured in */
} ;     /* bytes per 125 us */

/*
 * P18 : SBA Overhead Request
 */
#define SWAP_SMT_P0018  "l"

struct smt_p_0018 {
 struct smt_para para ;  /* generic parameter header */
 int  sba_ov_req ; /* total sync bandwidth req for overhead*/
} ;     /* measured in bytes per T_Neg */

/*
 * P19 : SBA Allocation Address
 */
#define SWAP_SMT_P0019  "s6"

struct smt_p_0019 {
 struct smt_para para ;  /* generic parameter header */
 u_short  sba_pad ;
 struct fddi_addr alloc_addr ; /* Allocation Address */
} ;

/*
 * P1A : SBA Category
 */
#define SWAP_SMT_P001A  "l"

struct smt_p_001a {
 struct smt_para para ;  /* generic parameter header */
 u_int  category ; /* Allocator defined classification */
} ;

/*
 * P1B : Maximum T_Neg
 */
#define SWAP_SMT_P001B  "l"

struct smt_p_001b {
 struct smt_para para ;  /* generic parameter header */
 u_int  max_t_neg ; /* longest T_NEG for the sync service*/
} ;

/*
 * P1C : Minimum SBA Segment Size
 */
#define SWAP_SMT_P001C  "l"

struct smt_p_001c {
 struct smt_para para ;  /* generic parameter header */
 u_int  min_seg_siz ; /* smallest number of bytes per frame*/
} ;

/*
 * P1D : SBA Allocatable
 */
#define SWAP_SMT_P001D  "l"

struct smt_p_001d {
 struct smt_para para ;  /* generic parameter header */
 u_int  allocatable ; /* total sync bw available for alloc */
} ;

/*
 * P20 0B : frame status capabilities
 * NOTE: not in swap table, is used by smt.c AND PMF table
 */
#define SMT_P_FSC 0x200b
/* #define SWAP_SMT_P_FSC "ssss" */

struct smt_p_fsc {
 struct smt_para para ;  /* generic parameter header */
 u_short fsc_pad0 ;
 u_short fsc_mac_index ;  /* mac index 1 .. ff */
 u_short fsc_pad1 ;
 u_short fsc_value ;  /* FSC_TYPE[0-2] */
} ;

#define FSC_TYPE0 0  /* "normal" node (A/C handling) */
#define FSC_TYPE1 1  /* Special A/C indicator forwarding */
#define FSC_TYPE2 2  /* Special A/C indicator forwarding */

/*
 * P00 21 : user defined authorization (see pmf.c)
 */
#define SMT_P_AUTHOR 0x0021

/*
 * notification parameters
 */
#define SWAP_SMT_P1048 "ll"
struct smt_p_1048 {
 u_int p1048_flag ;
 u_int p1048_cf_state ;
} ;

/*
 * NOTE: all 2xxx 3xxx and 4xxx must include the INDEX in the swap string,
 * even so the INDEX is NOT part of the struct.
 * INDEX is already swapped in pmf.c, format in string is '4'
 */
#define SWAP_SMT_P208C "4lss66"
struct smt_p_208c {
 u_int   p208c_flag ;
 u_short   p208c_pad ;
 u_short   p208c_dupcondition ;
 struct fddi_addr p208c_fddilong ;
 struct fddi_addr p208c_fddiunalong ;
} ;

#define SWAP_SMT_P208D "4lllll"
struct smt_p_208d {
 u_int   p208d_flag ;
 u_int   p208d_frame_ct ;
 u_int   p208d_error_ct ;
 u_int   p208d_lost_ct ;
 u_int   p208d_ratio ;
} ;

#define SWAP_SMT_P208E "4llll"
struct smt_p_208e {
 u_int   p208e_flag ;
 u_int   p208e_not_copied ;
 u_int   p208e_copied ;
 u_int   p208e_not_copied_ratio ;
} ;

#define SWAP_SMT_P208F "4ll6666s6"

struct smt_p_208f {
 u_int   p208f_multiple ;
 u_int   p208f_nacondition ;
 struct fddi_addr p208f_old_una ;
 struct fddi_addr p208f_new_una ;
 struct fddi_addr p208f_old_dna ;
 struct fddi_addr p208f_new_dna ;
 u_short   p208f_curren_path ;
 struct fddi_addr p208f_smt_address ;
} ;

#define SWAP_SMT_P2090 "4lssl"

struct smt_p_2090 {
 u_int   p2090_multiple ;
 u_short   p2090_availablepaths ;
 u_short   p2090_currentpath ;
 u_int   p2090_requestedpaths ;
} ;

/*
 * NOTE:
 * special kludge for parameters 320b,320f,3210
 * these parameters are part of RAF frames
 * RAF frames are parsed in SBA.C and must be swapped
 * PMF.C has special code to avoid double swapping
 */
#ifdef LITTLE_ENDIAN
#define SBAPATHINDEX (0x01000000L)
#else
#define SBAPATHINDEX (0x01L)
#endif

#define SWAP_SMT_P320B "42s"

struct smt_p_320b {
 struct smt_para para ; /* generic parameter header */
 u_int mib_index ;
 u_short path_pad ;
 u_short path_index ;
} ;

#define SWAP_SMT_P320F "4l"

struct smt_p_320f {
 struct smt_para para ; /* generic parameter header */
 u_int mib_index ;
 u_int mib_payload ;
} ;

#define SWAP_SMT_P3210 "4l"

struct smt_p_3210 {
 struct smt_para para ; /* generic parameter header */
 u_int mib_index ;
 u_int mib_overhead ;
} ;

#define SWAP_SMT_P4050 "4l1111ll"

struct smt_p_4050 {
 u_int   p4050_flag ;
 u_char   p4050_pad ;
 u_char   p4050_cutoff ;
 u_char   p4050_alarm ;
 u_char   p4050_estimate ;
 u_int   p4050_reject_ct ;
 u_int   p4050_ct ;
} ;

#define SWAP_SMT_P4051 "4lssss"
struct smt_p_4051 {
 u_int   p4051_multiple ;
 u_short   p4051_porttype ;
 u_short   p4051_connectstate ;
 u_short   p4051_pc_neighbor ;
 u_short   p4051_pc_withhold ;
} ;

#define SWAP_SMT_P4052 "4ll"
struct smt_p_4052 {
 u_int   p4052_flag ;
 u_int   p4052_eberrorcount ;
} ;

#define SWAP_SMT_P4053 "4lsslss"

struct smt_p_4053 {
 u_int   p4053_multiple ;
 u_short   p4053_availablepaths ;
 u_short   p4053_currentpath ;
 u_int   p4053_requestedpaths ;
 u_short   p4053_mytype ;
 u_short   p4053_neighbortype ;
} ;


#define SMT_P_SETCOUNT 0x1035
#define SWAP_SMT_P_SETCOUNT "l8"

struct smt_p_setcount {
 struct smt_para para ;  /* generic parameter header */
 u_int  count ;
 u_char  timestamp[8] ;
} ;

/*
 * SMT FRAMES
 */

/*
 * NIF : neighbor information frames
 */
struct smt_nif {
 struct smt_header smt ;  /* generic header */
 struct smt_p_una una ;  /* UNA */
 struct smt_p_sde sde ;  /* station descriptor */
 struct smt_p_state state ;  /* station state */
#ifdef SMT6_10
 struct smt_p_fsc fsc ;  /* frame status cap. */
#endif
} ;

/*
 * SIF : station information frames
 */
struct smt_sif_config {
 struct smt_header smt ;  /* generic header */
 struct smt_p_timestamp ts ;  /* time stamp */
 struct smt_p_sde sde ;  /* station descriptor */
 struct smt_p_version version ; /* supported versions */
 struct smt_p_state state ;  /* station state */
 struct smt_p_policy policy ; /* station policy */
 struct smt_p_latency latency ; /* path latency */
 struct smt_p_neighbor neighbor ; /* neighbors, we have only one*/
#ifdef OPT_PMF
 struct smt_p_setcount setcount ;  /* Set Count mandatory */
#endif
 /* WARNING : path MUST BE LAST FIELD !!! (see smt.c:smt_fill_path) */
 struct smt_p_path path ;  /* path descriptor */
} ;
#define SIZEOF_SMT_SIF_CONFIG (sizeof(struct smt_sif_config)- \
     sizeof(struct smt_p_path))

struct smt_sif_operation {
 struct smt_header smt ;  /* generic header */
 struct smt_p_timestamp ts ;  /* time stamp */
 struct smt_p_mac_status status ; /* mac status */
 struct smt_p_mac_counter mc ;  /* MAC counter */
 struct smt_p_mac_fnc  fnc ;  /* MAC frame not copied */
 struct smp_p_manufacturer man ;  /* manufacturer field */
 struct smp_p_user user ;  /* user field */
#ifdef OPT_PMF
 struct smt_p_setcount setcount ;  /* Set Count mandatory */
#endif
 /* must be last */
 struct smt_p_lem lem[];  /* phy lem status */
} ;

/*
 * ECF : echo frame
 */
struct smt_ecf {
 struct smt_header smt ;  /* generic header */
 struct smt_p_echo ec_echo ; /* echo parameter */
} ;
#define SMT_ECF_LEN (sizeof(struct smt_header)+sizeof(struct smt_para))

/*
 * RDF : request denied frame
 */
struct smt_rdf {
 struct smt_header smt ;  /* generic header */
 struct smt_p_reason reason ; /* reason code */
 struct smt_p_version version ; /* supported versions */
 struct smt_p_refused refused ; /* refused frame fragment */
} ;

/*
 * SBA Request Allocation Response Frame
 */
struct smt_sba_alc_res {
 struct smt_header smt ;  /* generic header */
 struct smt_p_0015 s_type ; /* resource type */
 struct smt_p_0016 cmd ;  /* SBA command */
 struct smt_p_reason reason ; /* reason code */
 struct smt_p_320b path ;  /* path type */
 struct smt_p_320f payload ; /* current SBA payload */
 struct smt_p_3210 overhead ; /* current SBA overhead */
 struct smt_p_0019 a_addr ; /* Allocation Address */
 struct smt_p_001a cat ;  /* Category - from the request */
 struct smt_p_001d alloc ;  /* SBA Allocatable */
} ;

/*
 * SBA Request Allocation Request Frame
 */
struct smt_sba_alc_req {
 struct smt_header smt ;  /* generic header */
 struct smt_p_0015 s_type ; /* resource type */
 struct smt_p_0016 cmd ;  /* SBA command */
 struct smt_p_320b path ;  /* path type */
 struct smt_p_0017 pl_req ; /* requested payload */
 struct smt_p_0018 ov_req ; /* requested SBA overhead */
 struct smt_p_320f payload ; /* current SBA payload */
 struct smt_p_3210 overhead ; /* current SBA overhead */
 struct smt_p_0019 a_addr ; /* Allocation Address */
 struct smt_p_001a cat ;  /* Category - from the request */
 struct smt_p_001b tneg ;  /* max T-NEG */
 struct smt_p_001c segm ;  /* minimum segment size */
} ;

/*
 * SBA Change Allocation Request Frame
 */
struct smt_sba_chg {
 struct smt_header smt ;  /* generic header */
 struct smt_p_0015 s_type ; /* resource type */
 struct smt_p_0016 cmd ;  /* SBA command */
 struct smt_p_320b path ;  /* path type */
 struct smt_p_320f payload ; /* current SBA payload */
 struct smt_p_3210 overhead ; /* current SBA overhead */
 struct smt_p_001a cat ;  /* Category - from the request */
} ;

/*
 * SBA Report Allocation Request Frame
 */
struct smt_sba_rep_req {
 struct smt_header smt ;  /* generic header */
 struct smt_p_0015 s_type ; /* resource type */
 struct smt_p_0016 cmd ;  /* SBA command */
} ;

/*
 * SBA Report Allocation Response Frame
 */
struct smt_sba_rep_res {
 struct smt_header smt ;  /* generic header */
 struct smt_p_0015 s_type ; /* resource type */
 struct smt_p_0016 cmd ;  /* SBA command */
 struct smt_p_320b path ;  /* path type */
 struct smt_p_320f payload ; /* current SBA payload */
 struct smt_p_3210 overhead ; /* current SBA overhead */
} ;

/*
 * actions
 */
#define SMT_STATION_ACTION 1
#define SMT_STATION_ACTION_CONNECT 0
#define SMT_STATION_ACTION_DISCONNECT 1
#define SMT_STATION_ACTION_PATHTEST 2
#define SMT_STATION_ACTION_SELFTEST 3
#define SMT_STATION_ACTION_DISABLE_A 4
#define SMT_STATION_ACTION_DISABLE_B 5
#define SMT_STATION_ACTION_DISABLE_M 6

#define SMT_PORT_ACTION  2
#define SMT_PORT_ACTION_MAINT 0
#define SMT_PORT_ACTION_ENABLE 1
#define SMT_PORT_ACTION_DISABLE 2
#define SMT_PORT_ACTION_START 3
#define SMT_PORT_ACTION_STOP 4

#endif /* _SMT_ */