1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0 3 * 4 * This file is provided under a dual BSD/GPLv2 license. When using or 5 * redistributing this file, you may do so under either license. 6 * 7 * GPL LICENSE SUMMARY 8 * 9 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of version 2 of the GNU General Public License as 13 * published by the Free Software Foundation. 14 * 15 * This program is distributed in the hope that it will be useful, but 16 * WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 23 * The full GNU General Public License is included in this distribution 24 * in the file called LICENSE.GPL. 25 * 26 * BSD LICENSE 27 * 28 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 29 * All rights reserved. 30 * 31 * Redistribution and use in source and binary forms, with or without 32 * modification, are permitted provided that the following conditions 33 * are met: 34 * 35 * * Redistributions of source code must retain the above copyright 36 * notice, this list of conditions and the following disclaimer. 37 * * Redistributions in binary form must reproduce the above copyright 38 * notice, this list of conditions and the following disclaimer in 39 * the documentation and/or other materials provided with the 40 * distribution. 41 * 42 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 43 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 44 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 45 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 46 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 47 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 48 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 49 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 50 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 51 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 52 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 53 */ 54 55 #include <sys/cdefs.h> 56 /** 57 * @file 58 * 59 * @brief This file contains the implementation of the 60 * SCIC_SDS_REMOTE_NODE_TABLE public, protected, and private methods. 61 */ 62 63 #include <dev/isci/scil/scic_sds_remote_node_table.h> 64 #include <dev/isci/scil/scic_sds_remote_node_context.h> 65 66 /** 67 * This routine will find the bit position in absolute bit terms of the next 68 * available bit for selection. The absolute bit is index * 32 + bit 69 * position. If there are available bits in the first U32 then it is just bit 70 * position. 71 * @param[in] remote_node_table This is the remote node index table from 72 * which the selection will be made. 73 * @param[in] group_table_index This is the index to the group table from 74 * which to search for an available selection. 75 * 76 * @return U32 This is the absolute bit position for an available group. 77 */ 78 static 79 U32 scic_sds_remote_node_table_get_group_index( 80 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 81 U32 group_table_index 82 ) 83 { 84 U32 dword_index; 85 U32 * group_table; 86 U32 bit_index; 87 88 group_table = remote_node_table->remote_node_groups[group_table_index]; 89 90 for (dword_index = 0; dword_index < remote_node_table->group_array_size; dword_index++) 91 { 92 if (group_table[dword_index] != 0) 93 { 94 for (bit_index = 0; bit_index < 32; bit_index++) 95 { 96 if ((group_table[dword_index] & (1 << bit_index)) != 0) 97 { 98 return (dword_index * 32) + bit_index; 99 } 100 } 101 } 102 } 103 104 return SCIC_SDS_REMOTE_NODE_TABLE_INVALID_INDEX; 105 } 106 107 /** 108 * This method will clear the group index entry in the specified group index 109 * table. 110 * 111 * @param[in out] remote_node_table This the remote node table in which to 112 * clear the selector. 113 * @param[in] set_index This is the remote node selector in which the change 114 * will be made. 115 * @param[in] group_index This is the bit index in the table to be modified. 116 * 117 * @return none 118 */ 119 static 120 void scic_sds_remote_node_table_clear_group_index( 121 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 122 U32 group_table_index, 123 U32 group_index 124 ) 125 { 126 U32 dword_index; 127 U32 bit_index; 128 U32 * group_table; 129 130 ASSERT(group_table_index < SCU_STP_REMOTE_NODE_COUNT); 131 ASSERT(group_index < (U32)(remote_node_table->group_array_size * 32)); 132 133 dword_index = group_index / 32; 134 bit_index = group_index % 32; 135 group_table = remote_node_table->remote_node_groups[group_table_index]; 136 137 group_table[dword_index] = group_table[dword_index] & ~(1 << bit_index); 138 } 139 140 /** 141 * This method will set the group index bit entry in the specified group index 142 * table. 143 * 144 * @param[in out] remote_node_table This the remote node table in which to set 145 * the selector. 146 * @param[in] group_table_index This is the remote node selector in which the 147 * change will be made. 148 * @param[in] group_index This is the bit position in the table to be 149 * modified. 150 * 151 * @return none 152 */ 153 static 154 void scic_sds_remote_node_table_set_group_index( 155 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 156 U32 group_table_index, 157 U32 group_index 158 ) 159 { 160 U32 dword_index; 161 U32 bit_index; 162 U32 * group_table; 163 164 ASSERT(group_table_index < SCU_STP_REMOTE_NODE_COUNT); 165 ASSERT(group_index < (U32)(remote_node_table->group_array_size * 32)); 166 167 dword_index = group_index / 32; 168 bit_index = group_index % 32; 169 group_table = remote_node_table->remote_node_groups[group_table_index]; 170 171 group_table[dword_index] = group_table[dword_index] | (1 << bit_index); 172 } 173 174 /** 175 * This method will set the remote to available in the remote node allocation 176 * table. 177 * 178 * @param[in out] remote_node_table This is the remote node table in which to 179 * modify the remote node availability. 180 * @param[in] remote_node_index This is the remote node index that is being 181 * returned to the table. 182 * 183 * @return none 184 */ 185 static 186 void scic_sds_remote_node_table_set_node_index( 187 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 188 U32 remote_node_index 189 ) 190 { 191 U32 dword_location; 192 U32 dword_remainder; 193 U32 slot_normalized; 194 U32 slot_position; 195 196 ASSERT( 197 (remote_node_table->available_nodes_array_size * SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD) 198 > (remote_node_index / SCU_STP_REMOTE_NODE_COUNT) 199 ); 200 201 dword_location = remote_node_index / SCIC_SDS_REMOTE_NODES_PER_DWORD; 202 dword_remainder = remote_node_index % SCIC_SDS_REMOTE_NODES_PER_DWORD; 203 slot_normalized = (dword_remainder / SCU_STP_REMOTE_NODE_COUNT) * sizeof(U32); 204 slot_position = remote_node_index % SCU_STP_REMOTE_NODE_COUNT; 205 206 remote_node_table->available_remote_nodes[dword_location] |= 207 1 << (slot_normalized + slot_position); 208 } 209 210 /** 211 * This method clears the remote node index from the table of available remote 212 * nodes. 213 * 214 * @param[in out] remote_node_table This is the remote node table from which 215 * to clear the available remote node bit. 216 * @param[in] remote_node_index This is the remote node index which is to be 217 * cleared from the table. 218 * 219 * @return none 220 */ 221 static 222 void scic_sds_remote_node_table_clear_node_index( 223 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 224 U32 remote_node_index 225 ) 226 { 227 U32 dword_location; 228 U32 dword_remainder; 229 U32 slot_position; 230 U32 slot_normalized; 231 232 ASSERT( 233 (remote_node_table->available_nodes_array_size * SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD) 234 > (remote_node_index / SCU_STP_REMOTE_NODE_COUNT) 235 ); 236 237 dword_location = remote_node_index / SCIC_SDS_REMOTE_NODES_PER_DWORD; 238 dword_remainder = remote_node_index % SCIC_SDS_REMOTE_NODES_PER_DWORD; 239 slot_normalized = (dword_remainder / SCU_STP_REMOTE_NODE_COUNT) * sizeof(U32); 240 slot_position = remote_node_index % SCU_STP_REMOTE_NODE_COUNT; 241 242 remote_node_table->available_remote_nodes[dword_location] &= 243 ~(1 << (slot_normalized + slot_position)); 244 } 245 246 /** 247 * This method clears the entire table slot at the specified slot index. 248 * 249 * @param[in out] remote_node_table The remote node table from which the slot 250 * will be cleared. 251 * @param[in] group_index The index for the slot that is to be cleared. 252 * 253 * @return none 254 */ 255 static 256 void scic_sds_remote_node_table_clear_group( 257 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 258 U32 group_index 259 ) 260 { 261 U32 dword_location; 262 U32 dword_remainder; 263 U32 dword_value; 264 265 ASSERT( 266 (remote_node_table->available_nodes_array_size * SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD) 267 > (group_index / SCU_STP_REMOTE_NODE_COUNT) 268 ); 269 270 dword_location = group_index / SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD; 271 dword_remainder = group_index % SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD; 272 273 dword_value = remote_node_table->available_remote_nodes[dword_location]; 274 dword_value &= ~(SCIC_SDS_REMOTE_NODE_TABLE_FULL_SLOT_VALUE << (dword_remainder * 4)); 275 remote_node_table->available_remote_nodes[dword_location] = dword_value; 276 } 277 278 /** 279 * THis method sets an entire remote node group in the remote node table. 280 * 281 * @param[in] remote_node_table 282 * @param[in] group_index 283 */ 284 static 285 void scic_sds_remote_node_table_set_group( 286 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 287 U32 group_index 288 ) 289 { 290 U32 dword_location; 291 U32 dword_remainder; 292 U32 dword_value; 293 294 ASSERT( 295 (remote_node_table->available_nodes_array_size * SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD) 296 > (group_index / SCU_STP_REMOTE_NODE_COUNT) 297 ); 298 299 dword_location = group_index / SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD; 300 dword_remainder = group_index % SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD; 301 302 dword_value = remote_node_table->available_remote_nodes[dword_location]; 303 dword_value |= (SCIC_SDS_REMOTE_NODE_TABLE_FULL_SLOT_VALUE << (dword_remainder * 4)); 304 remote_node_table->available_remote_nodes[dword_location] = dword_value; 305 } 306 307 /** 308 * This method will return the group value for the specified group index. 309 * 310 * @param[in] remote_node_table This is the remote node table that for which 311 * the group value is to be returned. 312 * @param[in] group_index This is the group index to use to find the group 313 * value. 314 * 315 * @return The bit values at the specified remote node group index. 316 */ 317 static 318 U8 scic_sds_remote_node_table_get_group_value( 319 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 320 U32 group_index 321 ) 322 { 323 U32 dword_location; 324 U32 dword_remainder; 325 U32 dword_value; 326 327 dword_location = group_index / SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD; 328 dword_remainder = group_index % SCIC_SDS_REMOTE_NODE_SETS_PER_DWORD; 329 330 dword_value = remote_node_table->available_remote_nodes[dword_location]; 331 dword_value &= (SCIC_SDS_REMOTE_NODE_TABLE_FULL_SLOT_VALUE << (dword_remainder * 4)); 332 dword_value = dword_value >> (dword_remainder * 4); 333 334 return (U8)dword_value; 335 } 336 337 /** 338 * This method will initialize the remote node table for use. 339 * 340 * @param[in out] remote_node_table The remote that which is to be 341 * initialized. 342 * @param[in] remote_node_entries The number of entries to put in the table. 343 * 344 * @return none 345 */ 346 void scic_sds_remote_node_table_initialize( 347 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 348 U32 remote_node_entries 349 ) 350 { 351 U32 index; 352 353 // Initialize the raw data we could improve the speed by only initializing 354 // those entries that we are actually going to be used 355 memset( 356 remote_node_table->available_remote_nodes, 357 0x00, 358 sizeof(remote_node_table->available_remote_nodes) 359 ); 360 361 memset( 362 remote_node_table->remote_node_groups, 363 0x00, 364 sizeof(remote_node_table->remote_node_groups) 365 ); 366 367 // Initialize the available remote node sets 368 remote_node_table->available_nodes_array_size = (U16) 369 (remote_node_entries / SCIC_SDS_REMOTE_NODES_PER_DWORD) 370 + ((remote_node_entries % SCIC_SDS_REMOTE_NODES_PER_DWORD) != 0); 371 372 373 // Initialize each full DWORD to a FULL SET of remote nodes 374 for (index = 0; index < remote_node_entries; index++) 375 { 376 scic_sds_remote_node_table_set_node_index(remote_node_table, index); 377 } 378 379 remote_node_table->group_array_size = (U16) 380 (remote_node_entries / (SCU_STP_REMOTE_NODE_COUNT * 32)) 381 + ((remote_node_entries % (SCU_STP_REMOTE_NODE_COUNT * 32)) != 0); 382 383 for (index = 0; index < (remote_node_entries / SCU_STP_REMOTE_NODE_COUNT); index++) 384 { 385 // These are all guaranteed to be full slot values so fill them in the 386 // available sets of 3 remote nodes 387 scic_sds_remote_node_table_set_group_index(remote_node_table, 2, index); 388 } 389 390 // Now fill in any remainders that we may find 391 if ((remote_node_entries % SCU_STP_REMOTE_NODE_COUNT) == 2) 392 { 393 scic_sds_remote_node_table_set_group_index(remote_node_table, 1, index); 394 } 395 else if ((remote_node_entries % SCU_STP_REMOTE_NODE_COUNT) == 1) 396 { 397 scic_sds_remote_node_table_set_group_index(remote_node_table, 0, index); 398 } 399 } 400 401 /** 402 * This method will allocate a single RNi from the remote node table. The 403 * table index will determine from which remote node group table to search. 404 * This search may fail and another group node table can be specified. The 405 * function is designed to allow a serach of the available single remote node 406 * group up to the triple remote node group. If an entry is found in the 407 * specified table the remote node is removed and the remote node groups are 408 * updated. 409 * 410 * @param[in out] remote_node_table The remote node table from which to 411 * allocate a remote node. 412 * @param[in] table_index The group index that is to be used for the search. 413 * 414 * @return The RNi value or an invalid remote node context if an RNi can not 415 * be found. 416 */ 417 static 418 U16 scic_sds_remote_node_table_allocate_single_remote_node( 419 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 420 U32 group_table_index 421 ) 422 { 423 U8 index; 424 U8 group_value; 425 U32 group_index; 426 U16 remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX; 427 428 group_index = scic_sds_remote_node_table_get_group_index( 429 remote_node_table, group_table_index); 430 431 // We could not find an available slot in the table selector 0 432 if (group_index != SCIC_SDS_REMOTE_NODE_TABLE_INVALID_INDEX) 433 { 434 group_value = scic_sds_remote_node_table_get_group_value( 435 remote_node_table, group_index); 436 437 for (index = 0; index < SCU_STP_REMOTE_NODE_COUNT; index++) 438 { 439 if (((1 << index) & group_value) != 0) 440 { 441 // We have selected a bit now clear it 442 remote_node_index = (U16) (group_index * SCU_STP_REMOTE_NODE_COUNT 443 + index); 444 445 scic_sds_remote_node_table_clear_group_index( 446 remote_node_table, group_table_index, group_index 447 ); 448 449 scic_sds_remote_node_table_clear_node_index( 450 remote_node_table, remote_node_index 451 ); 452 453 if (group_table_index > 0) 454 { 455 scic_sds_remote_node_table_set_group_index( 456 remote_node_table, group_table_index - 1, group_index 457 ); 458 } 459 460 break; 461 } 462 } 463 } 464 465 return remote_node_index; 466 } 467 468 /** 469 * This method will allocate three consecutive remote node context entries. If 470 * there are no remaining triple entries the function will return a failure. 471 * 472 * @param[in] remote_node_table This is the remote node table from which to 473 * allocate the remote node entries. 474 * @param[in] group_table_index THis is the group table index which must equal 475 * two (2) for this operation. 476 * 477 * @return The remote node index that represents three consecutive remote node 478 * entries or an invalid remote node context if none can be found. 479 */ 480 static 481 U16 scic_sds_remote_node_table_allocate_triple_remote_node( 482 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 483 U32 group_table_index 484 ) 485 { 486 U32 group_index; 487 U16 remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX; 488 489 group_index = scic_sds_remote_node_table_get_group_index( 490 remote_node_table, group_table_index); 491 492 if (group_index != SCIC_SDS_REMOTE_NODE_TABLE_INVALID_INDEX) 493 { 494 remote_node_index = (U16) group_index * SCU_STP_REMOTE_NODE_COUNT; 495 496 scic_sds_remote_node_table_clear_group_index( 497 remote_node_table, group_table_index, group_index 498 ); 499 500 scic_sds_remote_node_table_clear_group( 501 remote_node_table, group_index 502 ); 503 } 504 505 return remote_node_index; 506 } 507 508 /** 509 * This method will allocate a remote node that mataches the remote node count 510 * specified by the caller. Valid values for remote node count is 511 * SCU_SSP_REMOTE_NODE_COUNT(1) or SCU_STP_REMOTE_NODE_COUNT(3). 512 * 513 * @param[in] remote_node_table This is the remote node table from which the 514 * remote node allocation is to take place. 515 * @param[in] remote_node_count This is ther remote node count which is one of 516 * SCU_SSP_REMOTE_NODE_COUNT(1) or SCU_STP_REMOTE_NODE_COUNT(3). 517 * 518 * @return U16 This is the remote node index that is returned or an invalid 519 * remote node context. 520 */ 521 U16 scic_sds_remote_node_table_allocate_remote_node( 522 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 523 U32 remote_node_count 524 ) 525 { 526 U16 remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX; 527 528 if (remote_node_count == SCU_SSP_REMOTE_NODE_COUNT) 529 { 530 remote_node_index = 531 scic_sds_remote_node_table_allocate_single_remote_node( 532 remote_node_table, 0); 533 534 if (remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) 535 { 536 remote_node_index = 537 scic_sds_remote_node_table_allocate_single_remote_node( 538 remote_node_table, 1); 539 } 540 541 if (remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) 542 { 543 remote_node_index = 544 scic_sds_remote_node_table_allocate_single_remote_node( 545 remote_node_table, 2); 546 } 547 } 548 else if (remote_node_count == SCU_STP_REMOTE_NODE_COUNT) 549 { 550 remote_node_index = 551 scic_sds_remote_node_table_allocate_triple_remote_node( 552 remote_node_table, 2); 553 } 554 555 return remote_node_index; 556 } 557 558 /** 559 * This method will free a single remote node index back to the remote node 560 * table. This routine will update the remote node groups 561 * 562 * @param[in] remote_node_table 563 * @param[in] remote_node_index 564 */ 565 static 566 void scic_sds_remote_node_table_release_single_remote_node( 567 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 568 U16 remote_node_index 569 ) 570 { 571 U32 group_index; 572 U8 group_value; 573 574 group_index = remote_node_index / SCU_STP_REMOTE_NODE_COUNT; 575 576 group_value = scic_sds_remote_node_table_get_group_value(remote_node_table, group_index); 577 578 // Assert that we are not trying to add an entry to a slot that is already 579 // full. 580 ASSERT(group_value != SCIC_SDS_REMOTE_NODE_TABLE_FULL_SLOT_VALUE); 581 582 if (group_value == 0x00) 583 { 584 // There are no entries in this slot so it must be added to the single 585 // slot table. 586 scic_sds_remote_node_table_set_group_index(remote_node_table, 0, group_index); 587 } 588 else if ((group_value & (group_value -1)) == 0) 589 { 590 // There is only one entry in this slot so it must be moved from the 591 // single slot table to the dual slot table 592 scic_sds_remote_node_table_clear_group_index(remote_node_table, 0, group_index); 593 scic_sds_remote_node_table_set_group_index(remote_node_table, 1, group_index); 594 } 595 else 596 { 597 // There are two entries in the slot so it must be moved from the dual 598 // slot table to the tripple slot table. 599 scic_sds_remote_node_table_clear_group_index(remote_node_table, 1, group_index); 600 scic_sds_remote_node_table_set_group_index(remote_node_table, 2, group_index); 601 } 602 603 scic_sds_remote_node_table_set_node_index(remote_node_table, remote_node_index); 604 } 605 606 /** 607 * This method will release a group of three consecutive remote nodes back to 608 * the free remote nodes. 609 * 610 * @param[in] remote_node_table This is the remote node table to which the 611 * remote node index is to be freed. 612 * @param[in] remote_node_index This is the remote node index which is being 613 * freed. 614 */ 615 static 616 void scic_sds_remote_node_table_release_triple_remote_node( 617 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 618 U16 remote_node_index 619 ) 620 { 621 U32 group_index; 622 623 group_index = remote_node_index / SCU_STP_REMOTE_NODE_COUNT; 624 625 scic_sds_remote_node_table_set_group_index( 626 remote_node_table, 2, group_index 627 ); 628 629 scic_sds_remote_node_table_set_group(remote_node_table, group_index); 630 } 631 632 /** 633 * This method will release the remote node index back into the remote node 634 * table free pool. 635 * 636 * @param[in] remote_node_table The remote node table to which the remote node 637 * index is to be freed. 638 * @param[in] remote_node_count This is the count of consecutive remote nodes 639 * that are to be freed. 640 * @param[in] remote_node_index This is the remote node index of the start of 641 * the number of remote nodes to be freed. 642 */ 643 void scic_sds_remote_node_table_release_remote_node_index( 644 SCIC_REMOTE_NODE_TABLE_T * remote_node_table, 645 U32 remote_node_count, 646 U16 remote_node_index 647 ) 648 { 649 if (remote_node_count == SCU_SSP_REMOTE_NODE_COUNT) 650 { 651 scic_sds_remote_node_table_release_single_remote_node( 652 remote_node_table, remote_node_index); 653 } 654 else if (remote_node_count == SCU_STP_REMOTE_NODE_COUNT) 655 { 656 scic_sds_remote_node_table_release_triple_remote_node( 657 remote_node_table, remote_node_index); 658 } 659 } 660 661