drivers/net/fddi/skfp/smt.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /******************************************************************************
   3  *
   4  *      (C)Copyright 1998,1999 SysKonnect,
   5  *      a business unit of Schneider & Koch & Co. Datensysteme GmbH.
   6  *
   7  *      See the file "skfddi.c" for further information.
   8  *
   9  *      The information in this file is provided "AS IS" without warranty.
  10  *
  11  ******************************************************************************/
  12
  13 #include "h/types.h"
  14 #include "h/fddi.h"
  15 #include "h/smc.h"
  16 #include "h/smt_p.h"
  17 #include <linux/bitrev.h>
  18 #include <linux/kernel.h>
  19
  20 #define KERNEL
  21 #include "h/smtstate.h"
  22
  23 #ifndef lint
  24 static const char ID_sccs[] = "@(#)smt.c        2.43 98/11/23 (C) SK " ;
  25 #endif
  26
  27 /*
  28  * FC in SMbuf
  29  */
  30 #define m_fc(mb)        ((mb)->sm_data[0])
  31
  32 #define SMT_TID_MAGIC   0x1f0a7b3c
  33
  34 static const char *const smt_type_name[] = {
  35         "SMT_00??", "SMT_INFO", "SMT_02??", "SMT_03??",
  36         "SMT_04??", "SMT_05??", "SMT_06??", "SMT_07??",
  37         "SMT_08??", "SMT_09??", "SMT_0A??", "SMT_0B??",
  38         "SMT_0C??", "SMT_0D??", "SMT_0E??", "SMT_NSA"
  39 } ;
  40
  41 static const char *const smt_class_name[] = {
  42         "UNKNOWN","NIF","SIF_CONFIG","SIF_OPER","ECF","RAF","RDF",
  43         "SRF","PMF_GET","PMF_SET","ESF"
  44 } ;
  45
  46 #define LAST_CLASS      (SMT_PMF_SET)
  47
  48 static const struct fddi_addr SMT_Unknown = {
  49         { 0,0,0x1f,0,0,0 }
  50 } ;
  51
  52 /*
  53  * function prototypes
  54  */
  55 #ifdef  LITTLE_ENDIAN
  56 static int smt_swap_short(u_short s);
  57 #endif
  58 static int mac_index(struct s_smc *smc, int mac);
  59 static int phy_index(struct s_smc *smc, int phy);
  60 static int mac_con_resource_index(struct s_smc *smc, int mac);
  61 static int phy_con_resource_index(struct s_smc *smc, int phy);
  62 static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
  63                          int local);
  64 static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
  65                          int fc, u_long tid, int type, int local);
  66 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
  67                          u_long tid, int type, int len);
  68 static void smt_echo_test(struct s_smc *smc, int dna);
  69 static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
  70                                 u_long tid, int local);
  71 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
  72                                    u_long tid, int local);
  73 #ifdef LITTLE_ENDIAN
  74 static void smt_string_swap(char *data, const char *format, int len);
  75 #endif
  76 static void smt_add_frame_len(SMbuf *mb, int len);
  77 static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una);
  78 static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde);
  79 static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state);
  80 static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts);
  81 static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy);
  82 static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency);
  83 static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor);
  84 static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path);
  85 static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st);
  86 static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy);
  87 static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers);
  88 static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc);
  89 static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc);
  90 static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc);
  91 static void smt_fill_manufacturer(struct s_smc *smc,
  92                                   struct smp_p_manufacturer *man);
  93 static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user);
  94 static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount);
  95 static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
  96                           int len);
  97
  98 static void smt_clear_una_dna(struct s_smc *smc);
  99 static void smt_clear_old_una_dna(struct s_smc *smc);
 100 #ifdef  CONCENTRATOR
 101 static int entity_to_index(void);
 102 #endif
 103 static void update_dac(struct s_smc *smc, int report);
 104 static int div_ratio(u_long upper, u_long lower);
 105 #ifdef  USE_CAN_ADDR
 106 static void     hwm_conv_can(struct s_smc *smc, char *data, int len);
 107 #else
 108 #define         hwm_conv_can(smc,data,len)
 109 #endif
 110
 111
 112 static inline int is_my_addr(const struct s_smc *smc,
 113                              const struct fddi_addr *addr)
 114 {
 115         return(*(short *)(&addr->a[0]) ==
 116                 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[0])
 117           && *(short *)(&addr->a[2]) ==
 118                 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[2])
 119           && *(short *)(&addr->a[4]) ==
 120                 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[4])) ;
 121 }
 122
 123 static inline int is_broadcast(const struct fddi_addr *addr)
 124 {
 125         return *(u_short *)(&addr->a[0]) == 0xffff &&
 126                *(u_short *)(&addr->a[2]) == 0xffff &&
 127                *(u_short *)(&addr->a[4]) == 0xffff;
 128 }
 129
 130 static inline int is_individual(const struct fddi_addr *addr)
 131 {
 132         return !(addr->a[0] & GROUP_ADDR);
 133 }
 134
 135 static inline int is_equal(const struct fddi_addr *addr1,
 136                            const struct fddi_addr *addr2)
 137 {
 138         return *(u_short *)(&addr1->a[0]) == *(u_short *)(&addr2->a[0]) &&
 139                *(u_short *)(&addr1->a[2]) == *(u_short *)(&addr2->a[2]) &&
 140                *(u_short *)(&addr1->a[4]) == *(u_short *)(&addr2->a[4]);
 141 }
 142
 143 /*
 144  * list of mandatory paras in frames
 145  */
 146 static const u_short plist_nif[] = { SMT_P_UNA,SMT_P_SDE,SMT_P_STATE,0 } ;
 147
 148 /*
 149  * init SMT agent
 150  */
 151 void smt_agent_init(struct s_smc *smc)
 152 {
 153         int             i ;
 154
 155         /*
 156          * get MAC address
 157          */
 158         smc->mib.m[MAC0].fddiMACSMTAddress = smc->hw.fddi_home_addr ;
 159
 160         /*
 161          * get OUI address from driver (bia == built-in-address)
 162          */
 163         smc->mib.fddiSMTStationId.sid_oem[0] = 0 ;
 164         smc->mib.fddiSMTStationId.sid_oem[1] = 0 ;
 165         driver_get_bia(smc,&smc->mib.fddiSMTStationId.sid_node) ;
 166         for (i = 0 ; i < 6 ; i ++) {
 167                 smc->mib.fddiSMTStationId.sid_node.a[i] =
 168                         bitrev8(smc->mib.fddiSMTStationId.sid_node.a[i]);
 169         }
 170         smc->mib.fddiSMTManufacturerData[0] =
 171                 smc->mib.fddiSMTStationId.sid_node.a[0] ;
 172         smc->mib.fddiSMTManufacturerData[1] =
 173                 smc->mib.fddiSMTStationId.sid_node.a[1] ;
 174         smc->mib.fddiSMTManufacturerData[2] =
 175                 smc->mib.fddiSMTStationId.sid_node.a[2] ;
 176         smc->sm.smt_tid = 0 ;
 177         smc->mib.m[MAC0].fddiMACDupAddressTest = DA_NONE ;
 178         smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
 179 #ifndef SLIM_SMT
 180         smt_clear_una_dna(smc) ;
 181         smt_clear_old_una_dna(smc) ;
 182 #endif
 183         for (i = 0 ; i < SMT_MAX_TEST ; i++)
 184                 smc->sm.pend[i] = 0 ;
 185         smc->sm.please_reconnect = 0 ;
 186         smc->sm.uniq_ticks = 0 ;
 187 }
 188
 189 /*
 190  * SMT task
 191  * forever
 192  *      delay 30 seconds
 193  *      send NIF
 194  *      check tvu & tvd
 195  * end
 196  */
 197 void smt_agent_task(struct s_smc *smc)
 198 {
 199         smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
 200                 EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
 201         DB_SMT("SMT agent task");
 202 }
 203
 204 #ifndef SMT_REAL_TOKEN_CT
 205 void smt_emulate_token_ct(struct s_smc *smc, int mac_index)
 206 {
 207         u_long  count;
 208         u_long  time;
 209
 210
 211         time = smt_get_time();
 212         count = ((time - smc->sm.last_tok_time[mac_index]) *
 213                                         100)/TICKS_PER_SECOND;
 214
 215         /*
 216          * Only when ring is up we will have a token count. The
 217          * flag is unfortunately a single instance value. This
 218          * doesn't matter now, because we currently have only
 219          * one MAC instance.
 220          */
 221         if (smc->hw.mac_ring_is_up){
 222                 smc->mib.m[mac_index].fddiMACToken_Ct += count;
 223         }
 224
 225         /* Remember current time */
 226         smc->sm.last_tok_time[mac_index] = time;
 227
 228 }
 229 #endif
 230
 231 /*ARGSUSED1*/
 232 void smt_event(struct s_smc *smc, int event)
 233 {
 234         u_long          time ;
 235 #ifndef SMT_REAL_TOKEN_CT
 236         int             i ;
 237 #endif
 238
 239
 240         if (smc->sm.please_reconnect) {
 241                 smc->sm.please_reconnect -- ;
 242                 if (smc->sm.please_reconnect == 0) {
 243                         /* Counted down */
 244                         queue_event(smc,EVENT_ECM,EC_CONNECT) ;
 245                 }
 246         }
 247
 248         if (event == SM_FAST)
 249                 return ;
 250
 251         /*
 252          * timer for periodic cleanup in driver
 253          * reset and start the watchdog (FM2)
 254          * ESS timer
 255          * SBA timer
 256          */
 257         smt_timer_poll(smc) ;
 258         smt_start_watchdog(smc) ;
 259 #ifndef SLIM_SMT
 260 #ifndef BOOT
 261 #ifdef  ESS
 262         ess_timer_poll(smc) ;
 263 #endif
 264 #endif
 265 #ifdef  SBA
 266         sba_timer_poll(smc) ;
 267 #endif
 268
 269         smt_srf_event(smc,0,0,0) ;
 270
 271 #endif  /* no SLIM_SMT */
 272
 273         time = smt_get_time() ;
 274
 275         if (time - smc->sm.smt_last_lem >= TICKS_PER_SECOND*8) {
 276                 /*
 277                  * Use 8 sec. for the time intervall, it simplifies the
 278                  * LER estimation.
 279                  */
 280                 struct fddi_mib_m       *mib ;
 281                 u_long                  upper ;
 282                 u_long                  lower ;
 283                 int                     cond ;
 284                 int                     port;
 285                 struct s_phy            *phy ;
 286                 /*
 287                  * calculate LEM bit error rate
 288                  */
 289                 sm_lem_evaluate(smc) ;
 290                 smc->sm.smt_last_lem = time ;
 291
 292                 /*
 293                  * check conditions
 294                  */
 295 #ifndef SLIM_SMT
 296                 mac_update_counter(smc) ;
 297                 mib = smc->mib.m ;
 298                 upper =
 299                 (mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) +
 300                 (mib->fddiMACError_Ct - mib->fddiMACOld_Error_Ct) ;
 301                 lower =
 302                 (mib->fddiMACFrame_Ct - mib->fddiMACOld_Frame_Ct) +
 303                 (mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) ;
 304                 mib->fddiMACFrameErrorRatio = div_ratio(upper,lower) ;
 305
 306                 cond =
 307                         ((!mib->fddiMACFrameErrorThreshold &&
 308                         mib->fddiMACError_Ct != mib->fddiMACOld_Error_Ct) ||
 309                         (mib->fddiMACFrameErrorRatio >
 310                         mib->fddiMACFrameErrorThreshold)) ;
 311
 312                 if (cond != mib->fddiMACFrameErrorFlag)
 313                         smt_srf_event(smc,SMT_COND_MAC_FRAME_ERROR,
 314                                 INDEX_MAC,cond) ;
 315
 316                 upper =
 317                 (mib->fddiMACNotCopied_Ct - mib->fddiMACOld_NotCopied_Ct) ;
 318                 lower =
 319                 upper +
 320                 (mib->fddiMACCopied_Ct - mib->fddiMACOld_Copied_Ct) ;
 321                 mib->fddiMACNotCopiedRatio = div_ratio(upper,lower) ;
 322
 323                 cond =
 324                         ((!mib->fddiMACNotCopiedThreshold &&
 325                         mib->fddiMACNotCopied_Ct !=
 326                                 mib->fddiMACOld_NotCopied_Ct)||
 327                         (mib->fddiMACNotCopiedRatio >
 328                         mib->fddiMACNotCopiedThreshold)) ;
 329
 330                 if (cond != mib->fddiMACNotCopiedFlag)
 331                         smt_srf_event(smc,SMT_COND_MAC_NOT_COPIED,
 332                                 INDEX_MAC,cond) ;
 333
 334                 /*
 335                  * set old values
 336                  */
 337                 mib->fddiMACOld_Frame_Ct = mib->fddiMACFrame_Ct ;
 338                 mib->fddiMACOld_Copied_Ct = mib->fddiMACCopied_Ct ;
 339                 mib->fddiMACOld_Error_Ct = mib->fddiMACError_Ct ;
 340                 mib->fddiMACOld_Lost_Ct = mib->fddiMACLost_Ct ;
 341                 mib->fddiMACOld_NotCopied_Ct = mib->fddiMACNotCopied_Ct ;
 342
 343                 /*
 344                  * Check port EBError Condition
 345                  */
 346                 for (port = 0; port < NUMPHYS; port ++) {
 347                         phy = &smc->y[port] ;
 348
 349                         if (!phy->mib->fddiPORTHardwarePresent) {
 350                                 continue;
 351                         }
 352
 353                         cond = (phy->mib->fddiPORTEBError_Ct -
 354                                 phy->mib->fddiPORTOldEBError_Ct > 5) ;
 355
 356                         /* If ratio is more than 5 in 8 seconds
 357                          * Set the condition.
 358                          */
 359                         smt_srf_event(smc,SMT_COND_PORT_EB_ERROR,
 360                                 (int) (INDEX_PORT+ phy->np) ,cond) ;
 361
 362                         /*
 363                          * set old values
 364                          */
 365                         phy->mib->fddiPORTOldEBError_Ct =
 366                                 phy->mib->fddiPORTEBError_Ct ;
 367                 }
 368
 369 #endif  /* no SLIM_SMT */
 370         }
 371
 372 #ifndef SLIM_SMT
 373
 374         if (time - smc->sm.smt_last_notify >= (u_long)
 375                 (smc->mib.fddiSMTTT_Notify * TICKS_PER_SECOND) ) {
 376                 /*
 377                  * we can either send an announcement or a request
 378                  * a request will trigger a reply so that we can update
 379                  * our dna
 380                  * note: same tid must be used until reply is received
 381                  */
 382                 if (!smc->sm.pend[SMT_TID_NIF])
 383                         smc->sm.pend[SMT_TID_NIF] = smt_get_tid(smc) ;
 384                 smt_send_nif(smc,&fddi_broadcast, FC_SMT_NSA,
 385                         smc->sm.pend[SMT_TID_NIF], SMT_REQUEST,0) ;
 386                 smc->sm.smt_last_notify = time ;
 387         }
 388
 389         /*
 390          * check timer
 391          */
 392         if (smc->sm.smt_tvu &&
 393             time - smc->sm.smt_tvu > 228*TICKS_PER_SECOND) {
 394                 DB_SMT("SMT : UNA expired");
 395                 smc->sm.smt_tvu = 0 ;
 396
 397                 if (!is_equal(&smc->mib.m[MAC0].fddiMACUpstreamNbr,
 398                         &SMT_Unknown)){
 399                         /* Do not update unknown address */
 400                         smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
 401                                 smc->mib.m[MAC0].fddiMACUpstreamNbr ;
 402                 }
 403                 smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
 404                 smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
 405                 /*
 406                  * Make sure the fddiMACUNDA_Flag = FALSE is
 407                  * included in the SRF so we don't generate
 408                  * a separate SRF for the deassertion of this
 409                  * condition
 410                  */
 411                 update_dac(smc,0) ;
 412                 smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
 413                         INDEX_MAC,0) ;
 414         }
 415         if (smc->sm.smt_tvd &&
 416             time - smc->sm.smt_tvd > 228*TICKS_PER_SECOND) {
 417                 DB_SMT("SMT : DNA expired");
 418                 smc->sm.smt_tvd = 0 ;
 419                 if (!is_equal(&smc->mib.m[MAC0].fddiMACDownstreamNbr,
 420                         &SMT_Unknown)){
 421                         /* Do not update unknown address */
 422                         smc->mib.m[MAC0].fddiMACOldDownstreamNbr=
 423                                 smc->mib.m[MAC0].fddiMACDownstreamNbr ;
 424                 }
 425                 smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
 426                 smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
 427                         INDEX_MAC,0) ;
 428         }
 429
 430 #endif  /* no SLIM_SMT */
 431
 432 #ifndef SMT_REAL_TOKEN_CT
 433         /*
 434          * Token counter emulation section. If hardware supports the token
 435          * count, the token counter will be updated in mac_update_counter.
 436          */
 437         for (i = MAC0; i < NUMMACS; i++ ){
 438                 if (time - smc->sm.last_tok_time[i] > 2*TICKS_PER_SECOND ){
 439                         smt_emulate_token_ct( smc, i );
 440                 }
 441         }
 442 #endif
 443
 444         smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
 445                 EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
 446 }
 447
 448 static int div_ratio(u_long upper, u_long lower)
 449 {
 450         if ((upper<<16L) < upper)
 451                 upper = 0xffff0000L ;
 452         else
 453                 upper <<= 16L ;
 454         if (!lower)
 455                 return 0;
 456         return (int)(upper/lower) ;
 457 }
 458
 459 #ifndef SLIM_SMT
 460
 461 /*
 462  * receive packet handler
 463  */
 464 void smt_received_pack(struct s_smc *smc, SMbuf *mb, int fs)
 465 /* int fs;  frame status */
 466 {
 467         struct smt_header       *sm ;
 468         int                     local ;
 469
 470         int                     illegal = 0 ;
 471
 472         switch (m_fc(mb)) {
 473         case FC_SMT_INFO :
 474         case FC_SMT_LAN_LOC :
 475         case FC_SMT_LOC :
 476         case FC_SMT_NSA :
 477                 break ;
 478         default :
 479                 smt_free_mbuf(smc,mb) ;
 480                 return ;
 481         }
 482
 483         smc->mib.m[MAC0].fddiMACSMTCopied_Ct++ ;
 484         sm = smtod(mb,struct smt_header *) ;
 485         local = ((fs & L_INDICATOR) != 0) ;
 486         hwm_conv_can(smc,(char *)sm,12) ;
 487
 488         /* check destination address */
 489         if (is_individual(&sm->smt_dest) && !is_my_addr(smc,&sm->smt_dest)) {
 490                 smt_free_mbuf(smc,mb) ;
 491                 return ;
 492         }
 493 #if     0               /* for DUP recognition, do NOT filter them */
 494         /* ignore loop back packets */
 495         if (is_my_addr(smc,&sm->smt_source) && !local) {
 496                 smt_free_mbuf(smc,mb) ;
 497                 return ;
 498         }
 499 #endif
 500
 501         smt_swap_para(sm,(int) mb->sm_len,1) ;
 502         DB_SMT("SMT : received packet [%s] at 0x%p",
 503                smt_type_name[m_fc(mb) & 0xf], sm);
 504         DB_SMT("SMT : version %d, class %s",
 505                sm->smt_version,
 506                smt_class_name[sm->smt_class > LAST_CLASS ? 0 : sm->smt_class]);
 507
 508 #ifdef  SBA
 509         /*
 510          * check if NSA frame
 511          */
 512         if (m_fc(mb) == FC_SMT_NSA && sm->smt_class == SMT_NIF &&
 513                 (sm->smt_type == SMT_ANNOUNCE || sm->smt_type == SMT_REQUEST)) {
 514                         smc->sba.sm = sm ;
 515                         sba(smc,NIF) ;
 516         }
 517 #endif
 518
 519         /*
 520          * ignore any packet with NSA and A-indicator set
 521          */
 522         if ( (fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) {
 523                 DB_SMT("SMT : ignoring NSA with A-indicator set from %s",
 524                        addr_to_string(&sm->smt_source));
 525                 smt_free_mbuf(smc,mb) ;
 526                 return ;
 527         }
 528
 529         /*
 530          * ignore frames with illegal length
 531          */
 532         if (((sm->smt_class == SMT_ECF) && (sm->smt_len > SMT_MAX_ECHO_LEN)) ||
 533             ((sm->smt_class != SMT_ECF) && (sm->smt_len > SMT_MAX_INFO_LEN))) {
 534                 smt_free_mbuf(smc,mb) ;
 535                 return ;
 536         }
 537
 538         /*
 539          * check SMT version
 540          */
 541         switch (sm->smt_class) {
 542         case SMT_NIF :
 543         case SMT_SIF_CONFIG :
 544         case SMT_SIF_OPER :
 545         case SMT_ECF :
 546                 if (sm->smt_version != SMT_VID)
 547                         illegal = 1;
 548                 break ;
 549         default :
 550                 if (sm->smt_version != SMT_VID_2)
 551                         illegal = 1;
 552                 break ;
 553         }
 554         if (illegal) {
 555                 DB_SMT("SMT : version = %d, dest = %s",
 556                        sm->smt_version, addr_to_string(&sm->smt_source));
 557                 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_VERSION,local) ;
 558                 smt_free_mbuf(smc,mb) ;
 559                 return ;
 560         }
 561         if ((sm->smt_len > mb->sm_len - sizeof(struct smt_header)) ||
 562             ((sm->smt_len & 3) && (sm->smt_class != SMT_ECF))) {
 563                 DB_SMT("SMT: info length error, len = %d", sm->smt_len);
 564                 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,local) ;
 565                 smt_free_mbuf(smc,mb) ;
 566                 return ;
 567         }
 568         switch (sm->smt_class) {
 569         case SMT_NIF :
 570                 if (smt_check_para(smc,sm,plist_nif)) {
 571                         DB_SMT("SMT: NIF with para problem, ignoring");
 572                         break ;
 573                 }
 574                 switch (sm->smt_type) {
 575                 case SMT_ANNOUNCE :
 576                 case SMT_REQUEST :
 577                         if (!(fs & C_INDICATOR) && m_fc(mb) == FC_SMT_NSA
 578                                 && is_broadcast(&sm->smt_dest)) {
 579                                 struct smt_p_state      *st ;
 580
 581                                 /* set my UNA */
 582                                 if (!is_equal(
 583                                         &smc->mib.m[MAC0].fddiMACUpstreamNbr,
 584                                         &sm->smt_source)) {
 585                                         DB_SMT("SMT : updated my UNA = %s",
 586                                                addr_to_string(&sm->smt_source));
 587                                         if (!is_equal(&smc->mib.m[MAC0].
 588                                             fddiMACUpstreamNbr,&SMT_Unknown)){
 589                                          /* Do not update unknown address */
 590                                          smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
 591                                          smc->mib.m[MAC0].fddiMACUpstreamNbr ;
 592                                         }
 593
 594                                         smc->mib.m[MAC0].fddiMACUpstreamNbr =
 595                                                 sm->smt_source ;
 596                                         smt_srf_event(smc,
 597                                                 SMT_EVENT_MAC_NEIGHBOR_CHANGE,
 598                                                 INDEX_MAC,0) ;
 599                                         smt_echo_test(smc,0) ;
 600                                 }
 601                                 smc->sm.smt_tvu = smt_get_time() ;
 602                                 st = (struct smt_p_state *)
 603                                         sm_to_para(smc,sm,SMT_P_STATE) ;
 604                                 if (st) {
 605                                         smc->mib.m[MAC0].fddiMACUNDA_Flag =
 606                                         (st->st_dupl_addr & SMT_ST_MY_DUPA) ?
 607                                         TRUE : FALSE ;
 608                                         update_dac(smc,1) ;
 609                                 }
 610                         }
 611                         if ((sm->smt_type == SMT_REQUEST) &&
 612                             is_individual(&sm->smt_source) &&
 613                             ((!(fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) ||
 614                              (m_fc(mb) != FC_SMT_NSA))) {
 615                                 DB_SMT("SMT : replying to NIF request %s",
 616                                        addr_to_string(&sm->smt_source));
 617                                 smt_send_nif(smc,&sm->smt_source,
 618                                         FC_SMT_INFO,
 619                                         sm->smt_tid,
 620                                         SMT_REPLY,local) ;
 621                         }
 622                         break ;
 623                 case SMT_REPLY :
 624                         DB_SMT("SMT : received NIF response from %s",
 625                                addr_to_string(&sm->smt_source));
 626                         if (fs & A_INDICATOR) {
 627                                 smc->sm.pend[SMT_TID_NIF] = 0 ;
 628                                 DB_SMT("SMT : duplicate address");
 629                                 smc->mib.m[MAC0].fddiMACDupAddressTest =
 630                                         DA_FAILED ;
 631                                 smc->r.dup_addr_test = DA_FAILED ;
 632                                 queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
 633                                 smc->mib.m[MAC0].fddiMACDA_Flag = TRUE ;
 634                                 update_dac(smc,1) ;
 635                                 break ;
 636                         }
 637                         if (sm->smt_tid == smc->sm.pend[SMT_TID_NIF]) {
 638                                 smc->sm.pend[SMT_TID_NIF] = 0 ;
 639                                 /* set my DNA */
 640                                 if (!is_equal(
 641                                         &smc->mib.m[MAC0].fddiMACDownstreamNbr,
 642                                         &sm->smt_source)) {
 643                                         DB_SMT("SMT : updated my DNA");
 644                                         if (!is_equal(&smc->mib.m[MAC0].
 645                                          fddiMACDownstreamNbr, &SMT_Unknown)){
 646                                          /* Do not update unknown address */
 647                                 smc->mib.m[MAC0].fddiMACOldDownstreamNbr =
 648                                          smc->mib.m[MAC0].fddiMACDownstreamNbr ;
 649                                         }
 650
 651                                         smc->mib.m[MAC0].fddiMACDownstreamNbr =
 652                                                 sm->smt_source ;
 653                                         smt_srf_event(smc,
 654                                                 SMT_EVENT_MAC_NEIGHBOR_CHANGE,
 655                                                 INDEX_MAC,0) ;
 656                                         smt_echo_test(smc,1) ;
 657                                 }
 658                                 smc->mib.m[MAC0].fddiMACDA_Flag = FALSE ;
 659                                 update_dac(smc,1) ;
 660                                 smc->sm.smt_tvd = smt_get_time() ;
 661                                 smc->mib.m[MAC0].fddiMACDupAddressTest =
 662                                         DA_PASSED ;
 663                                 if (smc->r.dup_addr_test != DA_PASSED) {
 664                                         smc->r.dup_addr_test = DA_PASSED ;
 665                                         queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
 666                                 }
 667                         }
 668                         else if (sm->smt_tid ==
 669                                 smc->sm.pend[SMT_TID_NIF_TEST]) {
 670                                 DB_SMT("SMT : NIF test TID ok");
 671                         }
 672                         else {
 673                                 DB_SMT("SMT : expected TID %lx, got %x",
 674                                        smc->sm.pend[SMT_TID_NIF], sm->smt_tid);
 675                         }
 676                         break ;
 677                 default :
 678                         illegal = 2 ;
 679                         break ;
 680                 }
 681                 break ;
 682         case SMT_SIF_CONFIG :   /* station information */
 683                 if (sm->smt_type != SMT_REQUEST)
 684                         break ;
 685                 DB_SMT("SMT : replying to SIF Config request from %s",
 686                        addr_to_string(&sm->smt_source));
 687                 smt_send_sif_config(smc,&sm->smt_source,sm->smt_tid,local) ;
 688                 break ;
 689         case SMT_SIF_OPER :     /* station information */
 690                 if (sm->smt_type != SMT_REQUEST)
 691                         break ;
 692                 DB_SMT("SMT : replying to SIF Operation request from %s",
 693                        addr_to_string(&sm->smt_source));
 694                 smt_send_sif_operation(smc,&sm->smt_source,sm->smt_tid,local) ;
 695                 break ;
 696         case SMT_ECF :          /* echo frame */
 697                 switch (sm->smt_type) {
 698                 case SMT_REPLY :
 699                         smc->mib.priv.fddiPRIVECF_Reply_Rx++ ;
 700                         DB_SMT("SMT: received ECF reply from %s",
 701                                addr_to_string(&sm->smt_source));
 702                         if (sm_to_para(smc,sm,SMT_P_ECHODATA) == NULL) {
 703                                 DB_SMT("SMT: ECHODATA missing");
 704                                 break ;
 705                         }
 706                         if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF]) {
 707                                 DB_SMT("SMT : ECF test TID ok");
 708                         }
 709                         else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_UNA]) {
 710                                 DB_SMT("SMT : ECF test UNA ok");
 711                         }
 712                         else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_DNA]) {
 713                                 DB_SMT("SMT : ECF test DNA ok");
 714                         }
 715                         else {
 716                                 DB_SMT("SMT : expected TID %lx, got %x",
 717                                        smc->sm.pend[SMT_TID_ECF],
 718                                        sm->smt_tid);
 719                         }
 720                         break ;
 721                 case SMT_REQUEST :
 722                         smc->mib.priv.fddiPRIVECF_Req_Rx++ ;
 723                         {
 724                         if (sm->smt_len && !sm_to_para(smc,sm,SMT_P_ECHODATA)) {
 725                                 DB_SMT("SMT: ECF with para problem,sending RDF");
 726                                 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,
 727                                         local) ;
 728                                 break ;
 729                         }
 730                         DB_SMT("SMT - sending ECF reply to %s",
 731                                addr_to_string(&sm->smt_source));
 732
 733                         /* set destination addr.  & reply */
 734                         sm->smt_dest = sm->smt_source ;
 735                         sm->smt_type = SMT_REPLY ;
 736                         dump_smt(smc,sm,"ECF REPLY") ;
 737                         smc->mib.priv.fddiPRIVECF_Reply_Tx++ ;
 738                         smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
 739                         return ;                /* DON'T free mbuf */
 740                         }
 741                 default :
 742                         illegal = 1 ;
 743                         break ;
 744                 }
 745                 break ;
 746 #ifndef BOOT
 747         case SMT_RAF :          /* resource allocation */
 748 #ifdef  ESS
 749                 DB_ESSN(2, "ESS: RAF frame received");
 750                 fs = ess_raf_received_pack(smc,mb,sm,fs) ;
 751 #endif
 752
 753 #ifdef  SBA
 754                 DB_SBAN(2,"SBA: RAF frame received\n",0,0) ;
 755                 sba_raf_received_pack(smc,sm,fs) ;
 756 #endif
 757                 break ;
 758         case SMT_RDF :          /* request denied */
 759                 smc->mib.priv.fddiPRIVRDF_Rx++ ;
 760                 break ;
 761         case SMT_ESF :          /* extended service - not supported */
 762                 if (sm->smt_type == SMT_REQUEST) {
 763                         DB_SMT("SMT - received ESF, sending RDF");
 764                         smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
 765                 }
 766                 break ;
 767         case SMT_PMF_GET :
 768         case SMT_PMF_SET :
 769                 if (sm->smt_type != SMT_REQUEST)
 770                         break ;
 771                 /* update statistics */
 772                 if (sm->smt_class == SMT_PMF_GET)
 773                         smc->mib.priv.fddiPRIVPMF_Get_Rx++ ;
 774                 else
 775                         smc->mib.priv.fddiPRIVPMF_Set_Rx++ ;
 776                 /*
 777                  * ignore PMF SET with I/G set
 778                  */
 779                 if ((sm->smt_class == SMT_PMF_SET) &&
 780                         !is_individual(&sm->smt_dest)) {
 781                         DB_SMT("SMT: ignoring PMF-SET with I/G set");
 782                         break ;
 783                 }
 784                 smt_pmf_received_pack(smc,mb, local) ;
 785                 break ;
 786         case SMT_SRF :
 787                 dump_smt(smc,sm,"SRF received") ;
 788                 break ;
 789         default :
 790                 if (sm->smt_type != SMT_REQUEST)
 791                         break ;
 792                 /*
 793                  * For frames with unknown class:
 794                  * we need to send a RDF frame according to 8.1.3.1.1,
 795                  * only if it is a REQUEST.
 796                  */
 797                 DB_SMT("SMT : class = %d, send RDF to %s",
 798                        sm->smt_class, addr_to_string(&sm->smt_source));
 799
 800                 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
 801                 break ;
 802 #endif
 803         }
 804         if (illegal) {
 805                 DB_SMT("SMT: discarding invalid frame, reason = %d", illegal);
 806         }
 807         smt_free_mbuf(smc,mb) ;
 808 }
 809
 810 static void update_dac(struct s_smc *smc, int report)
 811 {
 812         int     cond ;
 813
 814         cond = ( smc->mib.m[MAC0].fddiMACUNDA_Flag |
 815                 smc->mib.m[MAC0].fddiMACDA_Flag) != 0 ;
 816         if (report && (cond != smc->mib.m[MAC0].fddiMACDuplicateAddressCond))
 817                 smt_srf_event(smc, SMT_COND_MAC_DUP_ADDR,INDEX_MAC,cond) ;
 818         else
 819                 smc->mib.m[MAC0].fddiMACDuplicateAddressCond = cond ;
 820 }
 821
 822 /*
 823  * send SMT frame
 824  *      set source address
 825  *      set station ID
 826  *      send frame
 827  */
 828 void smt_send_frame(struct s_smc *smc, SMbuf *mb, int fc, int local)
 829 /* SMbuf *mb;   buffer to send */
 830 /* int fc;      FC value */
 831 {
 832         struct smt_header       *sm ;
 833
 834         if (!smc->r.sm_ma_avail && !local) {
 835                 smt_free_mbuf(smc,mb) ;
 836                 return ;
 837         }
 838         sm = smtod(mb,struct smt_header *) ;
 839         sm->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
 840         sm->smt_sid = smc->mib.fddiSMTStationId ;
 841
 842         smt_swap_para(sm,(int) mb->sm_len,0) ;          /* swap para & header */
 843         hwm_conv_can(smc,(char *)sm,12) ;               /* convert SA and DA */
 844         smc->mib.m[MAC0].fddiMACSMTTransmit_Ct++ ;
 845         smt_send_mbuf(smc,mb,local ? FC_SMT_LOC : fc) ;
 846 }
 847
 848 /*
 849  * generate and send RDF
 850  */
 851 static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
 852                          int local)
 853 /* SMbuf *rej;  mbuf of offending frame */
 854 /* int fc;      FC of denied frame */
 855 /* int reason;  reason code */
 856 {
 857         SMbuf   *mb ;
 858         struct smt_header       *sm ;   /* header of offending frame */
 859         struct smt_rdf  *rdf ;
 860         int             len ;
 861         int             frame_len ;
 862
 863         sm = smtod(rej,struct smt_header *) ;
 864         if (sm->smt_type != SMT_REQUEST)
 865                 return ;
 866
 867         DB_SMT("SMT: sending RDF to %s,reason = 0x%x",
 868                addr_to_string(&sm->smt_source), reason);
 869
 870
 871         /*
 872          * note: get framelength from MAC length, NOT from SMT header
 873          * smt header length is included in sm_len
 874          */
 875         frame_len = rej->sm_len ;
 876
 877         if (!(mb=smt_build_frame(smc,SMT_RDF,SMT_REPLY,sizeof(struct smt_rdf))))
 878                 return ;
 879         rdf = smtod(mb,struct smt_rdf *) ;
 880         rdf->smt.smt_tid = sm->smt_tid ;                /* use TID from sm */
 881         rdf->smt.smt_dest = sm->smt_source ;            /* set dest = source */
 882
 883         /* set P12 */
 884         rdf->reason.para.p_type = SMT_P_REASON ;
 885         rdf->reason.para.p_len = sizeof(struct smt_p_reason) - PARA_LEN ;
 886         rdf->reason.rdf_reason = reason ;
 887
 888         /* set P14 */
 889         rdf->version.para.p_type = SMT_P_VERSION ;
 890         rdf->version.para.p_len = sizeof(struct smt_p_version) - PARA_LEN ;
 891         rdf->version.v_pad = 0 ;
 892         rdf->version.v_n = 1 ;
 893         rdf->version.v_index = 1 ;
 894         rdf->version.v_version[0] = SMT_VID_2 ;
 895         rdf->version.v_pad2 = 0 ;
 896
 897         /* set P13 */
 898         if ((unsigned int) frame_len <= SMT_MAX_INFO_LEN - sizeof(*rdf) +
 899                 2*sizeof(struct smt_header))
 900                 len = frame_len ;
 901         else
 902                 len = SMT_MAX_INFO_LEN - sizeof(*rdf) +
 903                         2*sizeof(struct smt_header) ;
 904         /* make length multiple of 4 */
 905         len &= ~3 ;
 906         rdf->refused.para.p_type = SMT_P_REFUSED ;
 907         /* length of para is smt_frame + ref_fc */
 908         rdf->refused.para.p_len = len + 4 ;
 909         rdf->refused.ref_fc = fc ;
 910
 911         /* swap it back */
 912         smt_swap_para(sm,frame_len,0) ;
 913
 914         memcpy((char *) &rdf->refused.ref_header,(char *) sm,len) ;
 915
 916         len -= sizeof(struct smt_header) ;
 917         mb->sm_len += len ;
 918         rdf->smt.smt_len += len ;
 919
 920         dump_smt(smc,(struct smt_header *)rdf,"RDF") ;
 921         smc->mib.priv.fddiPRIVRDF_Tx++ ;
 922         smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
 923 }
 924
 925 /*
 926  * generate and send NIF
 927  */
 928 static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
 929                          int fc, u_long tid, int type, int local)
 930 /* struct fddi_addr *dest;      dest address */
 931 /* int fc;                      frame control */
 932 /* u_long tid;                  transaction id */
 933 /* int type;                    frame type */
 934 {
 935         struct smt_nif  *nif ;
 936         SMbuf           *mb ;
 937
 938         if (!(mb = smt_build_frame(smc,SMT_NIF,type,sizeof(struct smt_nif))))
 939                 return ;
 940         nif = smtod(mb, struct smt_nif *) ;
 941         smt_fill_una(smc,&nif->una) ;   /* set UNA */
 942         smt_fill_sde(smc,&nif->sde) ;   /* set station descriptor */
 943         smt_fill_state(smc,&nif->state) ;       /* set state information */
 944 #ifdef  SMT6_10
 945         smt_fill_fsc(smc,&nif->fsc) ;   /* set frame status cap. */
 946 #endif
 947         nif->smt.smt_dest = *dest ;     /* destination address */
 948         nif->smt.smt_tid = tid ;        /* transaction ID */
 949         dump_smt(smc,(struct smt_header *)nif,"NIF") ;
 950         smt_send_frame(smc,mb,fc,local) ;
 951 }
 952
 953 #ifdef  DEBUG
 954 /*
 955  * send NIF request (test purpose)
 956  */
 957 static void smt_send_nif_request(struct s_smc *smc, struct fddi_addr *dest)
 958 {
 959         smc->sm.pend[SMT_TID_NIF_TEST] = smt_get_tid(smc) ;
 960         smt_send_nif(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_NIF_TEST],
 961                 SMT_REQUEST,0) ;
 962 }
 963
 964 /*
 965  * send ECF request (test purpose)
 966  */
 967 static void smt_send_ecf_request(struct s_smc *smc, struct fddi_addr *dest,
 968                                  int len)
 969 {
 970         smc->sm.pend[SMT_TID_ECF] = smt_get_tid(smc) ;
 971         smt_send_ecf(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_ECF],
 972                 SMT_REQUEST,len) ;
 973 }
 974 #endif
 975
 976 /*
 977  * echo test
 978  */
 979 static void smt_echo_test(struct s_smc *smc, int dna)
 980 {
 981         u_long  tid ;
 982
 983         smc->sm.pend[dna ? SMT_TID_ECF_DNA : SMT_TID_ECF_UNA] =
 984                 tid = smt_get_tid(smc) ;
 985         smt_send_ecf(smc, dna ?
 986                 &smc->mib.m[MAC0].fddiMACDownstreamNbr :
 987                 &smc->mib.m[MAC0].fddiMACUpstreamNbr,
 988                 FC_SMT_INFO,tid, SMT_REQUEST, (SMT_TEST_ECHO_LEN & ~3)-8) ;
 989 }
 990
 991 /*
 992  * generate and send ECF
 993  */
 994 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
 995                          u_long tid, int type, int len)
 996 /* struct fddi_addr *dest;      dest address */
 997 /* int fc;                      frame control */
 998 /* u_long tid;                  transaction id */
 999 /* int type;                    frame type */
