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