sys/dev/isci/scil/scic_sds_remote_device.h

   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
  65 extern "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
  75 struct SCIC_SDS_CONTROLLER;
  76 struct SCIC_SDS_PORT;
  77 struct SCIC_SDS_REQUEST;
  78 struct 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  */
  86 enum 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  */
 120 enum 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
 176 enum 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  */
 202 typedef 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
 307 typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_HANDLER_T)(
 308                                  SCIC_SDS_REMOTE_DEVICE_T *this_device);
 309
 310 typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_SUSPEND_HANDLER_T)(
 311                                  SCIC_SDS_REMOTE_DEVICE_T *this_device,
 312                                  U32                       suspend_type);
 313
 314 typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_RESUME_HANDLER_T)(
 315                                  SCIC_SDS_REMOTE_DEVICE_T *this_device);
 316
 317 typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_FRAME_HANDLER_T)(
 318                                   SCIC_SDS_REMOTE_DEVICE_T *this_device,
 319                                   U32                       frame_index);
 320
 321 typedef SCI_STATUS (*SCIC_SDS_REMOTE_DEVICE_EVENT_HANDLER_T)(
 322                                   SCIC_SDS_REMOTE_DEVICE_T *this_device,
 323                                   U32                       event_code);
 324
 325 typedef 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  */
 333 typedef 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
 346 extern SCI_BASE_STATE_T scic_sds_remote_device_state_table[];
 347 extern SCI_BASE_STATE_T scic_sds_ssp_remote_device_ready_substate_table[];
 348 extern SCI_BASE_STATE_T scic_sds_stp_remote_device_ready_substate_table[];
 349 extern SCI_BASE_STATE_T scic_sds_smp_remote_device_ready_substate_table[];
 350
 351 extern SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER_T
 352                scic_sds_remote_device_state_handler_table[];
 353 extern SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER_T
 354                scic_sds_ssp_remote_device_ready_substate_handler_table[];
 355 extern SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER_T
 356                scic_sds_stp_remote_device_ready_substate_handler_table[];
 357 extern 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
 472 U32 scic_sds_remote_device_get_min_timer_count(void);
 473
 474 U32 scic_sds_remote_device_get_max_timer_count(void);
 475
 476 SCI_STATUS scic_sds_remote_device_frame_handler(
 477    SCIC_SDS_REMOTE_DEVICE_T *this_device,
 478    U32                       frame_index
 479 );
 480
 481 SCI_STATUS scic_sds_remote_device_event_handler(
 482    SCIC_SDS_REMOTE_DEVICE_T *this_device,
 483    U32                       event_code
 484 );
 485
 486 SCI_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
 492 SCI_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
 498 SCI_STATUS scic_sds_remote_device_resume(
 499    SCIC_SDS_REMOTE_DEVICE_T *this_device
 500 );
 501
 502 SCI_STATUS scic_sds_remote_device_suspend(
 503    SCIC_SDS_REMOTE_DEVICE_T *this_device,
 504    U32                       suspend_type
 505 );
 506
 507 SCI_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
 513 void scic_sds_remote_device_post_request(
 514    SCIC_SDS_REMOTE_DEVICE_T * this_device,
 515    U32                        request
 516 );
 517
 518 #if !defined(DISABLE_ATAPI)
 519 BOOL 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
 529 void scic_sds_remote_device_initialize_state_logging(
 530    SCIC_SDS_REMOTE_DEVICE_T *this_device
 531 );
 532
 533 void 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
 543 void 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
 549 void scic_sds_remote_device_continue_request(
 550    SCIC_SDS_REMOTE_DEVICE_T * this_device
 551 );
 552
 553 SCI_STATUS scic_sds_remote_device_default_start_handler(
 554    SCI_BASE_REMOTE_DEVICE_T *this_device
 555 );
 556
 557 SCI_STATUS scic_sds_remote_device_default_stop_handler(
 558    SCI_BASE_REMOTE_DEVICE_T *this_device
 559 );
 560
 561 SCI_STATUS scic_sds_remote_device_default_fail_handler(
 562    SCI_BASE_REMOTE_DEVICE_T *this_device
 563 );
 564
 565 SCI_STATUS scic_sds_remote_device_default_destruct_handler(
 566    SCI_BASE_REMOTE_DEVICE_T *this_device
 567 );
 568
 569 SCI_STATUS scic_sds_remote_device_default_reset_handler(
 570    SCI_BASE_REMOTE_DEVICE_T *device
 571 );
 572
 573 SCI_STATUS scic_sds_remote_device_default_reset_complete_handler(
 574    SCI_BASE_REMOTE_DEVICE_T *device
 575 );
 576
 577 SCI_STATUS scic_sds_remote_device_default_start_request_handler(
 578    SCI_BASE_REMOTE_DEVICE_T *device,
 579    SCI_BASE_REQUEST_T       *request
 580 );
 581
 582 SCI_STATUS scic_sds_remote_device_default_complete_request_handler(
 583    SCI_BASE_REMOTE_DEVICE_T *device,
 584    SCI_BASE_REQUEST_T       *request
 585 );
 586
 587 SCI_STATUS scic_sds_remote_device_default_continue_request_handler(
 588    SCI_BASE_REMOTE_DEVICE_T *device,
 589    SCI_BASE_REQUEST_T       *request
 590 );
 591
 592 SCI_STATUS scic_sds_remote_device_default_suspend_handler(
 593    SCIC_SDS_REMOTE_DEVICE_T *this_device,
 594    U32                       suspend_type
 595 );
 596
 597 SCI_STATUS scic_sds_remote_device_default_resume_handler(
 598    SCIC_SDS_REMOTE_DEVICE_T *this_device
 599 );
 600
 601 SCI_STATUS  scic_sds_remote_device_default_event_handler(
 602    SCIC_SDS_REMOTE_DEVICE_T *this_device,
 603    U32                       event_code
 604 );
 605
 606 SCI_STATUS scic_sds_remote_device_default_frame_handler(
 607    SCIC_SDS_REMOTE_DEVICE_T *this_device,
 608    U32                       frame_index
 609 );
 610
 611 // ---------------------------------------------------------------------------
 612
 613 SCI_STATUS scic_sds_remote_device_ready_state_stop_handler(
 614    SCI_BASE_REMOTE_DEVICE_T *device
 615 );
 616
 617 SCI_STATUS scic_sds_remote_device_ready_state_reset_handler(
 618    SCI_BASE_REMOTE_DEVICE_T *device
 619 );
 620
 621 SCI_STATUS scic_sds_remote_device_general_frame_handler(
 622    SCIC_SDS_REMOTE_DEVICE_T *this_device,
 623    U32                       frame_index
 624 );
 625
 626 SCI_STATUS scic_sds_remote_device_general_event_handler(
 627    SCIC_SDS_REMOTE_DEVICE_T *this_device,
 628    U32                       event_code
 629 );
 630
 631 SCI_STATUS scic_sds_ssp_remote_device_ready_suspended_substate_resume_handler(
 632    SCIC_SDS_REMOTE_DEVICE_T *this_device
 633 );
 634
 635 // ---------------------------------------------------------------------------
 636
 637 void 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_