src/include/gpxe/srp.h

   1 #ifndef _GPXE_SRP_H
   2 #define _GPXE_SRP_H
   3
   4 /** @file
   5  *
   6  * SCSI RDMA Protocol
   7  *
   8  */
   9
  10 FILE_LICENCE ( BSD2 );
  11
  12 #include <stdint.h>
  13 #include <byteswap.h>
  14 #include <gpxe/iobuf.h>
  15 #include <gpxe/xfer.h>
  16 #include <gpxe/scsi.h>
  17
  18 /*****************************************************************************
  19  *
  20  * Common fields
  21  *
  22  *****************************************************************************
  23  */
  24
  25 /** An SRP information unit tag */
  26 struct srp_tag {
  27         uint32_t dwords[2];
  28 } __attribute__ (( packed ));
  29
  30 /** An SRP port ID */
  31 struct srp_port_id {
  32         uint8_t bytes[16];
  33 } __attribute__ (( packed ));
  34
  35 /** An SRP port ID pair */
  36 struct srp_port_ids {
  37         /** Initiator port ID */
  38         struct srp_port_id initiator;
  39         /** Target port ID */
  40         struct srp_port_id target;
  41 } __attribute__ (( packed ));
  42
  43 /** SRP information unit common fields */
  44 struct srp_common {
  45         /** Information unit type */
  46         uint8_t type;
  47         /** Reserved */
  48         uint8_t reserved0[7];
  49         /** Tag */
  50         struct srp_tag tag;
  51 } __attribute__ (( packed ));
  52
  53 /*****************************************************************************
  54  *
  55  * Login request
  56  *
  57  *****************************************************************************
  58  */
  59
  60 /** An SRP login request information unit */
  61 struct srp_login_req {
  62         /** Information unit type
  63          *
  64          * This must be @c SRP_LOGIN_REQ
  65          */
  66         uint8_t type;
  67         /** Reserved */
  68         uint8_t reserved0[7];
  69         /** Tag */
  70         struct srp_tag tag;
  71         /** Requested maximum initiator to target IU length */
  72         uint32_t max_i_t_iu_len;
  73         /** Reserved */
  74         uint8_t reserved1[4];
  75         /** Required buffer formats
  76          *
  77          * This is the bitwise OR of one or more @c
  78          * SRP_LOGIN_REQ_FMT_XXX constants.
  79          */
  80         uint16_t required_buffer_formats;
  81         /** Flags
  82          *
  83          * This is the bitwise OR of zero or more @c
  84          * SRP_LOGIN_REQ_FLAG_XXX and @c SRP_LOGIN_REQ_MCA_XXX
  85          * constants.
  86          */
  87         uint8_t flags;
  88         /** Reserved */
  89         uint8_t reserved2[5];
  90         /** Initiator and target port identifiers */
  91         struct srp_port_ids port_ids;
  92 } __attribute__ (( packed ));
  93
  94 /** Type of an SRP login request */
  95 #define SRP_LOGIN_REQ 0x00
  96
  97 /** Require indirect data buffer descriptor format */
  98 #define SRP_LOGIN_REQ_FMT_IDBD 0x04
  99
 100 /** Require direct data buffer descriptor format */
 101 #define SRP_LOGIN_REQ_FMT_DDBD 0x02
 102
 103 /** Use solicited notification for asynchronous events */
 104 #define SRP_LOGIN_REQ_FLAG_AESOLNT 0x40
 105
 106 /** Use solicited notification for credit request */
 107 #define SRP_LOGIN_REQ_FLAG_CRSOLNT 0x20
 108
 109 /** Use solicited notification for logouts */
 110 #define SRP_LOGIN_REQ_FLAG_LOSOLNT 0x10
 111
 112 /** Multi-channel action mask */
 113 #define SRP_LOGIN_REQ_MCA_MASK 0x03
 114
 115 /** Single RDMA channel operation */
 116 #define SRP_LOGIN_REQ_MCA_SINGLE_CHANNEL 0x00
 117
 118 /** Multiple independent RDMA channel operation */
 119 #define SRP_LOGIN_REQ_MCA_MULTIPLE_CHANNELS 0x01
 120
 121 /*****************************************************************************
 122  *
 123  * Login response
 124  *
 125  *****************************************************************************
 126  */
 127
 128 /** An SRP login response */
 129 struct srp_login_rsp {
 130         /** Information unit type
 131          *
 132          * This must be @c SRP_LOGIN_RSP
 133          */
 134         uint8_t type;
 135         /** Reserved */
 136         uint8_t reserved0[3];
 137         /** Request limit delta */
 138         uint32_t request_limit_delta;
 139         /** Tag */
 140         struct srp_tag tag;
 141         /** Maximum initiator to target IU length */
 142         uint32_t max_i_t_iu_len;
 143         /** Maximum target to initiator IU length */
 144         uint32_t max_t_i_iu_len;
 145         /** Supported buffer formats
 146          *
 147          * This is the bitwise OR of one or more @c
 148          * SRP_LOGIN_RSP_FMT_XXX constants.
 149          */
 150         uint16_t supported_buffer_formats;
 151         /** Flags
 152          *
 153          * This is the bitwise OR of zero or more @c
 154          * SRP_LOGIN_RSP_FLAG_XXX and @c SRP_LOGIN_RSP_MCR_XXX
 155          * constants.
 156          */
 157         uint8_t flags;
 158         /** Reserved */
 159         uint8_t reserved1[25];
 160 } __attribute__ (( packed ));
 161
 162 /** Type of an SRP login response */
 163 #define SRP_LOGIN_RSP 0xc0
 164
 165 /** Indirect data buffer descriptor format supported */
 166 #define SRP_LOGIN_RSP_FMT_IDBD 0x04
 167
 168 /** Direct data buffer descriptor format supported */
 169 #define SRP_LOGIN_RSP_FMT_DDBD 0x02
 170
 171 /** Solicited notification is supported */
 172 #define SRP_LOGIN_RSP_FLAG_SOLNTSUP 0x10
 173
 174 /** Multi-channel result mask */
 175 #define SRP_LOGIN_RSP_MCR_MASK 0x03
 176
 177 /** No existing RDMA channels were associated with the same I_T nexus */
 178 #define SRP_LOGIN_RSP_MCR_NO_EXISTING_CHANNELS 0x00
 179
 180 /** One or more existing RDMA channels were terminated */
 181 #define SRP_LOGIN_RSP_MCR_EXISTING_CHANNELS_TERMINATED 0x01
 182
 183 /** One or more existing RDMA channels continue to operate independently */
 184 #define SRP_LOGIN_RSP_MCR_EXISTING_CHANNELS_CONTINUE 0x02
 185
 186 /*****************************************************************************
 187  *
 188  * Login rejection
 189  *
 190  *****************************************************************************
 191  */
 192
 193 /** An SRP login rejection */
 194 struct srp_login_rej {
 195         /** Information unit type
 196          *
 197          * This must be @c SRP_LOGIN_REJ
 198          */
 199         uint8_t type;
 200         /** Reserved */
 201         uint8_t reserved0[3];
 202         /** Reason
 203          *
 204          * This is a @c SRP_LOGIN_REJ_REASON_XXX constant.
 205          */
 206         uint32_t reason;
 207         /** Tag */
 208         struct srp_tag tag;
 209         /** Reserved */
 210         uint8_t reserved1[8];
 211         /** Supported buffer formats
 212          *
 213          * This is the bitwise OR of one or more @c
 214          * SRP_LOGIN_REJ_FMT_XXX constants.
 215          */
 216         uint16_t supported_buffer_formats;
 217         /** Reserved */
 218         uint8_t reserved2[6];
 219 } __attribute__ (( packed ));
 220
 221 /** Type of an SRP login rejection */
 222 #define SRP_LOGIN_REJ 0xc2
 223
 224 /** Unable to establish RDMA channel, no reason specified */
 225 #define SRP_LOGIN_REJ_REASON_UNKNOWN 0x00010000UL
 226
 227 /** Insufficient RDMA channel resources */
 228 #define SRP_LOGIN_REJ_REASON_INSUFFICIENT_RESOURCES 0x00010001UL
 229
 230 /** Requested maximum initiator to target IU length value too large */
 231 #define SRP_LOGIN_REJ_REASON_BAD_MAX_I_T_IU_LEN 0x00010002UL
 232
 233 /** Unable to associate RDMA channel with specified I_T nexus */
 234 #define SRP_LOGIN_REJ_REASON_CANNOT_ASSOCIATE 0x00010003UL
 235
 236 /** One or more requested data buffer descriptor formats are not supported */
 237 #define SRP_LOGIN_REJ_REASON_UNSUPPORTED_BUFFER_FORMAT 0x00010004UL
 238
 239 /** SRP target port does not support multiple RDMA channels per I_T nexus */
 240 #define SRP_LOGIN_REJ_REASON_NO_MULTIPLE_CHANNELS 0x00010005UL
 241
 242 /** RDMA channel limit reached for this initiator */
 243 #define SRP_LOGIN_REJ_REASON_NO_MORE_CHANNELS 0x00010006UL
 244
 245 /** Indirect data buffer descriptor format supported */
 246 #define SRP_LOGIN_REJ_FMT_IDBD 0x04
 247
 248 /** Direct data buffer descriptor format supported */
 249 #define SRP_LOGIN_REJ_FMT_DDBD 0x02
 250
 251 /*****************************************************************************
 252  *
 253  * Initiator logout
 254  *
 255  *****************************************************************************
 256  */
 257
 258 /** An SRP initiator logout request */
 259 struct srp_i_logout {
 260         /** Information unit type
 261          *
 262          * This must be @c SRP_I_LOGOUT
 263          */
 264         uint8_t type;
 265         /** Reserved */
 266         uint8_t reserved0[7];
 267         /** Tag */
 268         struct srp_tag tag;
 269 } __attribute__ (( packed ));
 270
 271 /** Type of an SRP initiator logout request */
 272 #define SRP_I_LOGOUT 0x03
 273
 274 /*****************************************************************************
 275  *
 276  * Target logout
 277  *
 278  *****************************************************************************
 279  */
 280
 281 /** An SRP target logout request */
 282 struct srp_t_logout {
 283         /** Information unit type
 284          *
 285          * This must be @c SRP_T_LOGOUT
 286          */
 287         uint8_t type;
 288         /** Flags
 289          *
 290          * This is the bitwise OR of zero or more @c
 291          * SRP_T_LOGOUT_FLAG_XXX constants.
 292          */
 293         uint8_t flags;
 294         /** Reserved */
 295         uint8_t reserved0[2];
 296         /** Reason
 297          *
 298          * This is a @c SRP_T_LOGOUT_REASON_XXX constant.
 299          */
 300         uint32_t reason;
 301         /** Tag */
 302         struct srp_tag tag;
 303 } __attribute__ (( packed ));
 304
 305 /** Type of an SRP target logout request */
 306 #define SRP_T_LOGOUT 0x80
 307
 308 /** The initiator specified solicited notification of logouts */
 309 #define SRP_T_LOGOUT_FLAG_SOLNT 0x01
 310
 311 /** No reason specified */
 312 #define SRP_T_LOGOUT_REASON_UNKNOWN 0x00000000UL
 313
 314 /** Inactive RDMA channel (reclaiming resources) */
 315 #define SRP_T_LOGOUT_REASON_INACTIVE 0x00000001UL
 316
 317 /** Invalid information unit type code received by SRP target port */
 318 #define SRP_T_LOGOUT_REASON_INVALID_TYPE 0x00000002UL
 319
 320 /** SRP initiator port sent response with no corresponding request */
 321 #define SRP_T_LOGOUT_REASON_SPURIOUS_RESPONSE 0x00000003UL
 322
 323 /** RDMA channel disconnected due to multi-channel action code in new login */
 324 #define SRP_T_LOGOUT_REASON_MCA 0x00000004UL
 325
 326 /** Unsuppported format code value specified in data-out buffer descriptor */
 327 #define SRP_T_LOGOUT_UNSUPPORTED_DATA_OUT_FORMAT 0x00000005UL
 328
 329 /** Unsuppported format code value specified in data-in buffer descriptor */
 330 #define SRP_T_LOGOUT_UNSUPPORTED_DATA_IN_FORMAT 0x00000006UL
 331
 332 /** Invalid length for IU type */
 333 #define SRP_T_LOGOUT_INVALID_IU_LEN 0x00000008UL
 334
 335 /*****************************************************************************
 336  *
 337  * Task management
 338  *
 339  *****************************************************************************
 340  */
 341
 342 /** An SRP task management request */
 343 struct srp_tsk_mgmt {
 344         /** Information unit type
 345          *
 346          * This must be @c SRP_TSK_MGMT
 347          */
 348         uint8_t type;
 349         /** Flags
 350          *
 351          * This is the bitwise OR of zero or more
 352          * @c SRP_TSK_MGMT_FLAG_XXX constants.
 353          */
 354         uint8_t flags;
 355         /** Reserved */
 356         uint8_t reserved0[6];
 357         /** Tag */
 358         struct srp_tag tag;
 359         /** Reserved */
 360         uint8_t reserved1[4];
 361         /** Logical unit number */
 362         struct scsi_lun lun;
 363         /** Reserved */
 364         uint8_t reserved2[2];
 365         /** Task management function
 366          *
 367          * This is a @c SRP_TASK_MGMT_FUNC_XXX constant
 368          */
 369         uint8_t function;
 370         /** Reserved */
 371         uint8_t reserved3[1];
 372         /** Tag of task to be managed */
 373         struct srp_tag managed_tag;
 374         /** Reserved */
 375         uint8_t reserved4[8];
 376 } __attribute__ (( packed ));
 377
 378 /** Type of an SRP task management request */
 379 #define SRP_TSK_MGMT 0x01
 380
 381 /** Use solicited notification for unsuccessful completions */
 382 #define SRP_TSK_MGMT_FLAG_UCSOLNT 0x04
 383
 384 /** Use solicited notification for successful completions */
 385 #define SRP_TSK_MGMT_FLAG_SCSOLNT 0x02
 386
 387 /** The task manager shall perform an ABORT TASK function */
 388 #define SRP_TSK_MGMT_FUNC_ABORT_TASK 0x01
 389
 390 /** The task manager shall perform an ABORT TASK SET function */
 391 #define SRP_TSK_MGMT_FUNC_ABORT_TASK_SET 0x02
 392
 393 /** The task manager shall perform a CLEAR TASK SET function */
 394 #define SRP_TSK_MGMT_FUNC_CLEAR_TASK_SET 0x04
 395
 396 /** The task manager shall perform a LOGICAL UNIT RESET function */
 397 #define SRP_TSK_MGMT_FUNC_LOGICAL_UNIT_RESET 0x08
 398
 399 /** The task manager shall perform a CLEAR ACA function */
 400 #define SRP_TSK_MGMT_FUNC_CLEAR_ACA 0x40
 401
 402 /*****************************************************************************
 403  *
 404  * SCSI command
 405  *
 406  *****************************************************************************
 407  */
 408
 409 /** An SRP SCSI command */
 410 struct srp_cmd {
 411         /** Information unit type
 412          *
 413          * This must be @c SRP_CMD
 414          */
 415         uint8_t type;
 416         /** Flags
 417          *
 418          * This is the bitwise OR of zero or more @c SRP_CMD_FLAG_XXX
 419          * constants.
 420          */
 421         uint8_t flags;
 422         /** Reserved */
 423         uint8_t reserved0[3];
 424         /** Data buffer descriptor formats
 425          *
 426          * This is the bitwise OR of one @c SRP_CMD_DO_FMT_XXX and one @c
 427          * SRP_CMD_DI_FMT_XXX constant.
 428          */
 429         uint8_t data_buffer_formats;
 430         /** Data-out buffer descriptor count */
 431         uint8_t data_out_buffer_count;
 432         /** Data-in buffer descriptor count */
 433         uint8_t data_in_buffer_count;
 434         /** Tag */
 435         struct srp_tag tag;
 436         /** Reserved */
 437         uint8_t reserved1[4];
 438         /** Logical unit number */
 439         struct scsi_lun lun;
 440         /** Reserved */
 441         uint8_t reserved2[1];
 442         /** Task attribute
 443          *
 444          * This is a @c SRP_CMD_TASK_ATTR_XXX constant.
 445          */
 446         uint8_t task_attr;
 447         /** Reserved */
 448         uint8_t reserved3[1];
 449         /** Additional CDB length */
 450         uint8_t additional_cdb_len;
 451         /** Command data block */
 452         union scsi_cdb cdb;
 453 } __attribute__ (( packed ));
 454
 455 /** Type of an SRP SCSI command */
 456 #define SRP_CMD 0x02
 457
 458 /** Use solicited notification for unsuccessful completions */
 459 #define SRP_CMD_FLAG_UCSOLNT 0x04
 460
 461 /** Use solicited notification for successful completions */
 462 #define SRP_CMD_FLAG_SCSOLNT 0x02
 463
 464 /** Data-out buffer format mask */
 465 #define SRP_CMD_DO_FMT_MASK 0xf0
 466
 467 /** Direct data-out buffer format */
 468 #define SRP_CMD_DO_FMT_DIRECT 0x10
 469
 470 /** Indirect data-out buffer format */
 471 #define SRP_CMD_DO_FMT_INDIRECT 0x20
 472
 473 /** Data-in buffer format mask */
 474 #define SRP_CMD_DI_FMT_MASK 0x0f
 475
 476 /** Direct data-in buffer format */
 477 #define SRP_CMD_DI_FMT_DIRECT 0x01
 478
 479 /** Indirect data-in buffer format */
 480 #define SRP_CMD_DI_FMT_INDIRECT 0x02
 481
 482 /** Use the rules for a simple task attribute */
 483 #define SRP_CMD_TASK_ATTR_SIMPLE 0x00
 484
 485 /** Use the rules for a head of queue task attribute */
 486 #define SRP_CMD_TASK_ATTR_QUEUE_HEAD 0x01
 487
 488 /** Use the rules for an ordered task attribute */
 489 #define SRP_CMD_TASK_ATTR_ORDERED 0x02
 490
 491 /** Use the rules for an automatic contingent allegiance task attribute */
 492 #define SRP_CMD_TASK_ATTR_AUTOMATIC_CONTINGENT_ALLEGIANCE 0x08
 493
 494 /** An SRP memory descriptor */
 495 struct srp_memory_descriptor {
 496         /** Virtual address */
 497         uint64_t address;
 498         /** Memory handle */
 499         uint32_t handle;
 500         /** Data length */
 501         uint32_t len;
 502 } __attribute__ (( packed ));
 503
 504 /*****************************************************************************
 505  *
 506  * SCSI response
 507  *
 508  *****************************************************************************
 509  */
 510
 511 /** An SRP SCSI response */
 512 struct srp_rsp {
 513         /** Information unit type
 514          *
 515          * This must be @c SRP_RSP
 516          */
 517         uint8_t type;
 518         /** Flags
 519          *
 520          * This is the bitwise OR of zero or more @c SRP_RSP_FLAG_XXX
 521          * constants.
 522          */
 523         uint8_t flags;
 524         /** Reserved */
 525         uint8_t reserved0[2];
 526         /** Request limit delta */
 527         uint32_t request_limit_delta;
 528         /** Tag */
 529         struct srp_tag tag;
 530         /** Reserved */
 531         uint8_t reserved1[2];
 532         /** Valid fields
 533          *
 534          * This is the bitwise OR of zero or more @c SRP_RSP_VALID_XXX
 535          * constants.
 536          */
 537         uint8_t valid;
 538         /** Status
 539          *
 540          * This is the SCSI status code.
 541          */
 542         uint8_t status;
 543         /** Data-out residual count */
 544         uint32_t data_out_residual_count;
 545         /** Data-in residual count */
 546         uint32_t data_in_residual_count;
 547         /** Sense data list length */
 548         uint32_t sense_data_len;
 549         /** Response data list length */
 550         uint32_t response_data_len;
 551 } __attribute__ (( packed ));
 552
 553 /** Type of an SRP SCSI response */
 554 #define SRP_RSP 0xc1
 555
 556 /** The initiator specified solicited notification of this response */
 557 #define SRP_RSP_FLAG_SOLNT 0x01
 558
 559 /** Data-in residual count field is valid and represents an underflow */
 560 #define SRP_RSP_VALID_DIUNDER 0x20
 561
 562 /** Data-in residual count field is valid and represents an overflow */
 563 #define SRP_RSP_VALID_DIOVER 0x10
 564
 565 /** Data-out residual count field is valid and represents an underflow */
 566 #define SRP_RSP_VALID_DOUNDER 0x08
 567
 568 /** Data-out residual count field is valid and represents an overflow */
 569 #define SRP_RSP_VALID_DOOVER 0x04
 570
 571 /** Sense data list length field is valid */
 572 #define SRP_RSP_VALID_SNSVALID 0x02
 573
 574 /** Response data list length field is valid */
 575 #define SRP_RSP_VALID_RSPVALID 0x01
 576
 577 /**
 578  * Get response data portion of SCSI response
 579  *
 580  * @v rsp                       SCSI response
 581  * @ret response_data           Response data, or NULL if not present
 582  */
 583 static inline void * srp_rsp_response_data ( struct srp_rsp *rsp ) {
 584         return ( ( rsp->valid & SRP_RSP_VALID_RSPVALID ) ?
 585                  ( ( ( void * ) rsp ) + sizeof ( *rsp ) ) : NULL );
 586 }
 587
 588 /**
 589  * Get length of response data portion of SCSI response
 590  *
 591  * @v rsp                       SCSI response
 592  * @ret response_data_len       Response data length
 593  */
 594 static inline size_t srp_rsp_response_data_len ( struct srp_rsp *rsp ) {
 595         return ( ( rsp->valid & SRP_RSP_VALID_RSPVALID ) ?
 596                  ntohl ( rsp->response_data_len ) : 0 );
 597 }
 598
 599 /**
 600  * Get sense data portion of SCSI response
 601  *
 602  * @v rsp                       SCSI response
 603  * @ret sense_data              Sense data, or NULL if not present
 604  */
 605 static inline void * srp_rsp_sense_data ( struct srp_rsp *rsp ) {
 606         return ( ( rsp->valid & SRP_RSP_VALID_SNSVALID ) ?
 607                  ( ( ( void * ) rsp ) + sizeof ( *rsp ) +
 608                    srp_rsp_response_data_len ( rsp ) ) : NULL );
 609 }
 610
 611 /**
 612  * Get length of sense data portion of SCSI response
 613  *
 614  * @v rsp                       SCSI response
 615  * @ret sense_data_len          Sense data length
 616  */
 617 static inline size_t srp_rsp_sense_data_len ( struct srp_rsp *rsp ) {
 618         return ( ( rsp->valid & SRP_RSP_VALID_SNSVALID ) ?
 619                  ntohl ( rsp->sense_data_len ) : 0 );
 620 }
 621
 622 /*****************************************************************************
 623  *
 624  * Credit request
 625  *
 626  *****************************************************************************
 627  */
 628
 629 /** An SRP credit request */
 630 struct srp_cred_req {
 631         /** Information unit type
 632          *
 633          * This must be @c SRP_CRED_REQ
 634          */
 635         uint8_t type;
 636         /** Flags
 637          *
 638          * This is the bitwise OR of zero or more
 639          * @c SRP_CRED_REQ_FLAG_XXX constants.
 640          */
 641         uint8_t flags;
 642         /** Reserved */
 643         uint8_t reserved0[2];
 644         /** Request limit delta */
 645         uint32_t request_limit_delta;
 646         /** Tag */
 647         struct srp_tag tag;
 648 } __attribute__ (( packed ));
 649
 650 /** Type of an SRP credit request */
 651 #define SRP_CRED_REQ 0x81
 652
 653 /** The initiator specified solicited notification of credit requests */
 654 #define SRP_CRED_REQ_FLAG_SOLNT 0x01
 655
 656 /*****************************************************************************
 657  *
 658  * Credit response
 659  *
 660  *****************************************************************************
 661  */
 662
 663 /** An SRP credit response */
 664 struct srp_cred_rsp {
 665         /** Information unit type
 666          *
 667          * This must be @c SRP_CRED_RSP
 668          */
 669         uint8_t type;
 670         /** Reserved */
 671         uint8_t reserved0[7];
 672         /** Tag */
 673         struct srp_tag tag;
 674 } __attribute__ (( packed ));
 675
 676 /** Type of an SRP credit response */
 677 #define SRP_CRED_RSP 0x41
 678
 679 /*****************************************************************************
 680  *
 681  * Asynchronous event request
 682  *
 683  *****************************************************************************
 684  */
 685
 686 /** An SRP asynchronous event request */
 687 struct srp_aer_req {
 688         /** Information unit type
 689          *
 690          * This must be @c SRP_AER_REQ
 691          */
 692         uint8_t type;
 693         /** Flags
 694          *
 695          * This is the bitwise OR of zero or more @c
 696          * SRP_AER_REQ_FLAG_XXX constants.
 697          */
 698         uint8_t flags;
 699         /** Reserved */
 700         uint8_t reserved0[2];
 701         /** Request limit delta */
 702         uint32_t request_limit_delta;
 703         /** Tag */
 704         struct srp_tag tag;
 705         /** Reserved */
 706         uint8_t reserved1[4];
 707         /** Logical unit number */
 708         struct scsi_lun lun;
 709         /** Sense data list length */
 710         uint32_t sense_data_len;
 711         /** Reserved */
 712         uint8_t reserved2[4];
 713 } __attribute__ (( packed ));
 714
 715 /** Type of an SRP asynchronous event request */
 716 #define SRP_AER_REQ 0x82
 717
 718 /** The initiator specified solicited notification of asynchronous events */
 719 #define SRP_AER_REQ_FLAG_SOLNT 0x01
 720
 721 /**
 722  * Get sense data portion of asynchronous event request
 723  *
 724  * @v aer_req                   SRP asynchronous event request
 725  * @ret sense_data              Sense data
 726  */
 727 static inline __always_inline void *
 728 srp_aer_req_sense_data ( struct srp_aer_req *aer_req ) {
 729         return ( ( ( void * ) aer_req ) + sizeof ( *aer_req ) );
 730 }
 731
 732 /**
 733  * Get length of sense data portion of asynchronous event request
 734  *
 735  * @v aer_req                   SRP asynchronous event request
 736  * @ret sense_data_len          Sense data length
 737  */
 738 static inline __always_inline size_t
 739 srp_aer_req_sense_data_len ( struct srp_aer_req *aer_req ) {
 740         return ( ntohl ( aer_req->sense_data_len ) );
 741 }
 742
 743 /*****************************************************************************
 744  *
 745  * Asynchronous event response
 746  *
 747  *****************************************************************************
 748  */
 749
 750 /** An SRP asynchronous event response */
 751 struct srp_aer_rsp {
 752         /** Information unit type
 753          *
 754          * This must be @c SRP_AER_RSP
 755          */
 756         uint8_t type;
 757         /** Reserved */
 758         uint8_t reserved0[7];
 759         /** Tag */
 760         struct srp_tag tag;
 761 } __attribute__ (( packed ));
 762
 763 /** Type of an SRP asynchronous event response */
 764 #define SRP_AER_RSP 0x42
 765
 766 /*****************************************************************************
 767  *
 768  * Information units
 769  *
 770  *****************************************************************************
 771  */
 772
 773 /** Maximum length of any initiator-to-target IU that we will send
 774  *
 775  * The longest IU is a SRP_CMD with no additional CDB and two direct
 776  * data buffer descriptors, which comes to 80 bytes.
 777  */
 778 #define SRP_MAX_I_T_IU_LEN 80
 779
 780 /*****************************************************************************
 781  *
 782  * SRP device
 783  *
 784  *****************************************************************************
 785  */
 786
 787 struct srp_device;
 788
 789 /** An SRP transport type */
 790 struct srp_transport_type {
 791         /** Length of transport private data */
 792         size_t priv_len;
 793         /** Parse root path
 794          *
 795          * @v srp               SRP device
 796          * @v root_path         Root path
 797          * @ret                 Return status code
 798          */
 799         int ( * parse_root_path ) ( struct srp_device *srp,
 800                                     const char *root_path );
 801         /** Connect SRP session
 802          *
 803          * @v srp               SRP device
 804          * @ret rc              Return status code
 805          *
 806          * This method should open the underlying socket.
 807          */
 808         int ( * connect ) ( struct srp_device *srp );
 809 };
 810
 811 /** An SRP device */
 812 struct srp_device {
 813         /** Reference count */
 814         struct refcnt refcnt;
 815
 816         /** Initiator and target port IDs */
 817         struct srp_port_ids port_ids;
 818         /** Logical unit number */
 819         struct scsi_lun lun;
 820         /** Memory handle */
 821         uint32_t memory_handle;
 822
 823         /** Current state
 824          *
 825          * This is the bitwise-OR of zero or more @c SRP_STATE_XXX
 826          * flags.
 827          */
 828         unsigned int state;
 829         /** Retry counter */
 830         unsigned int retry_count;
 831         /** Current SCSI command */
 832         struct scsi_command *command;
 833
 834         /** Underlying data transfer interface */
 835         struct xfer_interface socket;
 836
 837         /** Transport type */
 838         struct srp_transport_type *transport;
 839         /** Transport private data */
 840         char transport_priv[0];
 841 };
 842
 843 /**
 844  * Get SRP transport private data
 845  *
 846  * @v srp               SRP device
 847  * @ret priv            SRP transport private data
 848  */
 849 static inline __always_inline void *
 850 srp_transport_priv ( struct srp_device *srp ) {
 851         return ( ( void * ) srp->transport_priv );
 852 }
 853
 854 /** SRP state flags */
 855 enum srp_state {
 856         /** Underlying socket is open */
 857         SRP_STATE_SOCKET_OPEN = 0x0001,
 858         /** Session is logged in */
 859         SRP_STATE_LOGGED_IN = 0x0002,
 860 };
 861
 862 /** Maximum number of SRP retry attempts */
 863 #define SRP_MAX_RETRIES 3
 864
 865 extern int srp_attach ( struct scsi_device *scsi, const char *root_path );
 866 extern void srp_detach ( struct scsi_device *scsi );
 867
 868 #endif /* _GPXE_SRP_H */