drivers/net/skfp/smt.c

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