开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
smt.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：52k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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.  ******************************************************************************/
  17. #include "h/types.h"
  18. #include "h/fddi.h"
  19. #include "h/smc.h"
  20. #include "h/smt_p.h"
  22. #define KERNEL
  23. #include "h/smtstate.h"
  25. #ifndef lint
  26. static const char ID_sccs[] = "@(#)smt.c 2.43 98/11/23 (C) SK " ;
  27. #endif
  29. extern const u_char canonical[256] ;
  31. /*
  32.  * FC in SMbuf
  33.  */
  34. #define m_fc(mb) ((mb)->sm_data[0])
  36. #define SMT_TID_MAGIC 0x1f0a7b3c
  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. } ;
  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)
  53. static const struct fddi_addr SMT_Unknown = {
  54. { 0,0,0x1f,0,0,0 }
  55. } ;
  57. /*
  58.  * external variables
  59.  */
  60. extern const struct fddi_addr fddi_broadcast ;
  62. /*
  63.  * external functions
  64.  */
  65. int pcm_status_twisted() ;
  66. void pcm_status_state() ;
  67. int pcm_status_type() ;
  69. extern SMbuf *smt_get_mbuf() ;
  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() ;
  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
  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 } ;
  136. /*
  137.  * init SMT agent
  138.  */
  139. void smt_agent_init(smc)
  140. struct s_smc *smc ;
  141. {
  142. int i ;
  144. /*
  145.  * get MAC address
  146.  */
  147. smc->mib.m[MAC0].fddiMACSMTAddress = smc->hw.fddi_home_addr ;
  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. }
  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 taskn",0,0) ;
  192. }
  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. }
  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;
  221. time = smt_get_time();
  222. count = ((time - smc->sm.last_tok_time[mac_index]) *
  223. 100)/TICKS_PER_SECOND;
  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. }
  235. /* Remember current time */
  236. smc->sm.last_tok_time[mac_index] = time;
  238. }
  239. #endif
  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
  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. }
  260. if (event == SM_FAST)
  261. return ;
  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
  281. smt_srf_event(smc,0,0,0) ;
  283. #endif /* no SLIM_SMT */
  285. time = smt_get_time() ;
  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 ;
  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) ;
  318. cond =
  319. ((!mib->fddiMACFrameErrorThreshold &&
  320. mib->fddiMACError_Ct != mib->fddiMACOld_Error_Ct) ||
  321. (mib->fddiMACFrameErrorRatio >
  322. mib->fddiMACFrameErrorThreshold)) ;
  324. if (cond != mib->fddiMACFrameErrorFlag)
  325. smt_srf_event(smc,SMT_COND_MAC_FRAME_ERROR,
  326. INDEX_MAC,cond) ;
  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) ;
  335. cond =
  336. ((!mib->fddiMACNotCopiedThreshold &&
  337. mib->fddiMACNotCopied_Ct !=
  338. mib->fddiMACOld_NotCopied_Ct)||
  339. (mib->fddiMACNotCopiedRatio >
  340. mib->fddiMACNotCopiedThreshold)) ;
  342. if (cond != mib->fddiMACNotCopiedFlag)
  343. smt_srf_event(smc,SMT_COND_MAC_NOT_COPIED,
  344. INDEX_MAC,cond) ;
  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 ;
  355. /*
  356.  * Check port EBError Condition
  357.  */
  358. for (port = 0; port < NUMPHYS; port ++) {
  359. phy = &smc->y[port] ;
  361. if (!phy->mib->fddiPORTHardwarePresent) {
  362. continue;
  363. }
  365. cond = (phy->mib->fddiPORTEBError_Ct -
  366. phy->mib->fddiPORTOldEBError_Ct > 5) ;
  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) ;
  374. /*
  375.  * set old values
  376.  */
  377. phy->mib->fddiPORTOldEBError_Ct =
  378. phy->mib->fddiPORTEBError_Ct ;
  379. }
  381. #endif /* no SLIM_SMT */
  382. }
  384. #ifndef SLIM_SMT
  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. }
  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 expiredn",0,0) ;
  407. smc->sm.smt_tvu = 0 ;
  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 seperate 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 expiredn",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. }
  442. #endif /* no SLIM_SMT */
  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
  456. smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
  457. EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
  458. }
  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. }
  473. #ifndef SLIM_SMT
  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 ;
  486. int illegal = 0 ;
  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. }
  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) ;
  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
  517. smt_swap_para(sm,(int) mb->sm_len,1) ;
  518. DB_SMT("SMT : received packet [%s] at 0x%xn",
  519. smt_type_name[m_fc(mb) & 0xf],sm) ;
  520. DB_SMT("SMT : version %d, class %sn",sm->smt_version,
  521. smt_class_name[(sm->smt_class>LAST_CLASS)?0 : sm->smt_class]) ;
  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
  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 %sn",
  539. addr_to_string(&sm->smt_source),0) ;
  540. smt_free_mbuf(smc,mb) ;
  541. return ;
  542. }
  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. }
  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 = %sn",
  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 = %dn",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, ignoringn",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 ;
  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 = %sn",
  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. }
  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 %sn",
  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 %sn",
  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 addressn",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 DNAn",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. }
  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 okn",0,0) ;
  686. }
  687. else {
  688. DB_SMT("SMT : expected TID %lx, got %lxn",
  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 %sn",
  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 %sn",
  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 %sn",
  716. addr_to_string(&sm->smt_source),0) ;
  717. if (sm_to_para(smc,sm,SMT_P_ECHODATA) == 0) {
  718. DB_SMT("SMT: ECHODATA missingn",0,0) ;
  719. break ;
  720. }
  721. if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF]) {
  722. DB_SMT("SMT : ECF test TID okn",0,0) ;
  723. }
  724. else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_UNA]) {
  725. DB_SMT("SMT : ECF test UNA okn",0,0) ;
  726. }
  727. else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_DNA]) {
  728. DB_SMT("SMT : ECF test DNA okn",0,0) ;
  729. }
  730. else {
  731. DB_SMT("SMT : expected TID %lx, got %lxn",
  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 RDFn",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 %sn",
  746. addr_to_string(&sm->smt_source),0) ;
  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 receivedn",0,0) ;
  765. fs = ess_raf_received_pack(smc,mb,sm,fs) ;
  766. #endif
  768. #ifdef SBA
  769. DB_SBAN(2,"SBA: RAF frame receivedn",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 RDFn",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 setn",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 %sn",
  813. sm->smt_class, addr_to_string(&sm->smt_source)) ;
  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 illegal frame, reason = %dn",
  821. illegal,0) ;
  822. }
  823. smt_free_mbuf(smc,mb) ;
  824. }
  826. static void update_dac(smc,report)
  827. struct s_smc *smc ;
  828. int report ;
  829. {
  830. int cond ;
  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. }
  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 ;
  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 ;
  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. }
  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 ;
  884. sm = smtod(rej,struct smt_header *) ;
  885. if (sm->smt_type != SMT_REQUEST)
  886. return ;
  888. DB_SMT("SMT: sending RDF to %s,reason = 0x%xn",
  889. addr_to_string(&sm->smt_source),reason) ;
  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 ;
  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 */
  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 ;
  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 ;
  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 ;
  932. /* swap it back */
  933. smt_swap_para(sm,frame_len,0) ;
  935. memcpy((char *) &rdf->refused.ref_header,(char *) sm,len) ;
  937. len -= sizeof(struct smt_header) ;
  938. mb->sm_len += len ;
  939. rdf->smt.smt_len += len ;
  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. }
  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 ;
  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. }
  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. }
  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
  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 ;
  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. }
  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 ;
  1033. if (!(mb = smt_build_frame(smc,SMT_ECF,type,SMT_ECF_LEN + len)))
  1034. return ;
  1035. ecf = smtod(mb, struct smt_ecf *) ;
  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. }
  1044. /*
  1045.  * generate and send SIF config response
  1046.  */
  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 ;
  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. }
  1078. /*
  1079.  * generate and send SIF operation response
  1080.  */
  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 ;
  1093. ports = NUMPHYS ;
  1094. #ifndef CONCENTRATOR
  1095. if (smc->s.sas == SMT_SAS)
  1096. ports = 1 ;
  1097. #endif
  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. }
  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. }
  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 ;
  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) ;
  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. }
  1170. static void smt_add_frame_len(mb,len)
  1171. SMbuf *mb ;
  1172. int len ;
  1173. {
  1174. struct smt_header *smt ;
  1176. smt = smtod(mb, struct smt_header *) ;
  1177. smt->smt_len += len ;
  1178. mb->sm_len += len ;
  1179. }
  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. }
  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. }
  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 ;
  1223. SMTSETPARA(state,SMT_P_STATE) ;
  1224. state->st_pad = 0 ;
  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. }
  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. {
  1263. SMTSETPARA(ts,SMT_P_TIMESTAMP) ;
  1264. smt_set_timestamp(smc,ts->ts_time) ;
  1265. }
  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 ;
  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. }
  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 ;
  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) ;
  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. }
  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) ;
  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. }
  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) ;
  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. }
  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
  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 ;
  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 ;
  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. }
  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. }
  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) ;
  1438. st->st_mib_index = INDEX_MAC ;
  1439. st->st_mac_index = mac_index(smc,1) ;
  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 ;
  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. }
  1458. /*
  1459.  * fill values in LEM status
  1460.  */
  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 ;
  1469. mib = smc->y[phy].mib ;
  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. }
  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. }
  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
  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. }
  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. }
  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. }
  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. }
  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. }
  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. {
  1607. u_char *p ;
  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. }
  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. }
  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. }
  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. }
  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
  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. } ;
  1724. #define N_SMT_PLEN (sizeof(smt_pdef)/sizeof(smt_pdef[0]))
  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 %xn",*p,0);
  1735. return(-1) ;
  1736. }
  1737. p++ ;
  1738. }
  1739. return(0) ;
  1740. }
  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 ;
  1752. SK_UNUSED(smc) ;
  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 %dn",plen,0) ;
  1764. return(0) ;
  1765. }
  1766. if ((plen & 3) && (para != SMT_P_ECHODATA)) {
  1767. DB_SMT("SMT : sm_to_para - odd length %dn",plen,0) ;
  1768. return(0) ;
  1769. }
  1770. if (found)
  1771. return(found) ;
  1772. }
  1773. return(0) ;
  1774. }
  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. }
  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. }
  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. }
  1804. int is_individual(addr)
  1805. struct fddi_addr *addr ;
  1806. {
  1807. return(!(addr->a[0] & GROUP_ADDR)) ;
  1808. }
  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. }
  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 ;
  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) ;
  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
  1850. #ifdef DEBUG
  1851. #define hextoasc(x) "0123456789abcdef"[x]
  1853. char *addr_to_string(addr)
  1854. struct fddi_addr *addr ;
  1855. {
  1856. int i ;
  1857. static char string[6*3] = "****" ;
  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
  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
  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. }
  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. }
  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. }
  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. }
  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
  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. }
  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 ;
  1993. /* printf("smt_swap_para sm %x len %d dir %dn",
  1994. sm,len,direction) ;
  1995.  */
  1996. smt_string_swap((char *)sm,SWAP_SMTHEADER,len) ;
  1998. /* swap args */
  1999. len -= sizeof(struct smt_header) ;
  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. }
  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 ;
  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
  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 %dn",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. }
  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 ;
  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. }
  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 ;
  2217. SK_UNUSED(smc) ;
  2219. for (i = len; i ; i--, data++) {
  2220. *data = canonical[*(u_char *)data] ;
  2221. }
  2222. }
  2223. #endif
  2225. #endif /* no SLIM_SMT */