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 * 40 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 41 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 42 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 43 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 44 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 46 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 47 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 48 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 49 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 50 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 51 * 52 * $FreeBSD$ 53 */ 54#ifndef _SCIC_SDS_REMOTE_DEVICE_H_ 55#define _SCIC_SDS_REMOTE_DEVICE_H_ 56 57/** 58 * @file 59 * 60 * @brief This file contains the structures, constants, and prototypes for the 61 * SCIC_SDS_REMOTE_DEVICE object. 62 */ 63 64#ifdef __cplusplus 65extern "C" { 66#endif // __cplusplus 67 68#include <dev/isci/scil/intel_sas.h> 69#include <dev/isci/scil/sci_base_remote_device.h> 70#include <dev/isci/scil/sci_base_request.h> 71#include <dev/isci/scil/sci_base_state_machine_logger.h> 72#include <dev/isci/scil/scu_remote_node_context.h> 73#include <dev/isci/scil/scic_sds_remote_node_context.h> 74 75struct SCIC_SDS_CONTROLLER; 76struct SCIC_SDS_PORT; 77struct SCIC_SDS_REQUEST; 78struct SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER; 79 80/** 81 * @enum SCIC_SDS_SSP_REMOTE_DEVICE_READY_SUBSTATES 82 * 83 * This is the enumeration of the ready substates for the 84 * SCIC_SDS_REMOTE_DEVICE. 85 */ 86enum SCIC_SDS_SSP_REMOTE_DEVICE_READY_SUBSTATES 87{ 88 /** 89 * This is the initial state for the remote device ready substate. 90 */ 91 SCIC_SDS_SSP_REMOTE_DEVICE_READY_SUBSTATE_INITIAL, 92 93 /** 94 * This is the ready operational substate for the remote device. This is the 95 * normal operational state for a remote device. 96 */ 97 SCIC_SDS_SSP_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL, 98 99 /** 100 * This is the suspended state for the remote device. This is the state that 101 * the device is placed in when a RNC suspend is received by the SCU hardware. 102 */ 103 SCIC_SDS_SSP_REMOTE_DEVICE_READY_SUBSTATE_SUSPENDED, 104 105 /** 106 * This is the final state that the device is placed in before a change to the 107 * base state machine. 108 */ 109 SCIC_SDS_SSP_REMOTE_DEVICE_READY_SUBSTATE_FINAL, 110 111 SCIC_SDS_SSP_REMOTE_DEVICE_READY_MAX_SUBSTATES 112}; 113 114/** 115 * @enum SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATES 116 * 117 * This is the enumeration for the SCIC_SDS_REMOTE_DEVICE ready substates for 118 * the STP remote device. 119 */ 120enum SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATES 121{ 122 /** 123 * This is the idle substate for the stp remote device. When there are no 124 * active IO for the device it is in this state. 125 */ 126 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE, 127 128 /** 129 * This is the command state for for the STP remote device. This state is 130 * entered when the device is processing a non-NCQ command. The device object 131 * will fail any new start IO requests until this command is complete. 132 */ 133 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD, 134 135 /** 136 * This is the NCQ state for the STP remote device. This state is entered 137 * when the device is processing an NCQ reuqest. It will remain in this state 138 * so long as there is one or more NCQ requests being processed. 139 */ 140 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ, 141 142 /** 143 * This is the NCQ error state for the STP remote device. This state is 144 * entered when an SDB error FIS is received by the device object while in the 145 * NCQ state. The device object will only accept a READ LOG command while in 146 * this state. 147 */ 148 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR, 149 150#if !defined(DISABLE_ATAPI) 151 /** 152 * This is the ATAPI error state for the STP ATAPI remote device. This state is 153 * entered when ATAPI device sends error status FIS without data while the device 154 * object is in CMD state. A suspension event is expected in this state. The device 155 * object will resume right away. 156 */ 157 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_ATAPI_ERROR, 158#endif 159 160 /** 161 * This is the READY substate indicates the device is waiting for the RESET task 162 * coming to be recovered from certain hardware specific error. 163 */ 164 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET, 165 166 SCIC_SDS_STP_REMOTE_DEVICE_READY_MAX_SUBSTATES 167}; 168 169 170/** 171 * @enum SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATES 172 * 173 * This is the enumeration of the ready substates for the SMP REMOTE DEVICE. 174 */ 175 176enum SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATES 177{ 178 /** 179 * This is the ready operational substate for the remote device. This is the 180 * normal operational state for a remote device. 181 */ 182 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE, 183 184 /** 185 * This is the suspended state for the remote device. This is the state that 186 * the device is placed in when a RNC suspend is received by the SCU hardware. 187 */ 188 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD, 189 190 SCIC_SDS_SMP_REMOTE_DEVICE_READY_MAX_SUBSTATES 191}; 192 193 194 195 196/** 197 * @struct SCIC_SDS_REMOTE_DEVICE 198 * 199 * @brief This structure contains the data for an SCU implementation of 200 * the SCU Core device data. 201 */ 202typedef struct SCIC_SDS_REMOTE_DEVICE 203{ 204 /** 205 * This field is the common base for all remote device objects. 206 */ 207 SCI_BASE_REMOTE_DEVICE_T parent; 208 209 /** 210 * This field is the programmed device port width. This value is written to 211 * the RCN data structure to tell the SCU how many open connections this 212 * device can have. 213 */ 214 U32 device_port_width; 215 216 /** 217 * This field is the programmed connection rate for this remote device. It is 218 * used to program the TC with the maximum allowed connection rate. 219 */ 220 SCI_SAS_LINK_RATE connection_rate; 221 222 /** 223 * This field contains the allowed target protocols for this remote device. 224 */ 225 SMP_DISCOVER_RESPONSE_PROTOCOLS_T target_protocols; 226 227 /** 228 * This field contains the device SAS address. 229 */ 230 SCI_SAS_ADDRESS_T device_address; 231 232 /** 233 * This filed is assinged the value of TRUE if the device is directly attached 234 * to the port. 235 */ 236 BOOL is_direct_attached; 237 238#if !defined(DISABLE_ATAPI) 239 /** 240 * This filed is assinged the value of TRUE if the device is an ATAPI device. 241 */ 242 BOOL is_atapi; 243#endif 244 245 /** 246 * This filed contains a pointer back to the port to which this device is 247 * assigned. 248 */ 249 struct SCIC_SDS_PORT *owning_port; 250 251 /** 252 * This field contains the SCU silicon remote node context specific 253 * information. 254 */ 255 struct SCIC_SDS_REMOTE_NODE_CONTEXT * rnc; 256 257 /** 258 * This field contains the stated request count for the remote device. The 259 * device can not reach the SCI_BASE_REMOTE_DEVICE_STATE_STOPPED until all 260 * requests are complete and the rnc_posted value is FALSE. 261 */ 262 U32 started_request_count; 263 264 /** 265 * This field contains a pointer to the working request object. It is only 266 * used only for SATA requests since the unsolicited frames we get from the 267 * hardware have no Tag value to look up the io request object. 268 */ 269 struct SCIC_SDS_REQUEST * working_request; 270 271 /** 272 * This field contains the reason for the remote device going not_ready. It is 273 * assigned in the state handlers and used in the state transition. 274 */ 275 U32 not_ready_reason; 276 277 /** 278 * This field is TRUE if this remote device has an initialzied ready substate 279 * machine. SSP devices do not have a ready substate machine and STP devices 280 * have a ready substate machine. 281 */ 282 BOOL has_ready_substate_machine; 283 284 /** 285 * This field contains the state machine for the ready substate machine for 286 * this SCIC_SDS_REMOTE_DEVICE object. 287 */ 288 SCI_BASE_STATE_MACHINE_T ready_substate_machine; 289 290 /** 291 * This field maintains the set of state handlers for the remote device 292 * object. These are changed each time the remote device enters a new state. 293 */ 294 struct SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER *state_handlers; 295 296 #ifdef SCI_LOGGING 297 /** 298 * This field conatins the ready substate machine logger. The logger will 299 * emit a message each time the ready substate machine changes state. 300 */ 301 SCI_BASE_STATE_MACHINE_LOGGER_T ready_substate_machine_logger; 302 #endif 303 304} SCIC_SDS_REMOTE_DEVICE_T; 305 306 307typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_HANDLER_T)( 308 SCIC_SDS_REMOTE_DEVICE_T *this_device); 309 310typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_SUSPEND_HANDLER_T)( 311 SCIC_SDS_REMOTE_DEVICE_T *this_device, 312 U32 suspend_type); 313 314typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_RESUME_HANDLER_T)( 315 SCIC_SDS_REMOTE_DEVICE_T *this_device); 316 317typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_FRAME_HANDLER_T)( 318 SCIC_SDS_REMOTE_DEVICE_T *this_device, 319 U32 frame_index); 320 321typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_EVENT_HANDLER_T)( 322 SCIC_SDS_REMOTE_DEVICE_T *this_device, 323 U32 event_code); 324 325typedef void (*SCIC_SDS_REMOTE_DEVICE_READY_NOT_READY_HANDLER_T)( 326 SCIC_SDS_REMOTE_DEVICE_T *this_device); 327 328/** 329 * @struct SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER 330 * @brief This structure conains the state handlers that are needed to 331 * process requests for the SCU remote device objects. 332 */ 333typedef struct SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER 334{ 335 SCI_BASE_REMOTE_DEVICE_STATE_HANDLER_T parent; 336 337 SCIC_SDS_REMOTE_DEVICE_SUSPEND_HANDLER_T suspend_handler; 338 SCIC_SDS_REMOTE_DEVICE_RESUME_HANDLER_T resume_handler; 339 340 SCIC_SDS_REMOTE_DEVICE_EVENT_HANDLER_T event_handler; 341 SCIC_SDS_REMOTE_DEVICE_FRAME_HANDLER_T frame_handler; 342 343} SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER_T; 344 345 346extern SCI_BASE_STATE_T scic_sds_remote_device_state_table[]; 347extern SCI_BASE_STATE_T scic_sds_ssp_remote_device_ready_substate_table[]; 348extern SCI_BASE_STATE_T scic_sds_stp_remote_device_ready_substate_table[]; 349extern SCI_BASE_STATE_T scic_sds_smp_remote_device_ready_substate_table[]; 350 351extern SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER_T 352 scic_sds_remote_device_state_handler_table[]; 353extern SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER_T 354 scic_sds_ssp_remote_device_ready_substate_handler_table[]; 355extern SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER_T 356 scic_sds_stp_remote_device_ready_substate_handler_table[]; 357extern SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER_T 358 scic_sds_smp_remote_device_ready_substate_handler_table[]; 359 360/** 361 * This macro incrments the request count for this device 362 */ 363#define scic_sds_remote_device_increment_request_count(this_device) \ 364 ((this_device)->started_request_count++) 365 366/** 367 * This macro decrements the request count for this device. This count 368 * will never decrment past 0. 369 */ 370#define scic_sds_remote_device_decrement_request_count(this_device) \ 371 ((this_device)->started_request_count > 0 ? \ 372 (this_device)->started_request_count-- : 0) 373 374/** 375 * This is a helper macro to return the current device request count. 376 */ 377#define scic_sds_remote_device_get_request_count(this_device) \ 378 ((this_device)->started_request_count) 379 380/** 381 * This macro returns the owning port of this remote device obejct. 382 */ 383#define scic_sds_remote_device_get_port(this_device) \ 384 ((this_device)->owning_port) 385 386/** 387 * This macro returns the controller object that contains this device 388 * object 389 */ 390#define scic_sds_remote_device_get_controller(this_device) \ 391 scic_sds_port_get_controller(scic_sds_remote_device_get_port(this_device)) 392 393/** 394 * This macro sets the remote device state handlers pointer and is set on 395 * entry to each device state. 396 */ 397#define scic_sds_remote_device_set_state_handlers(this_device, handlers) \ 398 ((this_device)->state_handlers = (handlers)) 399 400/** 401 * This macro returns the base sate machine object for the remote device. 402 */ 403#define scic_sds_remote_device_get_base_state_machine(this_device) \ 404 (&(this_device)->parent.state_machine) 405 406/** 407 * This macro returns the remote device ready substate machine 408 */ 409#define scic_sds_remote_device_get_ready_substate_machine(this_device) \ 410 (&(this_device)->ready_substate_machine) 411 412/** 413 * This macro returns the owning port of this device 414 */ 415#define scic_sds_remote_device_get_port(this_device) \ 416 ((this_device)->owning_port) 417 418/** 419 * This macro returns the remote device sequence value 420 */ 421#define scic_sds_remote_device_get_sequence(this_device) \ 422 ( \ 423 scic_sds_remote_device_get_controller(this_device)->\ 424 remote_device_sequence[(this_device)->rnc->remote_node_index] \ 425 ) 426 427/** 428 * This macro returns the controllers protocol engine group 429 */ 430#define scic_sds_remote_device_get_controller_peg(this_device) \ 431 ( \ 432 scic_sds_controller_get_protocol_engine_group( \ 433 scic_sds_port_get_controller( \ 434 scic_sds_remote_device_get_port(this_device) \ 435 ) \ 436 ) \ 437 ) 438 439/** 440 * This macro returns the port index for the devices owning port 441 */ 442#define scic_sds_remote_device_get_port_index(this_device) \ 443 (scic_sds_port_get_index(scic_sds_remote_device_get_port(this_device))) 444 445/** 446 * This macro returns the remote node index for this device object 447 */ 448#define scic_sds_remote_device_get_index(this_device) \ 449 ((this_device)->rnc->remote_node_index) 450 451/** 452 * This macro builds a remote device context for the SCU post request 453 * operation 454 */ 455#define scic_sds_remote_device_build_command_context(device, command) \ 456 ( (command) \ 457 | ((U32)(scic_sds_remote_device_get_controller_peg((device))) << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT)\ 458 | ((U32)(scic_sds_remote_device_get_port_index((device))) << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) \ 459 | (scic_sds_remote_device_get_index((device))) \ 460 ) 461 462/** 463 * This macro makes the working request assingment for the remote device 464 * object. To clear the working request use this macro with a NULL request 465 * object. 466 */ 467#define scic_sds_remote_device_set_working_request(device, request) \ 468 ((device)->working_request = (request)) 469 470// --------------------------------------------------------------------------- 471 472U32 scic_sds_remote_device_get_min_timer_count(void); 473 474U32 scic_sds_remote_device_get_max_timer_count(void); 475 476SCI_STATUS scic_sds_remote_device_frame_handler( 477 SCIC_SDS_REMOTE_DEVICE_T *this_device, 478 U32 frame_index 479); 480 481SCI_STATUS scic_sds_remote_device_event_handler( 482 SCIC_SDS_REMOTE_DEVICE_T *this_device, 483 U32 event_code 484); 485 486SCI_STATUS scic_sds_remote_device_start_io( 487 struct SCIC_SDS_CONTROLLER *controller, 488 SCIC_SDS_REMOTE_DEVICE_T *this_device, 489 struct SCIC_SDS_REQUEST *io_request 490); 491 492SCI_STATUS scic_sds_remote_device_complete_io( 493 struct SCIC_SDS_CONTROLLER *controller, 494 SCIC_SDS_REMOTE_DEVICE_T *this_device, 495 struct SCIC_SDS_REQUEST *io_request 496); 497 498SCI_STATUS scic_sds_remote_device_resume( 499 SCIC_SDS_REMOTE_DEVICE_T *this_device 500); 501 502SCI_STATUS scic_sds_remote_device_suspend( 503 SCIC_SDS_REMOTE_DEVICE_T *this_device, 504 U32 suspend_type 505); 506 507SCI_STATUS scic_sds_remote_device_start_task( 508 struct SCIC_SDS_CONTROLLER *controller, 509 SCIC_SDS_REMOTE_DEVICE_T *this_device, 510 struct SCIC_SDS_REQUEST *io_request 511); 512 513void scic_sds_remote_device_post_request( 514 SCIC_SDS_REMOTE_DEVICE_T * this_device, 515 U32 request 516); 517 518#if !defined(DISABLE_ATAPI) 519BOOL scic_sds_remote_device_is_atapi( 520 SCIC_SDS_REMOTE_DEVICE_T *this_device 521); 522#else // !defined(DISABLE_ATAPI) 523#define scic_sds_remote_device_is_atapi(this_device) FALSE 524#endif // !defined(DISABLE_ATAPI) 525 526// --------------------------------------------------------------------------- 527 528#ifdef SCI_LOGGING 529void scic_sds_remote_device_initialize_state_logging( 530 SCIC_SDS_REMOTE_DEVICE_T *this_device 531); 532 533void scic_sds_remote_device_deinitialize_state_logging( 534 SCIC_SDS_REMOTE_DEVICE_T *this_device 535); 536#else // SCI_LOGGING 537#define scic_sds_remote_device_initialize_state_logging(x) 538#define scic_sds_remote_device_deinitialize_state_logging(x) 539#endif // SCI_LOGGING 540 541// --------------------------------------------------------------------------- 542 543void scic_sds_remote_device_start_request( 544 SCIC_SDS_REMOTE_DEVICE_T * this_device, 545 struct SCIC_SDS_REQUEST * the_request, 546 SCI_STATUS status 547); 548 549void scic_sds_remote_device_continue_request( 550 SCIC_SDS_REMOTE_DEVICE_T * this_device 551); 552 553SCI_STATUS scic_sds_remote_device_default_start_handler( 554 SCI_BASE_REMOTE_DEVICE_T *this_device 555); 556 557SCI_STATUS scic_sds_remote_device_default_stop_handler( 558 SCI_BASE_REMOTE_DEVICE_T *this_device 559); 560 561SCI_STATUS scic_sds_remote_device_default_fail_handler( 562 SCI_BASE_REMOTE_DEVICE_T *this_device 563); 564 565SCI_STATUS scic_sds_remote_device_default_destruct_handler( 566 SCI_BASE_REMOTE_DEVICE_T *this_device 567); 568 569SCI_STATUS scic_sds_remote_device_default_reset_handler( 570 SCI_BASE_REMOTE_DEVICE_T *device 571); 572 573SCI_STATUS scic_sds_remote_device_default_reset_complete_handler( 574 SCI_BASE_REMOTE_DEVICE_T *device 575); 576 577SCI_STATUS scic_sds_remote_device_default_start_request_handler( 578 SCI_BASE_REMOTE_DEVICE_T *device, 579 SCI_BASE_REQUEST_T *request 580); 581 582SCI_STATUS scic_sds_remote_device_default_complete_request_handler( 583 SCI_BASE_REMOTE_DEVICE_T *device, 584 SCI_BASE_REQUEST_T *request 585); 586 587SCI_STATUS scic_sds_remote_device_default_continue_request_handler( 588 SCI_BASE_REMOTE_DEVICE_T *device, 589 SCI_BASE_REQUEST_T *request 590); 591 592SCI_STATUS scic_sds_remote_device_default_suspend_handler( 593 SCIC_SDS_REMOTE_DEVICE_T *this_device, 594 U32 suspend_type 595); 596 597SCI_STATUS scic_sds_remote_device_default_resume_handler( 598 SCIC_SDS_REMOTE_DEVICE_T *this_device 599); 600 601SCI_STATUS scic_sds_remote_device_default_event_handler( 602 SCIC_SDS_REMOTE_DEVICE_T *this_device, 603 U32 event_code 604); 605 606SCI_STATUS scic_sds_remote_device_default_frame_handler( 607 SCIC_SDS_REMOTE_DEVICE_T *this_device, 608 U32 frame_index 609); 610 611// --------------------------------------------------------------------------- 612 613SCI_STATUS scic_sds_remote_device_ready_state_stop_handler( 614 SCI_BASE_REMOTE_DEVICE_T *device 615); 616 617SCI_STATUS scic_sds_remote_device_ready_state_reset_handler( 618 SCI_BASE_REMOTE_DEVICE_T *device 619); 620 621SCI_STATUS scic_sds_remote_device_general_frame_handler( 622 SCIC_SDS_REMOTE_DEVICE_T *this_device, 623 U32 frame_index 624); 625 626SCI_STATUS scic_sds_remote_device_general_event_handler( 627 SCIC_SDS_REMOTE_DEVICE_T *this_device, 628 U32 event_code 629); 630 631SCI_STATUS scic_sds_ssp_remote_device_ready_suspended_substate_resume_handler( 632 SCIC_SDS_REMOTE_DEVICE_T *this_device 633); 634 635// --------------------------------------------------------------------------- 636 637void scic_sds_remote_device_get_info_from_smp_discover_response( 638 SCIC_SDS_REMOTE_DEVICE_T * this_device, 639 SMP_RESPONSE_DISCOVER_T * discover_response 640); 641 642#ifdef __cplusplus 643} 644#endif // __cplusplus 645 646#endif // _SCIC_SDS_REMOTE_DEVICE_H_ 647