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 2030