1000 /* int len;                     frame length */
1001 {
1002         struct smt_ecf  *ecf ;
1003         SMbuf           *mb ;
1004
1005         if (!(mb = smt_build_frame(smc,SMT_ECF,type,SMT_ECF_LEN + len)))
1006                 return ;
1007         ecf = smtod(mb, struct smt_ecf *) ;
1008
1009         smt_fill_echo(smc,&ecf->ec_echo,tid,len) ;      /* set ECHO */
1010         ecf->smt.smt_dest = *dest ;     /* destination address */
1011         ecf->smt.smt_tid = tid ;        /* transaction ID */
1012         smc->mib.priv.fddiPRIVECF_Req_Tx++ ;
1013         smt_send_frame(smc,mb,fc,0) ;
1014 }
1015
1016 /*
1017  * generate and send SIF config response
1018  */
1019
1020 static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
1021                                 u_long tid, int local)
1022 /* struct fddi_addr *dest;      dest address */
1023 /* u_long tid;                  transaction id */
1024 {
1025         struct smt_sif_config   *sif ;
1026         SMbuf                   *mb ;
1027         int                     len ;
1028         if (!(mb = smt_build_frame(smc,SMT_SIF_CONFIG,SMT_REPLY,
1029                 SIZEOF_SMT_SIF_CONFIG)))
1030                 return ;
1031
1032         sif = smtod(mb, struct smt_sif_config *) ;
1033         smt_fill_timestamp(smc,&sif->ts) ;      /* set time stamp */
1034         smt_fill_sde(smc,&sif->sde) ;           /* set station descriptor */
1035         smt_fill_version(smc,&sif->version) ;   /* set version information */
1036         smt_fill_state(smc,&sif->state) ;       /* set state information */
1037         smt_fill_policy(smc,&sif->policy) ;     /* set station policy */
1038         smt_fill_latency(smc,&sif->latency);    /* set station latency */
1039         smt_fill_neighbor(smc,&sif->neighbor);  /* set station neighbor */
1040         smt_fill_setcount(smc,&sif->setcount) ; /* set count */
1041         len = smt_fill_path(smc,&sif->path);    /* set station path descriptor*/
1042         sif->smt.smt_dest = *dest ;             /* destination address */
1043         sif->smt.smt_tid = tid ;                /* transaction ID */
1044         smt_add_frame_len(mb,len) ;             /* adjust length fields */
1045         dump_smt(smc,(struct smt_header *)sif,"SIF Configuration Reply") ;
1046         smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1047 }
1048
1049 /*
1050  * generate and send SIF operation response
1051  */
1052
1053 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
1054                                    u_long tid, int local)
1055 /* struct fddi_addr *dest;      dest address */
1056 /* u_long tid;                  transaction id */
1057 {
1058         struct smt_sif_operation *sif ;
1059         SMbuf                   *mb ;
1060         int                     ports ;
1061         int                     i ;
1062
1063         ports = NUMPHYS ;
1064 #ifndef CONCENTRATOR
1065         if (smc->s.sas == SMT_SAS)
1066                 ports = 1 ;
1067 #endif
1068
1069         if (!(mb = smt_build_frame(smc,SMT_SIF_OPER,SMT_REPLY,
1070                 SIZEOF_SMT_SIF_OPERATION+ports*sizeof(struct smt_p_lem))))
1071                 return ;
1072         sif = smtod(mb, struct smt_sif_operation *) ;
1073         smt_fill_timestamp(smc,&sif->ts) ;      /* set time stamp */
1074         smt_fill_mac_status(smc,&sif->status) ; /* set mac status */
1075         smt_fill_mac_counter(smc,&sif->mc) ; /* set mac counter field */
1076         smt_fill_mac_fnc(smc,&sif->fnc) ; /* set frame not copied counter */
1077         smt_fill_manufacturer(smc,&sif->man) ; /* set manufacturer field */
1078         smt_fill_user(smc,&sif->user) ;         /* set user field */
1079         smt_fill_setcount(smc,&sif->setcount) ; /* set count */
1080         /*
1081          * set link error mon information
1082          */
1083         if (ports == 1) {
1084                 smt_fill_lem(smc,sif->lem,PS) ;
1085         }
1086         else {
1087                 for (i = 0 ; i < ports ; i++) {
1088                         smt_fill_lem(smc,&sif->lem[i],i) ;
1089                 }
1090         }
1091
1092         sif->smt.smt_dest = *dest ;     /* destination address */
1093         sif->smt.smt_tid = tid ;        /* transaction ID */
1094         dump_smt(smc,(struct smt_header *)sif,"SIF Operation Reply") ;
1095         smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1096 }
1097
1098 /*
1099  * get and initialize SMT frame
1100  */
1101 SMbuf *smt_build_frame(struct s_smc *smc, int class, int type,
1102                                   int length)
1103 {
1104         SMbuf                   *mb ;
1105         struct smt_header       *smt ;
1106
1107 #if     0
1108         if (!smc->r.sm_ma_avail) {
1109                 return 0;
1110         }
1111 #endif
1112         if (!(mb = smt_get_mbuf(smc)))
1113                 return mb;
1114
1115         mb->sm_len = length ;
1116         smt = smtod(mb, struct smt_header *) ;
1117         smt->smt_dest = fddi_broadcast ; /* set dest = broadcast */
1118         smt->smt_class = class ;
1119         smt->smt_type = type ;
1120         switch (class) {
1121         case SMT_NIF :
1122         case SMT_SIF_CONFIG :
1123         case SMT_SIF_OPER :
1124         case SMT_ECF :
1125                 smt->smt_version = SMT_VID ;
1126                 break ;
1127         default :
1128                 smt->smt_version = SMT_VID_2 ;
1129                 break ;
1130         }
1131         smt->smt_tid = smt_get_tid(smc) ;       /* set transaction ID */
1132         smt->smt_pad = 0 ;
1133         smt->smt_len = length - sizeof(struct smt_header) ;
1134         return mb;
1135 }
1136
1137 static void smt_add_frame_len(SMbuf *mb, int len)
1138 {
1139         struct smt_header       *smt ;
1140
1141         smt = smtod(mb, struct smt_header *) ;
1142         smt->smt_len += len ;
1143         mb->sm_len += len ;
1144 }
1145
1146
1147
1148 /*
1149  * fill values in UNA parameter
1150  */
1151 static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una)
1152 {
1153         SMTSETPARA(una,SMT_P_UNA) ;
1154         una->una_pad = 0 ;
1155         una->una_node = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1156 }
1157
1158 /*
1159  * fill values in SDE parameter
1160  */
1161 static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde)
1162 {
1163         SMTSETPARA(sde,SMT_P_SDE) ;
1164         sde->sde_non_master = smc->mib.fddiSMTNonMaster_Ct ;
1165         sde->sde_master = smc->mib.fddiSMTMaster_Ct ;
1166         sde->sde_mac_count = NUMMACS ;          /* only 1 MAC */
1167 #ifdef  CONCENTRATOR
1168         sde->sde_type = SMT_SDE_CONCENTRATOR ;
1169 #else
1170         sde->sde_type = SMT_SDE_STATION ;
1171 #endif
1172 }
1173
1174 /*
1175  * fill in values in station state parameter
1176  */
1177 static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state)
1178 {
1179         int     top ;
1180         int     twist ;
1181
1182         SMTSETPARA(state,SMT_P_STATE) ;
1183         state->st_pad = 0 ;
1184
1185         /* determine topology */
1186         top = 0 ;
1187         if (smc->mib.fddiSMTPeerWrapFlag) {
1188                 top |= SMT_ST_WRAPPED ;         /* state wrapped */
1189         }
1190 #ifdef  CONCENTRATOR
1191         if (cfm_status_unattached(smc)) {
1192                 top |= SMT_ST_UNATTACHED ;      /* unattached concentrator */
1193         }
1194 #endif
1195         if ((twist = pcm_status_twisted(smc)) & 1) {
1196                 top |= SMT_ST_TWISTED_A ;       /* twisted cable */
1197         }
1198         if (twist & 2) {
1199                 top |= SMT_ST_TWISTED_B ;       /* twisted cable */
1200         }
1201 #ifdef  OPT_SRF
1202         top |= SMT_ST_SRF ;
1203 #endif
1204         if (pcm_rooted_station(smc))
1205                 top |= SMT_ST_ROOTED_S ;
1206         if (smc->mib.a[0].fddiPATHSbaPayload != 0)
1207                 top |= SMT_ST_SYNC_SERVICE ;
1208         state->st_topology = top ;
1209         state->st_dupl_addr =
1210                 ((smc->mib.m[MAC0].fddiMACDA_Flag ? SMT_ST_MY_DUPA : 0 ) |
1211                  (smc->mib.m[MAC0].fddiMACUNDA_Flag ? SMT_ST_UNA_DUPA : 0)) ;
1212 }
1213
1214 /*
1215  * fill values in timestamp parameter
1216  */
1217 static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts)
1218 {
1219
1220         SMTSETPARA(ts,SMT_P_TIMESTAMP) ;
1221         smt_set_timestamp(smc,ts->ts_time) ;
1222 }
1223
1224 void smt_set_timestamp(struct s_smc *smc, u_char *p)
1225 {
1226         u_long  time ;
1227         u_long  utime ;
1228
1229         /*
1230          * timestamp is 64 bits long ; resolution is 80 nS
1231          * our clock resolution is 10mS
1232          * 10mS/80ns = 125000 ~ 2^17 = 131072
1233          */
1234         utime = smt_get_time() ;
1235         time = utime * 100 ;
1236         time /= TICKS_PER_SECOND ;
1237         p[0] = 0 ;
1238         p[1] = (u_char)((time>>(8+8+8+8-1)) & 1) ;
1239         p[2] = (u_char)(time>>(8+8+8-1)) ;
1240         p[3] = (u_char)(time>>(8+8-1)) ;
1241         p[4] = (u_char)(time>>(8-1)) ;
1242         p[5] = (u_char)(time<<1) ;
1243         p[6] = (u_char)(smc->sm.uniq_ticks>>8) ;
1244         p[7] = (u_char)smc->sm.uniq_ticks ;
1245         /*
1246          * make sure we don't wrap: restart whenever the upper digits change
1247          */
1248         if (utime != smc->sm.uniq_time) {
1249                 smc->sm.uniq_ticks = 0 ;
1250         }
1251         smc->sm.uniq_ticks++ ;
1252         smc->sm.uniq_time = utime ;
1253 }
1254
1255 /*
1256  * fill values in station policy parameter
1257  */
1258 static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy)
1259 {
1260         int     i ;
1261         const u_char *map ;
1262         u_short in ;
1263         u_short out ;
1264
1265         /*
1266          * MIB para 101b (fddiSMTConnectionPolicy) coding
1267          * is different from 0005 coding
1268          */
1269         static const u_char ansi_weirdness[16] = {
1270                 0,7,5,3,8,1,6,4,9,10,2,11,12,13,14,15
1271         } ;
1272         SMTSETPARA(policy,SMT_P_POLICY) ;
1273
1274         out = 0 ;
1275         in = smc->mib.fddiSMTConnectionPolicy ;
1276         for (i = 0, map = ansi_weirdness ; i < 16 ; i++) {
1277                 if (in & 1)
1278                         out |= (1<<*map) ;
1279                 in >>= 1 ;
1280                 map++ ;
1281         }
1282         policy->pl_config = smc->mib.fddiSMTConfigPolicy ;
1283         policy->pl_connect = out ;
1284 }
1285
1286 /*
1287  * fill values in latency equivalent parameter
1288  */
1289 static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency)
1290 {
1291         SMTSETPARA(latency,SMT_P_LATENCY) ;
1292
1293         latency->lt_phyout_idx1 = phy_index(smc,0) ;
1294         latency->lt_latency1 = 10 ;     /* in octets (byte clock) */
1295         /*
1296          * note: latency has two phy entries by definition
1297          * for a SAS, the 2nd one is null
1298          */
1299         if (smc->s.sas == SMT_DAS) {
1300                 latency->lt_phyout_idx2 = phy_index(smc,1) ;
1301                 latency->lt_latency2 = 10 ;     /* in octets (byte clock) */
1302         }
1303         else {
1304                 latency->lt_phyout_idx2 = 0 ;
1305                 latency->lt_latency2 = 0 ;
1306         }
1307 }
1308
1309 /*
1310  * fill values in MAC neighbors parameter
1311  */
1312 static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor)
1313 {
1314         SMTSETPARA(neighbor,SMT_P_NEIGHBORS) ;
1315
1316         neighbor->nb_mib_index = INDEX_MAC ;
1317         neighbor->nb_mac_index = mac_index(smc,1) ;
1318         neighbor->nb_una = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1319         neighbor->nb_dna = smc->mib.m[MAC0].fddiMACDownstreamNbr ;
1320 }
1321
1322 /*
1323  * fill values in path descriptor
1324  */
1325 #ifdef  CONCENTRATOR
1326 #define ALLPHYS NUMPHYS
1327 #else
1328 #define ALLPHYS ((smc->s.sas == SMT_SAS) ? 1 : 2)
1329 #endif
1330
1331 static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path)
1332 {
1333         SK_LOC_DECL(int,type) ;
1334         SK_LOC_DECL(int,state) ;
1335         SK_LOC_DECL(int,remote) ;
1336         SK_LOC_DECL(int,mac) ;
1337         int     len ;
1338         int     p ;
1339         int     physp ;
1340         struct smt_phy_rec      *phy ;
1341         struct smt_mac_rec      *pd_mac ;
1342
1343         len =   PARA_LEN +
1344                 sizeof(struct smt_mac_rec) * NUMMACS +
1345                 sizeof(struct smt_phy_rec) * ALLPHYS ;
1346         path->para.p_type = SMT_P_PATH ;
1347         path->para.p_len = len - PARA_LEN ;
1348
1349         /* PHYs */
1350         for (p = 0,phy = path->pd_phy ; p < ALLPHYS ; p++, phy++) {
1351                 physp = p ;
1352 #ifndef CONCENTRATOR
1353                 if (smc->s.sas == SMT_SAS)
1354                         physp = PS ;
1355 #endif
1356                 pcm_status_state(smc,physp,&type,&state,&remote,&mac) ;
1357 #ifdef  LITTLE_ENDIAN
1358                 phy->phy_mib_index = smt_swap_short((u_short)p+INDEX_PORT) ;
1359 #else
1360                 phy->phy_mib_index = p+INDEX_PORT ;
1361 #endif
1362                 phy->phy_type = type ;
1363                 phy->phy_connect_state = state ;
1364                 phy->phy_remote_type = remote ;
1365                 phy->phy_remote_mac = mac ;
1366                 phy->phy_resource_idx = phy_con_resource_index(smc,p) ;
1367         }
1368
1369         /* MAC */
1370         pd_mac = (struct smt_mac_rec *) phy ;
1371         pd_mac->mac_addr = smc->mib.m[MAC0].fddiMACSMTAddress ;
1372         pd_mac->mac_resource_idx = mac_con_resource_index(smc,1) ;
1373         return len;
1374 }
1375
1376 /*
1377  * fill values in mac status
1378  */
1379 static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st)
1380 {
1381         SMTSETPARA(st,SMT_P_MAC_STATUS) ;
1382
1383         st->st_mib_index = INDEX_MAC ;
1384         st->st_mac_index = mac_index(smc,1) ;
1385
1386         mac_update_counter(smc) ;
1387         /*
1388          * timer values are represented in SMT as 2's complement numbers
1389          * units :      internal :  2's complement BCLK
1390          */
1391         st->st_t_req = smc->mib.m[MAC0].fddiMACT_Req ;
1392         st->st_t_neg = smc->mib.m[MAC0].fddiMACT_Neg ;
1393         st->st_t_max = smc->mib.m[MAC0].fddiMACT_Max ;
1394         st->st_tvx_value = smc->mib.m[MAC0].fddiMACTvxValue ;
1395         st->st_t_min = smc->mib.m[MAC0].fddiMACT_Min ;
1396
1397         st->st_sba = smc->mib.a[PATH0].fddiPATHSbaPayload ;
1398         st->st_frame_ct = smc->mib.m[MAC0].fddiMACFrame_Ct ;
1399         st->st_error_ct = smc->mib.m[MAC0].fddiMACError_Ct ;
1400         st->st_lost_ct = smc->mib.m[MAC0].fddiMACLost_Ct ;
1401 }
1402
1403 /*
1404  * fill values in LEM status
1405  */
1406 static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy)
1407 {
1408         struct fddi_mib_p       *mib ;
1409
1410         mib = smc->y[phy].mib ;
1411
1412         SMTSETPARA(lem,SMT_P_LEM) ;
1413         lem->lem_mib_index = phy+INDEX_PORT ;
1414         lem->lem_phy_index = phy_index(smc,phy) ;
1415         lem->lem_pad2 = 0 ;
1416         lem->lem_cutoff = mib->fddiPORTLer_Cutoff ;
1417         lem->lem_alarm = mib->fddiPORTLer_Alarm ;
1418         /* long term bit error rate */
1419         lem->lem_estimate = mib->fddiPORTLer_Estimate ;
1420         /* # of rejected connections */
1421         lem->lem_reject_ct = mib->fddiPORTLem_Reject_Ct ;
1422         lem->lem_ct = mib->fddiPORTLem_Ct ;     /* total number of errors */
1423 }
1424
1425 /*
1426  * fill version parameter
1427  */
1428 static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers)
1429 {
1430         SK_UNUSED(smc) ;
1431         SMTSETPARA(vers,SMT_P_VERSION) ;
1432         vers->v_pad = 0 ;
1433         vers->v_n = 1 ;                         /* one version is enough .. */
1434         vers->v_index = 1 ;
1435         vers->v_version[0] = SMT_VID_2 ;
1436         vers->v_pad2 = 0 ;
1437 }
1438
1439 #ifdef  SMT6_10
1440 /*
1441  * fill frame status capabilities
1442  */
1443 /*
1444  * note: this para 200B is NOT in swap table, because it's also set in
1445  * PMF add_para
1446  */
1447 static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc)
1448 {
1449         SK_UNUSED(smc) ;
1450         SMTSETPARA(fsc,SMT_P_FSC) ;
1451         fsc->fsc_pad0 = 0 ;
1452         fsc->fsc_mac_index = INDEX_MAC ;        /* this is MIB ; MIB is NOT
1453                                                  * mac_index ()i !
1454                                                  */
1455         fsc->fsc_pad1 = 0 ;
1456         fsc->fsc_value = FSC_TYPE0 ;            /* "normal" node */
1457 #ifdef  LITTLE_ENDIAN
1458         fsc->fsc_mac_index = smt_swap_short(INDEX_MAC) ;
1459         fsc->fsc_value = smt_swap_short(FSC_TYPE0) ;
1460 #endif
1461 }
1462 #endif
1463
1464 /*
1465  * fill mac counter field
1466  */
1467 static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc)
1468 {
1469         SMTSETPARA(mc,SMT_P_MAC_COUNTER) ;
1470         mc->mc_mib_index = INDEX_MAC ;
1471         mc->mc_index = mac_index(smc,1) ;
1472         mc->mc_receive_ct = smc->mib.m[MAC0].fddiMACCopied_Ct ;
1473         mc->mc_transmit_ct =  smc->mib.m[MAC0].fddiMACTransmit_Ct ;
1474 }
1475
1476 /*
1477  * fill mac frame not copied counter
1478  */
1479 static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc)
1480 {
1481         SMTSETPARA(fnc,SMT_P_MAC_FNC) ;
1482         fnc->nc_mib_index = INDEX_MAC ;
1483         fnc->nc_index = mac_index(smc,1) ;
1484         fnc->nc_counter = smc->mib.m[MAC0].fddiMACNotCopied_Ct ;
1485 }
1486
1487
1488 /*
1489  * fill manufacturer field
1490  */
1491 static void smt_fill_manufacturer(struct s_smc *smc,
1492                                   struct smp_p_manufacturer *man)
1493 {
1494         SMTSETPARA(man,SMT_P_MANUFACTURER) ;
1495         memcpy((char *) man->mf_data,
1496                 (char *) smc->mib.fddiSMTManufacturerData,
1497                 sizeof(man->mf_data)) ;
1498 }
1499
1500 /*
1501  * fill user field
1502  */
1503 static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user)
1504 {
1505         SMTSETPARA(user,SMT_P_USER) ;
1506         memcpy((char *) user->us_data,
1507                 (char *) smc->mib.fddiSMTUserData,
1508                 sizeof(user->us_data)) ;
1509 }
1510
1511 /*
1512  * fill set count
1513  */
1514 static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount)
1515 {
1516         SK_UNUSED(smc) ;
1517         SMTSETPARA(setcount,SMT_P_SETCOUNT) ;
1518         setcount->count = smc->mib.fddiSMTSetCount.count ;
1519         memcpy((char *)setcount->timestamp,
1520                 (char *)smc->mib.fddiSMTSetCount.timestamp,8) ;
1521 }
1522
1523 /*
1524  * fill echo data
1525  */
1526 static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
1527                           int len)
1528 {
1529         u_char  *p ;
1530
1531         SK_UNUSED(smc) ;
1532         SMTSETPARA(echo,SMT_P_ECHODATA) ;
1533         echo->para.p_len = len ;
1534         for (p = echo->ec_data ; len ; len--) {
1535                 *p++ = (u_char) seed ;
1536                 seed += 13 ;
1537         }
1538 }
1539
1540 /*
1541  * clear DNA and UNA
1542  * called from CFM if configuration changes
1543  */
1544 static void smt_clear_una_dna(struct s_smc *smc)
1545 {
1546         smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
1547         smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
1548 }
1549
1550 static void smt_clear_old_una_dna(struct s_smc *smc)
1551 {
1552         smc->mib.m[MAC0].fddiMACOldUpstreamNbr = SMT_Unknown ;
1553         smc->mib.m[MAC0].fddiMACOldDownstreamNbr = SMT_Unknown ;
1554 }
1555
1556 u_long smt_get_tid(struct s_smc *smc)
1557 {
1558         u_long  tid ;
1559         while ((tid = ++(smc->sm.smt_tid) ^ SMT_TID_MAGIC) == 0)
1560                 ;
1561         return tid & 0x3fffffffL;
1562 }
1563
1564
1565 /*
1566  * table of parameter lengths
1567  */
1568 static const struct smt_pdef {
1569         int     ptype ;
1570         int     plen ;
1571         const char      *pswap ;
1572 } smt_pdef[] = {
1573         { SMT_P_UNA,    sizeof(struct smt_p_una) ,
1574                 SWAP_SMT_P_UNA                                  } ,
1575         { SMT_P_SDE,    sizeof(struct smt_p_sde) ,
1576                 SWAP_SMT_P_SDE                                  } ,
1577         { SMT_P_STATE,  sizeof(struct smt_p_state) ,
1578                 SWAP_SMT_P_STATE                                } ,
1579         { SMT_P_TIMESTAMP,sizeof(struct smt_p_timestamp) ,
1580                 SWAP_SMT_P_TIMESTAMP                            } ,
1581         { SMT_P_POLICY, sizeof(struct smt_p_policy) ,
1582                 SWAP_SMT_P_POLICY                               } ,
1583         { SMT_P_LATENCY,        sizeof(struct smt_p_latency) ,
1584                 SWAP_SMT_P_LATENCY                              } ,
1585         { SMT_P_NEIGHBORS,sizeof(struct smt_p_neighbor) ,
1586                 SWAP_SMT_P_NEIGHBORS                            } ,
1587         { SMT_P_PATH,   sizeof(struct smt_p_path) ,
1588                 SWAP_SMT_P_PATH                                 } ,
1589         { SMT_P_MAC_STATUS,sizeof(struct smt_p_mac_status) ,
1590                 SWAP_SMT_P_MAC_STATUS                           } ,
1591         { SMT_P_LEM,    sizeof(struct smt_p_lem) ,
1592                 SWAP_SMT_P_LEM                                  } ,
1593         { SMT_P_MAC_COUNTER,sizeof(struct smt_p_mac_counter) ,
1594                 SWAP_SMT_P_MAC_COUNTER                          } ,
1595         { SMT_P_MAC_FNC,sizeof(struct smt_p_mac_fnc) ,
1596                 SWAP_SMT_P_MAC_FNC                              } ,
1597         { SMT_P_PRIORITY,sizeof(struct smt_p_priority) ,
1598                 SWAP_SMT_P_PRIORITY                             } ,
1599         { SMT_P_EB,sizeof(struct smt_p_eb) ,
1600                 SWAP_SMT_P_EB                                   } ,
1601         { SMT_P_MANUFACTURER,sizeof(struct smp_p_manufacturer) ,
1602                 SWAP_SMT_P_MANUFACTURER                         } ,
1603         { SMT_P_REASON, sizeof(struct smt_p_reason) ,
1604                 SWAP_SMT_P_REASON                               } ,
1605         { SMT_P_REFUSED, sizeof(struct smt_p_refused) ,
1606                 SWAP_SMT_P_REFUSED                              } ,
1607         { SMT_P_VERSION, sizeof(struct smt_p_version) ,
1608                 SWAP_SMT_P_VERSION                              } ,
1609 #ifdef ESS
1610         { SMT_P0015, sizeof(struct smt_p_0015) , SWAP_SMT_P0015 } ,
1611         { SMT_P0016, sizeof(struct smt_p_0016) , SWAP_SMT_P0016 } ,
1612         { SMT_P0017, sizeof(struct smt_p_0017) , SWAP_SMT_P0017 } ,
1613         { SMT_P0018, sizeof(struct smt_p_0018) , SWAP_SMT_P0018 } ,
1614         { SMT_P0019, sizeof(struct smt_p_0019) , SWAP_SMT_P0019 } ,
1615         { SMT_P001A, sizeof(struct smt_p_001a) , SWAP_SMT_P001A } ,
1616         { SMT_P001B, sizeof(struct smt_p_001b) , SWAP_SMT_P001B } ,
1617         { SMT_P001C, sizeof(struct smt_p_001c) , SWAP_SMT_P001C } ,
1618         { SMT_P001D, sizeof(struct smt_p_001d) , SWAP_SMT_P001D } ,
1619 #endif
1620 #if     0
1621         { SMT_P_FSC,    sizeof(struct smt_p_fsc) ,
1622                 SWAP_SMT_P_FSC                                  } ,
1623 #endif
1624
1625         { SMT_P_SETCOUNT,0,     SWAP_SMT_P_SETCOUNT             } ,
1626         { SMT_P1048,    0,      SWAP_SMT_P1048                  } ,
1627         { SMT_P208C,    0,      SWAP_SMT_P208C                  } ,
1628         { SMT_P208D,    0,      SWAP_SMT_P208D                  } ,
1629         { SMT_P208E,    0,      SWAP_SMT_P208E                  } ,
1630         { SMT_P208F,    0,      SWAP_SMT_P208F                  } ,
1631         { SMT_P2090,    0,      SWAP_SMT_P2090                  } ,
1632 #ifdef  ESS
1633         { SMT_P320B, sizeof(struct smt_p_320b) , SWAP_SMT_P320B } ,
1634         { SMT_P320F, sizeof(struct smt_p_320f) , SWAP_SMT_P320F } ,
1635         { SMT_P3210, sizeof(struct smt_p_3210) , SWAP_SMT_P3210 } ,
1636 #endif
1637         { SMT_P4050,    0,      SWAP_SMT_P4050                  } ,
1638         { SMT_P4051,    0,      SWAP_SMT_P4051                  } ,
1639         { SMT_P4052,    0,      SWAP_SMT_P4052                  } ,
1640         { SMT_P4053,    0,      SWAP_SMT_P4053                  } ,
1641 } ;
1642
1643 #define N_SMT_PLEN      ARRAY_SIZE(smt_pdef)
1644
1645 int smt_check_para(struct s_smc *smc, struct smt_header *sm,
1646                    const u_short list[])
1647 {
1648         const u_short           *p = list ;
1649         while (*p) {
1650                 if (!sm_to_para(smc,sm,(int) *p)) {
1651                         DB_SMT("SMT: smt_check_para - missing para %hx", *p);
1652                         return -1;
1653                 }
1654                 p++ ;
1655         }
1656         return 0;
1657 }
1658
1659 void *sm_to_para(struct s_smc *smc, struct smt_header *sm, int para)
1660 {
1661         char    *p ;
1662         int     len ;
1663         int     plen ;
1664         void    *found = NULL;
1665
1666         SK_UNUSED(smc) ;
1667
1668         len = sm->smt_len ;
1669         p = (char *)(sm+1) ;            /* pointer to info */
1670         while (len > 0 ) {
1671                 if (((struct smt_para *)p)->p_type == para)
1672                         found = (void *) p ;
1673                 plen = ((struct smt_para *)p)->p_len + PARA_LEN ;
1674                 p += plen ;
1675                 len -= plen ;
1676                 if (len < 0) {
1677                         DB_SMT("SMT : sm_to_para - length error %d", plen);
1678                         return NULL;
1679                 }
1680                 if ((plen & 3) && (para != SMT_P_ECHODATA)) {
1681                         DB_SMT("SMT : sm_to_para - odd length %d", plen);
1682                         return NULL;
1683                 }
1684                 if (found)
1685                         return found;
1686         }
1687         return NULL;
1688 }
1689
1690 #if     0
1691 /*
1692  * send ANTC data test frame
1693  */
1694 void fddi_send_antc(struct s_smc *smc, struct fddi_addr *dest)
1695 {
1696         SK_UNUSED(smc) ;
1697         SK_UNUSED(dest) ;
1698 #if     0
1699         SMbuf                   *mb ;
1700         struct smt_header       *smt ;
1701         int                     i ;
1702         char                    *p ;
1703
1704         mb = smt_get_mbuf() ;
1705         mb->sm_len = 3000+12 ;
1706         p = smtod(mb, char *) + 12 ;
1707         for (i = 0 ; i < 3000 ; i++)
1708                 *p++ = 1 << (i&7) ;
1709
1710         smt = smtod(mb, struct smt_header *) ;
1711         smt->smt_dest = *dest ;
1712         smt->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
1713         smt_send_mbuf(smc,mb,FC_ASYNC_LLC) ;
1714 #endif
1715 }
1716 #endif
1717
1718 #ifdef  DEBUG
1719 char *addr_to_string(struct fddi_addr *addr)
1720 {
1721         int     i ;
1722         static char     string[6*3] = "****" ;
1723
1724         for (i = 0 ; i < 6 ; i++) {
1725                 string[i * 3] = hex_asc_hi(addr->a[i]);
1726                 string[i * 3 + 1] = hex_asc_lo(addr->a[i]);
1727                 string[i * 3 + 2] = ':';
1728         }
1729         string[5 * 3 + 2] = 0;
1730         return string;
1731 }
1732 #endif
1733
1734 /*
1735  * return static mac index
1736  */
1737 static int mac_index(struct s_smc *smc, int mac)
1738 {
1739         SK_UNUSED(mac) ;
1740 #ifdef  CONCENTRATOR
1741         SK_UNUSED(smc) ;
1742         return NUMPHYS + 1;
1743 #else
1744         return (smc->s.sas == SMT_SAS) ? 2 : 3;
1745 #endif
1746 }
1747
1748 /*
1749  * return static phy index
1750  */
1751 static int phy_index(struct s_smc *smc, int phy)
1752 {
1753         SK_UNUSED(smc) ;
1754         return phy + 1;
1755 }
1756
1757 /*
1758  * return dynamic mac connection resource index
1759  */
1760 static int mac_con_resource_index(struct s_smc *smc, int mac)
1761 {
1762 #ifdef  CONCENTRATOR
1763         SK_UNUSED(smc) ;
1764         SK_UNUSED(mac) ;
1765         return entity_to_index(smc, cem_get_downstream(smc, ENTITY_MAC));
1766 #else
1767         SK_UNUSED(mac) ;
1768         switch (smc->mib.fddiSMTCF_State) {
1769         case SC9_C_WRAP_A :
1770         case SC5_THRU_B :
1771         case SC11_C_WRAP_S :
1772                 return 1;
1773         case SC10_C_WRAP_B :
1774         case SC4_THRU_A :
1775                 return 2;
1776         }
1777         return smc->s.sas == SMT_SAS ? 2 : 3;
1778 #endif
1779 }
1780
1781 /*
1782  * return dynamic phy connection resource index
1783  */
1784 static int phy_con_resource_index(struct s_smc *smc, int phy)
1785 {
1786 #ifdef  CONCENTRATOR
1787         return entity_to_index(smc, cem_get_downstream(smc, ENTITY_PHY(phy))) ;
1788 #else
1789         switch (smc->mib.fddiSMTCF_State) {
1790         case SC9_C_WRAP_A :
1791                 return phy == PA ? 3 : 2;
1792         case SC10_C_WRAP_B :
1793                 return phy == PA ? 1 : 3;
1794         case SC4_THRU_A :
1795                 return phy == PA ? 3 : 1;
1796         case SC5_THRU_B :
1797                 return phy == PA ? 2 : 3;
1798         case SC11_C_WRAP_S :
1799                 return 2;
1800         }
1801         return phy;
1802 #endif
1803 }
1804
1805 #ifdef  CONCENTRATOR
1806 static int entity_to_index(struct s_smc *smc, int e)
1807 {
1808         if (e == ENTITY_MAC)
1809                 return mac_index(smc, 1);
1810         else
1811                 return phy_index(smc, e - ENTITY_PHY(0));
1812 }
1813 #endif
1814
1815 #ifdef  LITTLE_ENDIAN
1816 static int smt_swap_short(u_short s)
1817 {
1818         return ((s>>8)&0xff) | ((s&0xff)<<8);
1819 }
1820
1821 void smt_swap_para(struct smt_header *sm, int len, int direction)
1822 /* int direction;       0 encode 1 decode */
1823 {
1824         struct smt_para *pa ;
1825         const  struct smt_pdef  *pd ;
1826         char    *p ;
1827         int     plen ;
1828         int     type ;
1829         int     i ;
1830
1831 /*      printf("smt_swap_para sm %x len %d dir %d\n",
1832                 sm,len,direction) ;
1833  */
1834         smt_string_swap((char *)sm,SWAP_SMTHEADER,len) ;
1835
1836         /* swap args */
1837         len -= sizeof(struct smt_header) ;
1838
1839         p = (char *) (sm + 1) ;
1840         while (len > 0) {
1841                 pa = (struct smt_para *) p ;
1842                 plen = pa->p_len ;
1843                 type = pa->p_type ;
1844                 pa->p_type = smt_swap_short(pa->p_type) ;
1845                 pa->p_len = smt_swap_short(pa->p_len) ;
1846                 if (direction) {
1847                         plen = pa->p_len ;
1848                         type = pa->p_type ;
1849                 }
1850                 /*
1851                  * note: paras can have 0 length !
1852                  */
1853                 if (plen < 0)
1854                         break ;
1855                 plen += PARA_LEN ;
1856                 for (i = N_SMT_PLEN, pd = smt_pdef; i ; i--,pd++) {
1857                         if (pd->ptype == type)
1858                                 break ;
1859                 }
1860                 if (i && pd->pswap) {
1861                         smt_string_swap(p+PARA_LEN,pd->pswap,len) ;
1862                 }
1863                 len -= plen ;
1864                 p += plen ;
1865         }
1866 }
1867
1868 static void smt_string_swap(char *data, const char *format, int len)
1869 {
1870         const char      *open_paren = NULL ;
1871         int     x ;
1872
1873         while (len > 0  && *format) {
1874                 switch (*format) {
1875                 case '[' :
1876                         open_paren = format ;
1877                         break ;
1878                 case ']' :
1879                         format = open_paren ;
1880                         break ;
1881                 case '1' :
1882                 case '2' :
1883                 case '3' :
1884                 case '4' :
1885                 case '5' :
1886                 case '6' :
1887                 case '7' :
1888                 case '8' :
1889                 case '9' :
1890                         data  += *format - '0' ;
1891                         len   -= *format - '0' ;
1892                         break ;
1893                 case 'c':
1894                         data++ ;
1895                         len-- ;
1896                         break ;
1897                 case 's' :
1898                         x = data[0] ;
1899                         data[0] = data[1] ;
1900                         data[1] = x ;
1901                         data += 2 ;
1902                         len -= 2 ;
1903                         break ;
1904                 case 'l' :
1905                         x = data[0] ;
1906                         data[0] = data[3] ;
1907                         data[3] = x ;
1908                         x = data[1] ;
1909                         data[1] = data[2] ;
1910                         data[2] = x ;
1911                         data += 4 ;
1912                         len -= 4 ;
1913                         break ;
1914                 }
1915                 format++ ;
1916         }
1917 }
1918 #else
1919 void smt_swap_para(struct smt_header *sm, int len, int direction)
1920 /* int direction;       0 encode 1 decode */
1921 {
1922         SK_UNUSED(sm) ;
1923         SK_UNUSED(len) ;
1924         SK_UNUSED(direction) ;
1925 }
1926 #endif
1927
1928 /*
1929  * PMF actions
1930  */
1931 int smt_action(struct s_smc *smc, int class, int code, int index)
1932 {
1933         int     event ;
1934         int     port ;
1935         DB_SMT("SMT: action %d code %d", class, code);
1936         switch(class) {
1937         case SMT_STATION_ACTION :
1938                 switch(code) {
1939                 case SMT_STATION_ACTION_CONNECT :
1940                         smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;
1941                         queue_event(smc,EVENT_ECM,EC_CONNECT) ;
1942                         break ;
1943                 case SMT_STATION_ACTION_DISCONNECT :
1944                         queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
1945                         smc->mib.fddiSMTRemoteDisconnectFlag = TRUE ;
1946                         RS_SET(smc,RS_DISCONNECT) ;
1947                         AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1948                                 FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_DISCONNECT,
1949                                 smt_get_event_word(smc));
1950                         break ;
1951                 case SMT_STATION_ACTION_PATHTEST :
1952                         AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1953                                 FDDI_SMT_EVENT, (u_long) FDDI_PATH_TEST,
1954                                 smt_get_event_word(smc));
1955                         break ;
1956                 case SMT_STATION_ACTION_SELFTEST :
1957                         AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1958                                 FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_SELF_TEST,
1959                                 smt_get_event_word(smc));
1960                         break ;
1961                 case SMT_STATION_ACTION_DISABLE_A :
1962                         if (smc->y[PA].pc_mode == PM_PEER) {
1963                                 RS_SET(smc,RS_EVENT) ;
1964                                 queue_event(smc,EVENT_PCM+PA,PC_DISABLE) ;
1965                         }
1966                         break ;
1967                 case SMT_STATION_ACTION_DISABLE_B :
1968                         if (smc->y[PB].pc_mode == PM_PEER) {
1969                                 RS_SET(smc,RS_EVENT) ;
1970                                 queue_event(smc,EVENT_PCM+PB,PC_DISABLE) ;
1971                         }
1972                         break ;
1973                 case SMT_STATION_ACTION_DISABLE_M :
1974                         for (port = 0 ; port <  NUMPHYS ; port++) {
1975                                 if (smc->mib.p[port].fddiPORTMy_Type != TM)
1976                                         continue ;
1977                                 RS_SET(smc,RS_EVENT) ;
1978                                 queue_event(smc,EVENT_PCM+port,PC_DISABLE) ;
1979                         }
1980                         break ;
1981                 default :
1982                         return 1;
1983                 }
1984                 break ;
1985         case SMT_PORT_ACTION :
1986                 switch(code) {
1987                 case SMT_PORT_ACTION_ENABLE :
1988                         event = PC_ENABLE ;
1989                         break ;
1990                 case SMT_PORT_ACTION_DISABLE :
1991                         event = PC_DISABLE ;
1992                         break ;
1993                 case SMT_PORT_ACTION_MAINT :
1994                         event = PC_MAINT ;
1995                         break ;
1996                 case SMT_PORT_ACTION_START :
1997                         event = PC_START ;
1998                         break ;
1999                 case SMT_PORT_ACTION_STOP :
2000                         event = PC_STOP ;
2001                         break ;
2002                 default :
2003                         return 1;
2004                 }
2005                 queue_event(smc,EVENT_PCM+index,event) ;
2006                 break ;
2007         default :
2008                 return 1;
2009         }
2010         return 0;
2011 }
2012
2013 /*
2014  * canonical conversion of <len> bytes beginning form *data
2015  */
2016 #ifdef  USE_CAN_ADDR
2017 static void hwm_conv_can(struct s_smc *smc, char *data, int len)
2018 {
2019         int i ;
2020
2021         SK_UNUSED(smc) ;
2022
2023         for (i = len; i ; i--, data++)
2024                 *data = bitrev8(*data);
2025 }
2026 #endif
2027
2028 #endif  /* no SLIM_SMT */
2029