1/****************************************************************************** 2 * 3 * (C)Copyright 1998,1999 SysKonnect, 4 * a business unit of Schneider & Koch & Co. Datensysteme GmbH. 5 * 6 * See the file "skfddi.c" for further information. 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * The information in this file is provided "AS IS" without warranty. 14 * 15 ******************************************************************************/ 16 17/* 18 * ******************************************************************* 19 * This SBA code implements the Synchronous Bandwidth Allocation 20 * functions described in the "FDDI Synchronous Forum Implementer's 21 * Agreement" dated December 1th, 1993. 22 * ******************************************************************* 23 * 24 * PURPOSE: The purpose of this function is to control 25 * synchronous allocations on a single FDDI segment. 26 * Allocations are limited to the primary FDDI ring. 27 * The SBM provides recovery mechanisms to recover 28 * unused bandwidth also resolves T_Neg and 29 * reconfiguration changes. Many of the SBM state 30 * machine inputs are sourced by the underlying 31 * FDDI sub-system supporting the SBA application. 32 * 33 * ******************************************************************* 34 */ 35 36#include "h/types.h" 37#include "h/fddi.h" 38#include "h/smc.h" 39#include "h/smt_p.h" 40 41 42#ifndef SLIM_SMT 43 44#ifdef ESS 45 46#ifndef lint 47static const char ID_sccs[] = "@(#)ess.c 1.10 96/02/23 (C) SK" ; 48#define LINT_USE(x) 49#else 50#define LINT_USE(x) (x)=(x) 51#endif 52#define MS2BCLK(x) ((x)*12500L) 53 54/* 55 ------------------------------------------------------------- 56 LOCAL VARIABLES: 57 ------------------------------------------------------------- 58*/ 59 60static const u_short plist_raf_alc_res[] = { SMT_P0012, SMT_P320B, SMT_P320F, 61 SMT_P3210, SMT_P0019, SMT_P001A, 62 SMT_P001D, 0 } ; 63 64static const u_short plist_raf_chg_req[] = { SMT_P320B, SMT_P320F, SMT_P3210, 65 SMT_P001A, 0 } ; 66 67static const struct fddi_addr smt_sba_da = {{0x80,0x01,0x43,0x00,0x80,0x0C}} ; 68static const struct fddi_addr null_addr = {{0,0,0,0,0,0}} ; 69 70/* 71 ------------------------------------------------------------- 72 GLOBAL VARIABLES: 73 ------------------------------------------------------------- 74*/ 75 76 77/* 78 ------------------------------------------------------------- 79 LOCAL FUNCTIONS: 80 ------------------------------------------------------------- 81*/ 82 83static void ess_send_response(struct s_smc *smc, struct smt_header *sm, 84 int sba_cmd); 85static void ess_config_fifo(struct s_smc *smc); 86static void ess_send_alc_req(struct s_smc *smc); 87static void ess_send_frame(struct s_smc *smc, SMbuf *mb); 88 89/* 90 ------------------------------------------------------------- 91 EXTERNAL FUNCTIONS: 92 ------------------------------------------------------------- 93*/ 94 95/* 96 ------------------------------------------------------------- 97 PUBLIC FUNCTIONS: 98 ------------------------------------------------------------- 99*/ 100 101void ess_timer_poll(struct s_smc *smc); 102void ess_para_change(struct s_smc *smc); 103int ess_raf_received_pack(struct s_smc *smc, SMbuf *mb, struct smt_header *sm, 104 int fs); 105static int process_bw_alloc(struct s_smc *smc, long int payload, long int overhead); 106 107 108/* 109 * -------------------------------------------------------------------------- 110 * End Station Support (ESS) 111 * -------------------------------------------------------------------------- 112 */ 113 114/* 115 * evaluate the RAF frame 116 */ 117int ess_raf_received_pack(struct s_smc *smc, SMbuf *mb, struct smt_header *sm, 118 int fs) 119{ 120 void *p ; /* universal pointer */ 121 struct smt_p_0016 *cmd ; /* para: command for the ESS */ 122 SMbuf *db ; 123 u_long msg_res_type ; /* recource type */ 124 u_long payload, overhead ; 125 int local ; 126 int i ; 127 128 /* 129 * Message Processing Code 130 */ 131 local = ((fs & L_INDICATOR) != 0) ; 132 133 /* 134 * get the resource type 135 */ 136 if (!(p = (void *) sm_to_para(smc,sm,SMT_P0015))) { 137 DB_ESS("ESS: RAF frame error, parameter type not found\n",0,0) ; 138 return(fs) ; 139 } 140 msg_res_type = ((struct smt_p_0015 *)p)->res_type ; 141 142 /* 143 * get the pointer to the ESS command 144 */ 145 if (!(cmd = (struct smt_p_0016 *) sm_to_para(smc,sm,SMT_P0016))) { 146 /* 147 * error in frame: para ESS command was not found 148 */ 149 DB_ESS("ESS: RAF frame error, parameter command not found\n",0,0); 150 return(fs) ; 151 } 152 153 DB_ESSN(2,"fc %x ft %x\n",sm->smt_class,sm->smt_type) ; 154 DB_ESSN(2,"ver %x tran %lx\n",sm->smt_version,sm->smt_tid) ; 155 DB_ESSN(2,"stn_id %s\n",addr_to_string(&sm->smt_source),0) ; 156 157 DB_ESSN(2,"infolen %x res %x\n",sm->smt_len, msg_res_type) ; 158 DB_ESSN(2,"sbacmd %x\n",cmd->sba_cmd,0) ; 159 160 /* 161 * evaluate the ESS command 162 */ 163 switch (cmd->sba_cmd) { 164 165 /* 166 * Process an ESS Allocation Request 167 */ 168 case REQUEST_ALLOCATION : 169 /* 170 * check for an RAF Request (Allocation Request) 171 */ 172 if (sm->smt_type == SMT_REQUEST) { 173 /* 174 * process the Allocation request only if the frame is 175 * local and no static allocation is used 176 */ 177 if (!local || smc->mib.fddiESSPayload) 178 return(fs) ; 179 180 p = (void *) sm_to_para(smc,sm,SMT_P0019) ; 181 for (i = 0; i < 5; i++) { 182 if (((struct smt_p_0019 *)p)->alloc_addr.a[i]) { 183 return(fs) ; 184 } 185 } 186 187 /* 188 * Note: The Application should send a LAN_LOC_FRAME. 189 * The ESS do not send the Frame to the network! 190 */ 191 smc->ess.alloc_trans_id = sm->smt_tid ; 192 DB_ESS("ESS: save Alloc Req Trans ID %lx\n",sm->smt_tid,0); 193 p = (void *) sm_to_para(smc,sm,SMT_P320F) ; 194 ((struct smt_p_320f *)p)->mib_payload = 195 smc->mib.a[PATH0].fddiPATHSbaPayload ; 196 p = (void *) sm_to_para(smc,sm,SMT_P3210) ; 197 ((struct smt_p_3210 *)p)->mib_overhead = 198 smc->mib.a[PATH0].fddiPATHSbaOverhead ; 199 sm->smt_dest = smt_sba_da ; 200 201 if (smc->ess.local_sba_active) 202 return(fs | I_INDICATOR) ; 203 204 if (!(db = smt_get_mbuf(smc))) 205 return(fs) ; 206 207 db->sm_len = mb->sm_len ; 208 db->sm_off = mb->sm_off ; 209 memcpy(((char *)(db->sm_data+db->sm_off)),(char *)sm, 210 (int)db->sm_len) ; 211 dump_smt(smc, 212 (struct smt_header *)(db->sm_data+db->sm_off), 213 "RAF") ; 214 smt_send_frame(smc,db,FC_SMT_INFO,0) ; 215 return(fs) ; 216 } 217 218 /* 219 * The RAF frame is an Allocation Response ! 220 * check the parameters 221 */ 222 if (smt_check_para(smc,sm,plist_raf_alc_res)) { 223 DB_ESS("ESS: RAF with para problem, ignoring\n",0,0) ; 224 return(fs) ; 225 } 226 227 /* 228 * VERIFY THE FRAME IS WELL BUILT: 229 * 230 * 1. path index = primary ring only 231 * 2. resource type = sync bw only 232 * 3. trans action id = alloc_trans_id 233 * 4. reason code = success 234 * 235 * If any are violated, discard the RAF frame 236 */ 237 if ((((struct smt_p_320b *)sm_to_para(smc,sm,SMT_P320B))->path_index 238 != PRIMARY_RING) || 239 (msg_res_type != SYNC_BW) || 240 (((struct smt_p_reason *)sm_to_para(smc,sm,SMT_P0012))->rdf_reason 241 != SMT_RDF_SUCCESS) || 242 (sm->smt_tid != smc->ess.alloc_trans_id)) { 243 244 DB_ESS("ESS: Allocation Responce not accepted\n",0,0) ; 245 return(fs) ; 246 } 247 248 /* 249 * Extract message parameters 250 */ 251 p = (void *) sm_to_para(smc,sm,SMT_P320F) ; 252 if (!p) { 253 printk(KERN_ERR "ESS: sm_to_para failed"); 254 return fs; 255 } 256 payload = ((struct smt_p_320f *)p)->mib_payload ; 257 p = (void *) sm_to_para(smc,sm,SMT_P3210) ; 258 if (!p) { 259 printk(KERN_ERR "ESS: sm_to_para failed"); 260 return fs; 261 } 262 overhead = ((struct smt_p_3210 *)p)->mib_overhead ; 263 264 DB_ESSN(2,"payload= %lx overhead= %lx\n",payload,overhead) ; 265 266 /* 267 * process the bandwidth allocation 268 */ 269 (void)process_bw_alloc(smc,(long)payload,(long)overhead) ; 270 271 return(fs) ; 272 /* end of Process Allocation Request */ 273 274 /* 275 * Process an ESS Change Request 276 */ 277 case CHANGE_ALLOCATION : 278 /* 279 * except only replies 280 */ 281 if (sm->smt_type != SMT_REQUEST) { 282 DB_ESS("ESS: Do not process Change Responses\n",0,0) ; 283 return(fs) ; 284 } 285 286 /* 287 * check the para for the Change Request 288 */ 289 if (smt_check_para(smc,sm,plist_raf_chg_req)) { 290 DB_ESS("ESS: RAF with para problem, ignoring\n",0,0) ; 291 return(fs) ; 292 } 293 294 /* 295 * Verify the path index and resource 296 * type are correct. If any of 297 * these are false, don't process this 298 * change request frame. 299 */ 300 if ((((struct smt_p_320b *)sm_to_para(smc,sm,SMT_P320B))->path_index 301 != PRIMARY_RING) || (msg_res_type != SYNC_BW)) { 302 DB_ESS("ESS: RAF frame with para problem, ignoring\n",0,0) ; 303 return(fs) ; 304 } 305 306 /* 307 * Extract message queue parameters 308 */ 309 p = (void *) sm_to_para(smc,sm,SMT_P320F) ; 310 payload = ((struct smt_p_320f *)p)->mib_payload ; 311 p = (void *) sm_to_para(smc,sm,SMT_P3210) ; 312 overhead = ((struct smt_p_3210 *)p)->mib_overhead ; 313 314 DB_ESSN(2,"ESS: Change Request from %s\n", 315 addr_to_string(&sm->smt_source),0) ; 316 DB_ESSN(2,"payload= %lx overhead= %lx\n",payload,overhead) ; 317 318 /* 319 * process the bandwidth allocation 320 */ 321 if(!process_bw_alloc(smc,(long)payload,(long)overhead)) 322 return(fs) ; 323 324 /* 325 * send an RAF Change Reply 326 */ 327 ess_send_response(smc,sm,CHANGE_ALLOCATION) ; 328 329 return(fs) ; 330 /* end of Process Change Request */ 331 332 /* 333 * Process Report Response 334 */ 335 case REPORT_ALLOCATION : 336 /* 337 * except only requests 338 */ 339 if (sm->smt_type != SMT_REQUEST) { 340 DB_ESS("ESS: Do not process a Report Reply\n",0,0) ; 341 return(fs) ; 342 } 343 344 DB_ESSN(2,"ESS: Report Request from %s\n", 345 addr_to_string(&(sm->smt_source)),0) ; 346 347 /* 348 * verify that the resource type is sync bw only 349 */ 350 if (msg_res_type != SYNC_BW) { 351 DB_ESS("ESS: ignoring RAF with para problem\n",0,0) ; 352 return(fs) ; 353 } 354 355 /* 356 * send an RAF Change Reply 357 */ 358 ess_send_response(smc,sm,REPORT_ALLOCATION) ; 359 360 return(fs) ; 361 /* end of Process Report Request */ 362 363 default: 364 /* 365 * error in frame 366 */ 367 DB_ESS("ESS: ignoring RAF with bad sba_cmd\n",0,0) ; 368 break ; 369 } 370 371 return(fs) ; 372} 373 374/* 375 * determines the synchronous bandwidth, set the TSYNC register and the 376 * mib variables SBAPayload, SBAOverhead and fddiMACT-NEG. 377 */ 378static int process_bw_alloc(struct s_smc *smc, long int payload, long int overhead) 379{ 380 /* 381 * determine the synchronous bandwidth (sync_bw) in bytes per T-NEG, 382 * if the payload is greater than zero. 383 * For the SBAPayload and the SBAOverhead we have the following 384 * unite quations 385 * _ _ 386 * | bytes | 387 * SBAPayload = | 8000 ------ | 388 * | s | 389 * - - 390 * _ _ 391 * | bytes | 392 * SBAOverhead = | ------ | 393 * | T-NEG | 394 * - - 395 * 396 * T-NEG is discribed by the equation: 397 * 398 * (-) fddiMACT-NEG 399 * T-NEG = ------------------- 400 * 12500000 1/s 401 * 402 * The number of bytes we are able to send is the payload 403 * plus the overhead. 404 * 405 * bytes T-NEG SBAPayload 8000 bytes/s 406 * sync_bw = SBAOverhead ------ + ----------------------------- 407 * T-NEG T-NEG 408 * 409 * 410 * 1 411 * sync_bw = SBAOverhead + ---- (-)fddiMACT-NEG * SBAPayload 412 * 1562 413 * 414 */ 415 416 /* 417 * set the mib attributes fddiPATHSbaOverhead, fddiPATHSbaPayload 418 */ 419/* if (smt_set_obj(smc,SMT_P320F,payload,S_SET)) { 420 DB_ESS("ESS: SMT does not accept the payload value\n",0,0) ; 421 return(FALSE) ; 422 } 423 if (smt_set_obj(smc,SMT_P3210,overhead,S_SET)) { 424 DB_ESS("ESS: SMT does not accept the overhead value\n",0,0) ; 425 return(FALSE) ; 426 } */ 427 428 /* premliminary */ 429 if (payload > MAX_PAYLOAD || overhead > 5000) { 430 DB_ESS("ESS: payload / overhead not accepted\n",0,0) ; 431 return(FALSE) ; 432 } 433 434 /* 435 * start the iterative allocation process if the payload or the overhead 436 * are smaller than the parsed values 437 */ 438 if (smc->mib.fddiESSPayload && 439 ((u_long)payload != smc->mib.fddiESSPayload || 440 (u_long)overhead != smc->mib.fddiESSOverhead)) { 441 smc->ess.raf_act_timer_poll = TRUE ; 442 smc->ess.timer_count = 0 ; 443 } 444 445 /* 446 * evulate the Payload 447 */ 448 if (payload) { 449 DB_ESSN(2,"ESS: turn SMT_ST_SYNC_SERVICE bit on\n",0,0) ; 450 smc->ess.sync_bw_available = TRUE ; 451 452 smc->ess.sync_bw = overhead - 453 (long)smc->mib.m[MAC0].fddiMACT_Neg * 454 payload / 1562 ; 455 } 456 else { 457 DB_ESSN(2,"ESS: turn SMT_ST_SYNC_SERVICE bit off\n",0,0) ; 458 smc->ess.sync_bw_available = FALSE ; 459 smc->ess.sync_bw = 0 ; 460 overhead = 0 ; 461 } 462 463 smc->mib.a[PATH0].fddiPATHSbaPayload = payload ; 464 smc->mib.a[PATH0].fddiPATHSbaOverhead = overhead ; 465 466 467 DB_ESSN(2,"tsync = %lx\n",smc->ess.sync_bw,0) ; 468 469 ess_config_fifo(smc) ; 470 set_formac_tsync(smc,smc->ess.sync_bw) ; 471 return(TRUE) ; 472} 473 474static void ess_send_response(struct s_smc *smc, struct smt_header *sm, 475 int sba_cmd) 476{ 477 struct smt_sba_chg *chg ; 478 SMbuf *mb ; 479 void *p ; 480 481 /* 482 * get and initialize the responce frame 483 */ 484 if (sba_cmd == CHANGE_ALLOCATION) { 485 if (!(mb=smt_build_frame(smc,SMT_RAF,SMT_REPLY, 486 sizeof(struct smt_sba_chg)))) 487 return ; 488 } 489 else { 490 if (!(mb=smt_build_frame(smc,SMT_RAF,SMT_REPLY, 491 sizeof(struct smt_sba_rep_res)))) 492 return ; 493 } 494 495 chg = smtod(mb,struct smt_sba_chg *) ; 496 chg->smt.smt_tid = sm->smt_tid ; 497 chg->smt.smt_dest = sm->smt_source ; 498 499 /* set P15 */ 500 chg->s_type.para.p_type = SMT_P0015 ; 501 chg->s_type.para.p_len = sizeof(struct smt_p_0015) - PARA_LEN ; 502 chg->s_type.res_type = SYNC_BW ; 503 504 /* set P16 */ 505 chg->cmd.para.p_type = SMT_P0016 ; 506 chg->cmd.para.p_len = sizeof(struct smt_p_0016) - PARA_LEN ; 507 chg->cmd.sba_cmd = sba_cmd ; 508 509 /* set P320B */ 510 chg->path.para.p_type = SMT_P320B ; 511 chg->path.para.p_len = sizeof(struct smt_p_320b) - PARA_LEN ; 512 chg->path.mib_index = SBAPATHINDEX ; 513 chg->path.path_pad = 0; 514 chg->path.path_index = PRIMARY_RING ; 515 516 /* set P320F */ 517 chg->payload.para.p_type = SMT_P320F ; 518 chg->payload.para.p_len = sizeof(struct smt_p_320f) - PARA_LEN ; 519 chg->payload.mib_index = SBAPATHINDEX ; 520 chg->payload.mib_payload = smc->mib.a[PATH0].fddiPATHSbaPayload ; 521 522 /* set P3210 */ 523 chg->overhead.para.p_type = SMT_P3210 ; 524 chg->overhead.para.p_len = sizeof(struct smt_p_3210) - PARA_LEN ; 525 chg->overhead.mib_index = SBAPATHINDEX ; 526 chg->overhead.mib_overhead = smc->mib.a[PATH0].fddiPATHSbaOverhead ; 527 528 if (sba_cmd == CHANGE_ALLOCATION) { 529 /* set P1A */ 530 chg->cat.para.p_type = SMT_P001A ; 531 chg->cat.para.p_len = sizeof(struct smt_p_001a) - PARA_LEN ; 532 p = (void *) sm_to_para(smc,sm,SMT_P001A) ; 533 chg->cat.category = ((struct smt_p_001a *)p)->category ; 534 } 535 dump_smt(smc,(struct smt_header *)chg,"RAF") ; 536 ess_send_frame(smc,mb) ; 537} 538 539void ess_timer_poll(struct s_smc *smc) 540{ 541 if (!smc->ess.raf_act_timer_poll) 542 return ; 543 544 DB_ESSN(2,"ESS: timer_poll\n",0,0) ; 545 546 smc->ess.timer_count++ ; 547 if (smc->ess.timer_count == 10) { 548 smc->ess.timer_count = 0 ; 549 ess_send_alc_req(smc) ; 550 } 551} 552 553static void ess_send_alc_req(struct s_smc *smc) 554{ 555 struct smt_sba_alc_req *req ; 556 SMbuf *mb ; 557 558 /* 559 * send never allocation request where the requested payload and 560 * overhead is zero or deallocate bandwidth when no bandwidth is 561 * parsed 562 */ 563 if (!smc->mib.fddiESSPayload) { 564 smc->mib.fddiESSOverhead = 0 ; 565 } 566 else { 567 if (!smc->mib.fddiESSOverhead) 568 smc->mib.fddiESSOverhead = DEFAULT_OV ; 569 } 570 571 if (smc->mib.fddiESSOverhead == 572 smc->mib.a[PATH0].fddiPATHSbaOverhead && 573 smc->mib.fddiESSPayload == 574 smc->mib.a[PATH0].fddiPATHSbaPayload){ 575 smc->ess.raf_act_timer_poll = FALSE ; 576 smc->ess.timer_count = 7 ; /* next RAF alc req after 3 s */ 577 return ; 578 } 579 580 /* 581 * get and initialize the responce frame 582 */ 583 if (!(mb=smt_build_frame(smc,SMT_RAF,SMT_REQUEST, 584 sizeof(struct smt_sba_alc_req)))) 585 return ; 586 req = smtod(mb,struct smt_sba_alc_req *) ; 587 req->smt.smt_tid = smc->ess.alloc_trans_id = smt_get_tid(smc) ; 588 req->smt.smt_dest = smt_sba_da ; 589 590 /* set P15 */ 591 req->s_type.para.p_type = SMT_P0015 ; 592 req->s_type.para.p_len = sizeof(struct smt_p_0015) - PARA_LEN ; 593 req->s_type.res_type = SYNC_BW ; 594 595 /* set P16 */ 596 req->cmd.para.p_type = SMT_P0016 ; 597 req->cmd.para.p_len = sizeof(struct smt_p_0016) - PARA_LEN ; 598 req->cmd.sba_cmd = REQUEST_ALLOCATION ; 599 600 /* 601 * set the parameter type and parameter length of all used 602 * parameters 603 */ 604 605 /* set P320B */ 606 req->path.para.p_type = SMT_P320B ; 607 req->path.para.p_len = sizeof(struct smt_p_320b) - PARA_LEN ; 608 req->path.mib_index = SBAPATHINDEX ; 609 req->path.path_pad = 0; 610 req->path.path_index = PRIMARY_RING ; 611 612 /* set P0017 */ 613 req->pl_req.para.p_type = SMT_P0017 ; 614 req->pl_req.para.p_len = sizeof(struct smt_p_0017) - PARA_LEN ; 615 req->pl_req.sba_pl_req = smc->mib.fddiESSPayload - 616 smc->mib.a[PATH0].fddiPATHSbaPayload ; 617 618 /* set P0018 */ 619 req->ov_req.para.p_type = SMT_P0018 ; 620 req->ov_req.para.p_len = sizeof(struct smt_p_0018) - PARA_LEN ; 621 req->ov_req.sba_ov_req = smc->mib.fddiESSOverhead - 622 smc->mib.a[PATH0].fddiPATHSbaOverhead ; 623 624 /* set P320F */ 625 req->payload.para.p_type = SMT_P320F ; 626 req->payload.para.p_len = sizeof(struct smt_p_320f) - PARA_LEN ; 627 req->payload.mib_index = SBAPATHINDEX ; 628 req->payload.mib_payload = smc->mib.a[PATH0].fddiPATHSbaPayload ; 629 630 /* set P3210 */ 631 req->overhead.para.p_type = SMT_P3210 ; 632 req->overhead.para.p_len = sizeof(struct smt_p_3210) - PARA_LEN ; 633 req->overhead.mib_index = SBAPATHINDEX ; 634 req->overhead.mib_overhead = smc->mib.a[PATH0].fddiPATHSbaOverhead ; 635 636 /* set P19 */ 637 req->a_addr.para.p_type = SMT_P0019 ; 638 req->a_addr.para.p_len = sizeof(struct smt_p_0019) - PARA_LEN ; 639 req->a_addr.sba_pad = 0; 640 req->a_addr.alloc_addr = null_addr ; 641 642 /* set P1A */ 643 req->cat.para.p_type = SMT_P001A ; 644 req->cat.para.p_len = sizeof(struct smt_p_001a) - PARA_LEN ; 645 req->cat.category = smc->mib.fddiESSCategory ; 646 647 /* set P1B */ 648 req->tneg.para.p_type = SMT_P001B ; 649 req->tneg.para.p_len = sizeof(struct smt_p_001b) - PARA_LEN ; 650 req->tneg.max_t_neg = smc->mib.fddiESSMaxTNeg ; 651 652 /* set P1C */ 653 req->segm.para.p_type = SMT_P001C ; 654 req->segm.para.p_len = sizeof(struct smt_p_001c) - PARA_LEN ; 655 req->segm.min_seg_siz = smc->mib.fddiESSMinSegmentSize ; 656 657 dump_smt(smc,(struct smt_header *)req,"RAF") ; 658 ess_send_frame(smc,mb) ; 659} 660 661static void ess_send_frame(struct s_smc *smc, SMbuf *mb) 662{ 663 /* 664 * check if the frame must be send to the own ESS 665 */ 666 if (smc->ess.local_sba_active) { 667 /* 668 * Send the Change Reply to the local SBA 669 */ 670 DB_ESS("ESS:Send to the local SBA\n",0,0) ; 671 if (!smc->ess.sba_reply_pend) 672 smc->ess.sba_reply_pend = mb ; 673 else { 674 DB_ESS("Frame is lost - another frame was pending\n",0,0); 675 smt_free_mbuf(smc,mb) ; 676 } 677 } 678 else { 679 /* 680 * Send the SBA RAF Change Reply to the network 681 */ 682 DB_ESS("ESS:Send to the network\n",0,0) ; 683 smt_send_frame(smc,mb,FC_SMT_INFO,0) ; 684 } 685} 686 687void ess_para_change(struct s_smc *smc) 688{ 689 (void)process_bw_alloc(smc,(long)smc->mib.a[PATH0].fddiPATHSbaPayload, 690 (long)smc->mib.a[PATH0].fddiPATHSbaOverhead) ; 691} 692 693static void ess_config_fifo(struct s_smc *smc) 694{ 695 /* 696 * if nothing to do exit 697 */ 698 if (smc->mib.a[PATH0].fddiPATHSbaPayload) { 699 if (smc->hw.fp.fifo.fifo_config_mode & SYNC_TRAFFIC_ON && 700 (smc->hw.fp.fifo.fifo_config_mode&SEND_ASYNC_AS_SYNC) == 701 smc->mib.fddiESSSynchTxMode) { 702 return ; 703 } 704 } 705 else { 706 if (!(smc->hw.fp.fifo.fifo_config_mode & SYNC_TRAFFIC_ON)) { 707 return ; 708 } 709 } 710 711 /* 712 * split up the FIFO and reinitialize the queues 713 */ 714 formac_reinit_tx(smc) ; 715} 716 717#endif /* ESS */ 718 719#endif /* no SLIM_SMT */ 720