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 47 static 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 60 static 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 64 static const u_short plist_raf_chg_req[] = { SMT_P320B, SMT_P320F, SMT_P3210, 65 SMT_P001A, 0 } ; 66 67 static const struct fddi_addr smt_sba_da = {{0x80,0x01,0x43,0x00,0x80,0x0C}} ; 68 static 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 83 static void ess_send_response(struct s_smc *smc, struct smt_header *sm, 84 int sba_cmd); 85 static void ess_config_fifo(struct s_smc *smc); 86 static void ess_send_alc_req(struct s_smc *smc); 87 static 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 101 void ess_timer_poll(struct s_smc *smc); 102 void ess_para_change(struct s_smc *smc); 103 int ess_raf_received_pack(struct s_smc *smc, SMbuf *mb, struct smt_header *sm, 104 int fs); 105 static 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 */ 117 int 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"); 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"); 150 return fs; 151 } 152 153 DB_ESSN(2, "fc %x ft %x", sm->smt_class, sm->smt_type); 154 DB_ESSN(2, "ver %x tran %x", sm->smt_version, sm->smt_tid); 155 DB_ESSN(2, "stn_id %s", addr_to_string(&sm->smt_source)); 156 157 DB_ESSN(2, "infolen %x res %lx", sm->smt_len, msg_res_type); 158 DB_ESSN(2, "sbacmd %x", cmd->sba_cmd); 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 %x", sm->smt_tid); 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"); 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 Response not accepted"); 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", 265 payload, overhead); 266 267 /* 268 * process the bandwidth allocation 269 */ 270 (void)process_bw_alloc(smc,(long)payload,(long)overhead) ; 271 272 return fs; 273 /* end of Process Allocation Request */ 274 275 /* 276 * Process an ESS Change Request 277 */ 278 case CHANGE_ALLOCATION : 279 /* 280 * except only replies 281 */ 282 if (sm->smt_type != SMT_REQUEST) { 283 DB_ESS("ESS: Do not process Change Responses"); 284 return fs; 285 } 286 287 /* 288 * check the para for the Change Request 289 */ 290 if (smt_check_para(smc,sm,plist_raf_chg_req)) { 291 DB_ESS("ESS: RAF with para problem, ignoring"); 292 return fs; 293 } 294 295 /* 296 * Verify the path index and resource 297 * type are correct. If any of 298 * these are false, don't process this 299 * change request frame. 300 */ 301 if ((((struct smt_p_320b *)sm_to_para(smc,sm,SMT_P320B))->path_index 302 != PRIMARY_RING) || (msg_res_type != SYNC_BW)) { 303 DB_ESS("ESS: RAF frame with para problem, ignoring"); 304 return fs; 305 } 306 307 /* 308 * Extract message queue parameters 309 */ 310 p = (void *) sm_to_para(smc,sm,SMT_P320F) ; 311 payload = ((struct smt_p_320f *)p)->mib_payload ; 312 p = (void *) sm_to_para(smc,sm,SMT_P3210) ; 313 overhead = ((struct smt_p_3210 *)p)->mib_overhead ; 314 315 DB_ESSN(2, "ESS: Change Request from %s", 316 addr_to_string(&sm->smt_source)); 317 DB_ESSN(2, "payload= %lx overhead= %lx", 318 payload, overhead); 319 320 /* 321 * process the bandwidth allocation 322 */ 323 if(!process_bw_alloc(smc,(long)payload,(long)overhead)) 324 return fs; 325 326 /* 327 * send an RAF Change Reply 328 */ 329 ess_send_response(smc,sm,CHANGE_ALLOCATION) ; 330 331 return fs; 332 /* end of Process Change Request */ 333 334 /* 335 * Process Report Response 336 */ 337 case REPORT_ALLOCATION : 338 /* 339 * except only requests 340 */ 341 if (sm->smt_type != SMT_REQUEST) { 342 DB_ESS("ESS: Do not process a Report Reply"); 343 return fs; 344 } 345 346 DB_ESSN(2, "ESS: Report Request from %s", 347 addr_to_string(&sm->smt_source)); 348 349 /* 350 * verify that the resource type is sync bw only 351 */ 352 if (msg_res_type != SYNC_BW) { 353 DB_ESS("ESS: ignoring RAF with para problem"); 354 return fs; 355 } 356 357 /* 358 * send an RAF Change Reply 359 */ 360 ess_send_response(smc,sm,REPORT_ALLOCATION) ; 361 362 return fs; 363 /* end of Process Report Request */ 364 365 default: 366 /* 367 * error in frame 368 */ 369 DB_ESS("ESS: ignoring RAF with bad sba_cmd"); 370 break ; 371 } 372 373 return fs; 374 } 375 376 /* 377 * determines the synchronous bandwidth, set the TSYNC register and the 378 * mib variables SBAPayload, SBAOverhead and fddiMACT-NEG. 379 */ 380 static int process_bw_alloc(struct s_smc *smc, long int payload, long int overhead) 381 { 382 /* 383 * determine the synchronous bandwidth (sync_bw) in bytes per T-NEG, 384 * if the payload is greater than zero. 385 * For the SBAPayload and the SBAOverhead we have the following 386 * unite quations 387 * _ _ 388 * | bytes | 389 * SBAPayload = | 8000 ------ | 390 * | s | 391 * - - 392 * _ _ 393 * | bytes | 394 * SBAOverhead = | ------ | 395 * | T-NEG | 396 * - - 397 * 398 * T-NEG is described by the equation: 399 * 400 * (-) fddiMACT-NEG 401 * T-NEG = ------------------- 402 * 12500000 1/s 403 * 404 * The number of bytes we are able to send is the payload 405 * plus the overhead. 406 * 407 * bytes T-NEG SBAPayload 8000 bytes/s 408 * sync_bw = SBAOverhead ------ + ----------------------------- 409 * T-NEG T-NEG 410 * 411 * 412 * 1 413 * sync_bw = SBAOverhead + ---- (-)fddiMACT-NEG * SBAPayload 414 * 1562 415 * 416 */ 417 418 /* 419 * set the mib attributes fddiPATHSbaOverhead, fddiPATHSbaPayload 420 */ 421 /* if (smt_set_obj(smc,SMT_P320F,payload,S_SET)) { 422 DB_ESS("ESS: SMT does not accept the payload value"); 423 return FALSE; 424 } 425 if (smt_set_obj(smc,SMT_P3210,overhead,S_SET)) { 426 DB_ESS("ESS: SMT does not accept the overhead value"); 427 return FALSE; 428 } */ 429 430 /* premliminary */ 431 if (payload > MAX_PAYLOAD || overhead > 5000) { 432 DB_ESS("ESS: payload / overhead not accepted"); 433 return FALSE; 434 } 435 436 /* 437 * start the iterative allocation process if the payload or the overhead 438 * are smaller than the parsed values 439 */ 440 if (smc->mib.fddiESSPayload && 441 ((u_long)payload != smc->mib.fddiESSPayload || 442 (u_long)overhead != smc->mib.fddiESSOverhead)) { 443 smc->ess.raf_act_timer_poll = TRUE ; 444 smc->ess.timer_count = 0 ; 445 } 446 447 /* 448 * evulate the Payload 449 */ 450 if (payload) { 451 DB_ESSN(2, "ESS: turn SMT_ST_SYNC_SERVICE bit on"); 452 smc->ess.sync_bw_available = TRUE ; 453 454 smc->ess.sync_bw = overhead - 455 (long)smc->mib.m[MAC0].fddiMACT_Neg * 456 payload / 1562 ; 457 } 458 else { 459 DB_ESSN(2, "ESS: turn SMT_ST_SYNC_SERVICE bit off"); 460 smc->ess.sync_bw_available = FALSE ; 461 smc->ess.sync_bw = 0 ; 462 overhead = 0 ; 463 } 464 465 smc->mib.a[PATH0].fddiPATHSbaPayload = payload ; 466 smc->mib.a[PATH0].fddiPATHSbaOverhead = overhead ; 467 468 469 DB_ESSN(2, "tsync = %lx", smc->ess.sync_bw); 470 471 ess_config_fifo(smc) ; 472 set_formac_tsync(smc,smc->ess.sync_bw) ; 473 return TRUE; 474 } 475 476 static void ess_send_response(struct s_smc *smc, struct smt_header *sm, 477 int sba_cmd) 478 { 479 struct smt_sba_chg *chg ; 480 SMbuf *mb ; 481 void *p ; 482 483 /* 484 * get and initialize the response frame 485 */ 486 if (sba_cmd == CHANGE_ALLOCATION) { 487 if (!(mb=smt_build_frame(smc,SMT_RAF,SMT_REPLY, 488 sizeof(struct smt_sba_chg)))) 489 return ; 490 } 491 else { 492 if (!(mb=smt_build_frame(smc,SMT_RAF,SMT_REPLY, 493 sizeof(struct smt_sba_rep_res)))) 494 return ; 495 } 496 497 chg = smtod(mb,struct smt_sba_chg *) ; 498 chg->smt.smt_tid = sm->smt_tid ; 499 chg->smt.smt_dest = sm->smt_source ; 500 501 /* set P15 */ 502 chg->s_type.para.p_type = SMT_P0015 ; 503 chg->s_type.para.p_len = sizeof(struct smt_p_0015) - PARA_LEN ; 504 chg->s_type.res_type = SYNC_BW ; 505 506 /* set P16 */ 507 chg->cmd.para.p_type = SMT_P0016 ; 508 chg->cmd.para.p_len = sizeof(struct smt_p_0016) - PARA_LEN ; 509 chg->cmd.sba_cmd = sba_cmd ; 510 511 /* set P320B */ 512 chg->path.para.p_type = SMT_P320B ; 513 chg->path.para.p_len = sizeof(struct smt_p_320b) - PARA_LEN ; 514 chg->path.mib_index = SBAPATHINDEX ; 515 chg->path.path_pad = 0; 516 chg->path.path_index = PRIMARY_RING ; 517 518 /* set P320F */ 519 chg->payload.para.p_type = SMT_P320F ; 520 chg->payload.para.p_len = sizeof(struct smt_p_320f) - PARA_LEN ; 521 chg->payload.mib_index = SBAPATHINDEX ; 522 chg->payload.mib_payload = smc->mib.a[PATH0].fddiPATHSbaPayload ; 523 524 /* set P3210 */ 525 chg->overhead.para.p_type = SMT_P3210 ; 526 chg->overhead.para.p_len = sizeof(struct smt_p_3210) - PARA_LEN ; 527 chg->overhead.mib_index = SBAPATHINDEX ; 528 chg->overhead.mib_overhead = smc->mib.a[PATH0].fddiPATHSbaOverhead ; 529 530 if (sba_cmd == CHANGE_ALLOCATION) { 531 /* set P1A */ 532 chg->cat.para.p_type = SMT_P001A ; 533 chg->cat.para.p_len = sizeof(struct smt_p_001a) - PARA_LEN ; 534 p = (void *) sm_to_para(smc,sm,SMT_P001A) ; 535 chg->cat.category = ((struct smt_p_001a *)p)->category ; 536 } 537 dump_smt(smc,(struct smt_header *)chg,"RAF") ; 538 ess_send_frame(smc,mb) ; 539 } 540 541 void ess_timer_poll(struct s_smc *smc) 542 { 543 if (!smc->ess.raf_act_timer_poll) 544 return ; 545 546 DB_ESSN(2, "ESS: timer_poll"); 547 548 smc->ess.timer_count++ ; 549 if (smc->ess.timer_count == 10) { 550 smc->ess.timer_count = 0 ; 551 ess_send_alc_req(smc) ; 552 } 553 } 554 555 static void ess_send_alc_req(struct s_smc *smc) 556 { 557 struct smt_sba_alc_req *req ; 558 SMbuf *mb ; 559 560 /* 561 * send never allocation request where the requested payload and 562 * overhead is zero or deallocate bandwidth when no bandwidth is 563 * parsed 564 */ 565 if (!smc->mib.fddiESSPayload) { 566 smc->mib.fddiESSOverhead = 0 ; 567 } 568 else { 569 if (!smc->mib.fddiESSOverhead) 570 smc->mib.fddiESSOverhead = DEFAULT_OV ; 571 } 572 573 if (smc->mib.fddiESSOverhead == 574 smc->mib.a[PATH0].fddiPATHSbaOverhead && 575 smc->mib.fddiESSPayload == 576 smc->mib.a[PATH0].fddiPATHSbaPayload){ 577 smc->ess.raf_act_timer_poll = FALSE ; 578 smc->ess.timer_count = 7 ; /* next RAF alc req after 3 s */ 579 return ; 580 } 581 582 /* 583 * get and initialize the response frame 584 */ 585 if (!(mb=smt_build_frame(smc,SMT_RAF,SMT_REQUEST, 586 sizeof(struct smt_sba_alc_req)))) 587 return ; 588 req = smtod(mb,struct smt_sba_alc_req *) ; 589 req->smt.smt_tid = smc->ess.alloc_trans_id = smt_get_tid(smc) ; 590 req->smt.smt_dest = smt_sba_da ; 591 592 /* set P15 */ 593 req->s_type.para.p_type = SMT_P0015 ; 594 req->s_type.para.p_len = sizeof(struct smt_p_0015) - PARA_LEN ; 595 req->s_type.res_type = SYNC_BW ; 596 597 /* set P16 */ 598 req->cmd.para.p_type = SMT_P0016 ; 599 req->cmd.para.p_len = sizeof(struct smt_p_0016) - PARA_LEN ; 600 req->cmd.sba_cmd = REQUEST_ALLOCATION ; 601 602 /* 603 * set the parameter type and parameter length of all used 604 * parameters 605 */ 606 607 /* set P320B */ 608 req->path.para.p_type = SMT_P320B ; 609 req->path.para.p_len = sizeof(struct smt_p_320b) - PARA_LEN ; 610 req->path.mib_index = SBAPATHINDEX ; 611 req->path.path_pad = 0; 612 req->path.path_index = PRIMARY_RING ; 613 614 /* set P0017 */ 615 req->pl_req.para.p_type = SMT_P0017 ; 616 req->pl_req.para.p_len = sizeof(struct smt_p_0017) - PARA_LEN ; 617 req->pl_req.sba_pl_req = smc->mib.fddiESSPayload - 618 smc->mib.a[PATH0].fddiPATHSbaPayload ; 619 620 /* set P0018 */ 621 req->ov_req.para.p_type = SMT_P0018 ; 622 req->ov_req.para.p_len = sizeof(struct smt_p_0018) - PARA_LEN ; 623 req->ov_req.sba_ov_req = smc->mib.fddiESSOverhead - 624 smc->mib.a[PATH0].fddiPATHSbaOverhead ; 625 626 /* set P320F */ 627 req->payload.para.p_type = SMT_P320F ; 628 req->payload.para.p_len = sizeof(struct smt_p_320f) - PARA_LEN ; 629 req->payload.mib_index = SBAPATHINDEX ; 630 req->payload.mib_payload = smc->mib.a[PATH0].fddiPATHSbaPayload ; 631 632 /* set P3210 */ 633 req->overhead.para.p_type = SMT_P3210 ; 634 req->overhead.para.p_len = sizeof(struct smt_p_3210) - PARA_LEN ; 635 req->overhead.mib_index = SBAPATHINDEX ; 636 req->overhead.mib_overhead = smc->mib.a[PATH0].fddiPATHSbaOverhead ; 637 638 /* set P19 */ 639 req->a_addr.para.p_type = SMT_P0019 ; 640 req->a_addr.para.p_len = sizeof(struct smt_p_0019) - PARA_LEN ; 641 req->a_addr.sba_pad = 0; 642 req->a_addr.alloc_addr = null_addr ; 643 644 /* set P1A */ 645 req->cat.para.p_type = SMT_P001A ; 646 req->cat.para.p_len = sizeof(struct smt_p_001a) - PARA_LEN ; 647 req->cat.category = smc->mib.fddiESSCategory ; 648 649 /* set P1B */ 650 req->tneg.para.p_type = SMT_P001B ; 651 req->tneg.para.p_len = sizeof(struct smt_p_001b) - PARA_LEN ; 652 req->tneg.max_t_neg = smc->mib.fddiESSMaxTNeg ; 653 654 /* set P1C */ 655 req->segm.para.p_type = SMT_P001C ; 656 req->segm.para.p_len = sizeof(struct smt_p_001c) - PARA_LEN ; 657 req->segm.min_seg_siz = smc->mib.fddiESSMinSegmentSize ; 658 659 dump_smt(smc,(struct smt_header *)req,"RAF") ; 660 ess_send_frame(smc,mb) ; 661 } 662 663 static void ess_send_frame(struct s_smc *smc, SMbuf *mb) 664 { 665 /* 666 * check if the frame must be send to the own ESS 667 */ 668 if (smc->ess.local_sba_active) { 669 /* 670 * Send the Change Reply to the local SBA 671 */ 672 DB_ESS("ESS:Send to the local SBA"); 673 if (!smc->ess.sba_reply_pend) 674 smc->ess.sba_reply_pend = mb ; 675 else { 676 DB_ESS("Frame is lost - another frame was pending"); 677 smt_free_mbuf(smc,mb) ; 678 } 679 } 680 else { 681 /* 682 * Send the SBA RAF Change Reply to the network 683 */ 684 DB_ESS("ESS:Send to the network"); 685 smt_send_frame(smc,mb,FC_SMT_INFO,0) ; 686 } 687 } 688 689 void ess_para_change(struct s_smc *smc) 690 { 691 (void)process_bw_alloc(smc,(long)smc->mib.a[PATH0].fddiPATHSbaPayload, 692 (long)smc->mib.a[PATH0].fddiPATHSbaOverhead) ; 693 } 694 695 static void ess_config_fifo(struct s_smc *smc) 696 { 697 /* 698 * if nothing to do exit 699 */ 700 if (smc->mib.a[PATH0].fddiPATHSbaPayload) { 701 if (smc->hw.fp.fifo.fifo_config_mode & SYNC_TRAFFIC_ON && 702 (smc->hw.fp.fifo.fifo_config_mode&SEND_ASYNC_AS_SYNC) == 703 smc->mib.fddiESSSynchTxMode) { 704 return ; 705 } 706 } 707 else { 708 if (!(smc->hw.fp.fifo.fifo_config_mode & SYNC_TRAFFIC_ON)) { 709 return ; 710 } 711 } 712 713 /* 714 * split up the FIFO and reinitialize the queues 715 */ 716 formac_reinit_tx(smc) ; 717 } 718 719 #endif /* ESS */ 720 721 #endif /* no SLIM_SMT */ 722 723