1 #ifndef _IPXE_SRP_H
2 #define _IPXE_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 <ipxe/iobuf.h>
15 #include <ipxe/xfer.h>
16 #include <ipxe/scsi.h>
17 #include <ipxe/acpi.h>
18
19 /*****************************************************************************
20 *
21 * Common fields
22 *
23 *****************************************************************************
24 */
25
26 /** An SRP information unit tag */
27 union srp_tag {
28 uint8_t bytes[8];
29 uint32_t dwords[2];
30 } __attribute__ (( packed ));
31
32 /** SRP tag magic marker */
33 #define SRP_TAG_MAGIC 0x69505845
34
35 /** An SRP port ID */
36 union srp_port_id {
37 uint8_t bytes[16];
38 uint32_t dwords[4];
39 } __attribute__ (( packed ));
40
41 /** SRP information unit common fields */
42 struct srp_common {
43 /** Information unit type */
44 uint8_t type;
45 /** Reserved */
46 uint8_t reserved0[7];
47 /** Tag */
48 union srp_tag tag;
49 } __attribute__ (( packed ));
50
51 /*****************************************************************************
52 *
53 * Login request
54 *
55 *****************************************************************************
56 */
57
58 /** An SRP login request information unit */
59 struct srp_login_req {
60 /** Information unit type
61 *
62 * This must be @c SRP_LOGIN_REQ
63 */
64 uint8_t type;
65 /** Reserved */
66 uint8_t reserved0[7];
67 /** Tag */
68 union srp_tag tag;
69 /** Requested maximum initiator to target IU length */
70 uint32_t max_i_t_iu_len;
71 /** Reserved */
72 uint8_t reserved1[4];
73 /** Required buffer formats
74 *
75 * This is the bitwise OR of one or more @c
76 * SRP_LOGIN_REQ_FMT_XXX constants.
77 */
78 uint16_t required_buffer_formats;
79 /** Flags
80 *
81 * This is the bitwise OR of zero or more @c
82 * SRP_LOGIN_REQ_FLAG_XXX and @c SRP_LOGIN_REQ_MCA_XXX
83 * constants.
84 */
85 uint8_t flags;
86 /** Reserved */
87 uint8_t reserved2[5];
88 /** Initiator port identifier */
89 union srp_port_id initiator;
90 /** Target port identifier */
91 union srp_port_id target;
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 union 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 union 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 /** SRP login rejection reason is defined */
246 #define SRP_LOGIN_REJ_REASON_DEFINED( reason ) \
247 ( ( (reason) & 0xfffffff0UL ) == 0x00010000UL )
248
249 /** Indirect data buffer descriptor format supported */
250 #define SRP_LOGIN_REJ_FMT_IDBD 0x04
251
252 /** Direct data buffer descriptor format supported */
253 #define SRP_LOGIN_REJ_FMT_DDBD 0x02
254
255 /*****************************************************************************
256 *
257 * Initiator logout
258 *
259 *****************************************************************************
260 */
261
262 /** An SRP initiator logout request */
263 struct srp_i_logout {
264 /** Information unit type
265 *
266 * This must be @c SRP_I_LOGOUT
267 */
268 uint8_t type;
269 /** Reserved */
270 uint8_t reserved0[7];
271 /** Tag */
272 union srp_tag tag;
273 } __attribute__ (( packed ));
274
275 /** Type of an SRP initiator logout request */
276 #define SRP_I_LOGOUT 0x03
277
278 /*****************************************************************************
279 *
280 * Target logout
281 *
282 *****************************************************************************
283 */
284
285 /** An SRP target logout request */
286 struct srp_t_logout {
287 /** Information unit type
288 *
289 * This must be @c SRP_T_LOGOUT
290 */
291 uint8_t type;
292 /** Flags
293 *
294 * This is the bitwise OR of zero or more @c
295 * SRP_T_LOGOUT_FLAG_XXX constants.
296 */
297 uint8_t flags;
298 /** Reserved */
299 uint8_t reserved0[2];
300 /** Reason
301 *
302 * This is a @c SRP_T_LOGOUT_REASON_XXX constant.
303 */
304 uint32_t reason;
305 /** Tag */
306 union srp_tag tag;
307 } __attribute__ (( packed ));
308
309 /** Type of an SRP target logout request */
310 #define SRP_T_LOGOUT 0x80
311
312 /** The initiator specified solicited notification of logouts */
313 #define SRP_T_LOGOUT_FLAG_SOLNT 0x01
314
315 /** No reason specified */
316 #define SRP_T_LOGOUT_REASON_UNKNOWN 0x00000000UL
317
318 /** Inactive RDMA channel (reclaiming resources) */
319 #define SRP_T_LOGOUT_REASON_INACTIVE 0x00000001UL
320
321 /** Invalid information unit type code received by SRP target port */
322 #define SRP_T_LOGOUT_REASON_INVALID_TYPE 0x00000002UL
323
324 /** SRP initiator port sent response with no corresponding request */
325 #define SRP_T_LOGOUT_REASON_SPURIOUS_RESPONSE 0x00000003UL
326
327 /** RDMA channel disconnected due to multi-channel action code in new login */
328 #define SRP_T_LOGOUT_REASON_MCA 0x00000004UL
329
330 /** Unsuppported format code value specified in data-out buffer descriptor */
331 #define SRP_T_LOGOUT_UNSUPPORTED_DATA_OUT_FORMAT 0x00000005UL
332
333 /** Unsuppported format code value specified in data-in buffer descriptor */
334 #define SRP_T_LOGOUT_UNSUPPORTED_DATA_IN_FORMAT 0x00000006UL
335
336 /** Invalid length for IU type */
337 #define SRP_T_LOGOUT_INVALID_IU_LEN 0x00000008UL
338
339 /*****************************************************************************
340 *
341 * Task management
342 *
343 *****************************************************************************
344 */
345
346 /** An SRP task management request */
347 struct srp_tsk_mgmt {
348 /** Information unit type
349 *
350 * This must be @c SRP_TSK_MGMT
351 */
352 uint8_t type;
353 /** Flags
354 *
355 * This is the bitwise OR of zero or more
356 * @c SRP_TSK_MGMT_FLAG_XXX constants.
357 */
358 uint8_t flags;
359 /** Reserved */
360 uint8_t reserved0[6];
361 /** Tag */
362 union srp_tag tag;
363 /** Reserved */
364 uint8_t reserved1[4];
365 /** Logical unit number */
366 struct scsi_lun lun;
367 /** Reserved */
368 uint8_t reserved2[2];
369 /** Task management function
370 *
371 * This is a @c SRP_TASK_MGMT_FUNC_XXX constant
372 */
373 uint8_t function;
374 /** Reserved */
375 uint8_t reserved3[1];
376 /** Tag of task to be managed */
377 union srp_tag managed_tag;
378 /** Reserved */
379 uint8_t reserved4[8];
380 } __attribute__ (( packed ));
381
382 /** Type of an SRP task management request */
383 #define SRP_TSK_MGMT 0x01
384
385 /** Use solicited notification for unsuccessful completions */
386 #define SRP_TSK_MGMT_FLAG_UCSOLNT 0x04
387
388 /** Use solicited notification for successful completions */
389 #define SRP_TSK_MGMT_FLAG_SCSOLNT 0x02
390
391 /** The task manager shall perform an ABORT TASK function */
392 #define SRP_TSK_MGMT_FUNC_ABORT_TASK 0x01
393
394 /** The task manager shall perform an ABORT TASK SET function */
395 #define SRP_TSK_MGMT_FUNC_ABORT_TASK_SET 0x02
396
397 /** The task manager shall perform a CLEAR TASK SET function */
398 #define SRP_TSK_MGMT_FUNC_CLEAR_TASK_SET 0x04
399
400 /** The task manager shall perform a LOGICAL UNIT RESET function */
401 #define SRP_TSK_MGMT_FUNC_LOGICAL_UNIT_RESET 0x08
402
403 /** The task manager shall perform a CLEAR ACA function */
404 #define SRP_TSK_MGMT_FUNC_CLEAR_ACA 0x40
405
406 /*****************************************************************************
407 *
408 * SCSI command
409 *
410 *****************************************************************************
411 */
412
413 /** An SRP SCSI command */
414 struct srp_cmd {
415 /** Information unit type
416 *
417 * This must be @c SRP_CMD
418 */
419 uint8_t type;
420 /** Flags
421 *
422 * This is the bitwise OR of zero or more @c SRP_CMD_FLAG_XXX
423 * constants.
424 */
425 uint8_t flags;
426 /** Reserved */
427 uint8_t reserved0[3];
428 /** Data buffer descriptor formats
429 *
430 * This is the bitwise OR of one @c SRP_CMD_DO_FMT_XXX and one @c
431 * SRP_CMD_DI_FMT_XXX constant.
432 */
433 uint8_t data_buffer_formats;
434 /** Data-out buffer descriptor count */
435 uint8_t data_out_buffer_count;
436 /** Data-in buffer descriptor count */
437 uint8_t data_in_buffer_count;
438 /** Tag */
439 union srp_tag tag;
440 /** Reserved */
441 uint8_t reserved1[4];
442 /** Logical unit number */
443 struct scsi_lun lun;
444 /** Reserved */
445 uint8_t reserved2[1];
446 /** Task attribute
447 *
448 * This is a @c SRP_CMD_TASK_ATTR_XXX constant.
449 */
450 uint8_t task_attr;
451 /** Reserved */
452 uint8_t reserved3[1];
453 /** Additional CDB length */
454 uint8_t additional_cdb_len;
455 /** Command data block */
456 union scsi_cdb cdb;
457 } __attribute__ (( packed ));
458
459 /** Type of an SRP SCSI command */
460 #define SRP_CMD 0x02
461
462 /** Use solicited notification for unsuccessful completions */
463 #define SRP_CMD_FLAG_UCSOLNT 0x04
464
465 /** Use solicited notification for successful completions */
466 #define SRP_CMD_FLAG_SCSOLNT 0x02
467
468 /** Data-out buffer format mask */
469 #define SRP_CMD_DO_FMT_MASK 0xf0
470
471 /** Direct data-out buffer format */
472 #define SRP_CMD_DO_FMT_DIRECT 0x10
473
474 /** Indirect data-out buffer format */
475 #define SRP_CMD_DO_FMT_INDIRECT 0x20
476
477 /** Data-in buffer format mask */
478 #define SRP_CMD_DI_FMT_MASK 0x0f
479
480 /** Direct data-in buffer format */
481 #define SRP_CMD_DI_FMT_DIRECT 0x01
482
483 /** Indirect data-in buffer format */
484 #define SRP_CMD_DI_FMT_INDIRECT 0x02
485
486 /** Use the rules for a simple task attribute */
487 #define SRP_CMD_TASK_ATTR_SIMPLE 0x00
488
489 /** Use the rules for a head of queue task attribute */
490 #define SRP_CMD_TASK_ATTR_QUEUE_HEAD 0x01
491
492 /** Use the rules for an ordered task attribute */
493 #define SRP_CMD_TASK_ATTR_ORDERED 0x02
494
495 /** Use the rules for an automatic contingent allegiance task attribute */
496 #define SRP_CMD_TASK_ATTR_AUTOMATIC_CONTINGENT_ALLEGIANCE 0x08
497
498 /** An SRP memory descriptor */
499 struct srp_memory_descriptor {
500 /** Virtual address */
501 uint64_t address;
502 /** Memory handle */
503 uint32_t handle;
504 /** Data length */
505 uint32_t len;
506 } __attribute__ (( packed ));
507
508 /*****************************************************************************
509 *
510 * SCSI response
511 *
512 *****************************************************************************
513 */
514
515 /** An SRP SCSI response */
516 struct srp_rsp {
517 /** Information unit type
518 *
519 * This must be @c SRP_RSP
520 */
521 uint8_t type;
522 /** Flags
523 *
524 * This is the bitwise OR of zero or more @c SRP_RSP_FLAG_XXX
525 * constants.
526 */
527 uint8_t flags;
528 /** Reserved */
529 uint8_t reserved0[2];
530 /** Request limit delta */
531 uint32_t request_limit_delta;
532 /** Tag */
533 union srp_tag tag;
534 /** Reserved */
535 uint8_t reserved1[2];
536 /** Valid fields
537 *
538 * This is the bitwise OR of zero or more @c SRP_RSP_VALID_XXX
539 * constants.
540 */
541 uint8_t valid;
542 /** Status
543 *
544 * This is the SCSI status code.
545 */
546 uint8_t status;
547 /** Data-out residual count */
548 uint32_t data_out_residual_count;
549 /** Data-in residual count */
550 uint32_t data_in_residual_count;
551 /** Sense data list length */
552 uint32_t sense_data_len;
553 /** Response data list length */
554 uint32_t response_data_len;
555 } __attribute__ (( packed ));
556
557 /** Type of an SRP SCSI response */
558 #define SRP_RSP 0xc1
559
560 /** The initiator specified solicited notification of this response */
561 #define SRP_RSP_FLAG_SOLNT 0x01
562
563 /** Data-in residual count field is valid and represents an underflow */
564 #define SRP_RSP_VALID_DIUNDER 0x20
565
566 /** Data-in residual count field is valid and represents an overflow */
567 #define SRP_RSP_VALID_DIOVER 0x10
568
569 /** Data-out residual count field is valid and represents an underflow */
570 #define SRP_RSP_VALID_DOUNDER 0x08
571
572 /** Data-out residual count field is valid and represents an overflow */
573 #define SRP_RSP_VALID_DOOVER 0x04
574
575 /** Sense data list length field is valid */
576 #define SRP_RSP_VALID_SNSVALID 0x02
577
578 /** Response data list length field is valid */
579 #define SRP_RSP_VALID_RSPVALID 0x01
580
581 /**
582 * Get response data portion of SCSI response
583 *
584 * @v rsp SCSI response
585 * @ret response_data Response data, or NULL if not present
586 */
srp_rsp_response_data(const struct srp_rsp * rsp)587 static inline const void * srp_rsp_response_data ( const struct srp_rsp *rsp ) {
588 return ( ( rsp->valid & SRP_RSP_VALID_RSPVALID ) ?
589 ( ( ( const void * ) rsp ) + sizeof ( *rsp ) ) : NULL );
590 }
591
592 /**
593 * Get length of response data portion of SCSI response
594 *
595 * @v rsp SCSI response
596 * @ret response_data_len Response data length
597 */
srp_rsp_response_data_len(const struct srp_rsp * rsp)598 static inline size_t srp_rsp_response_data_len ( const struct srp_rsp *rsp ) {
599 return ( ( rsp->valid & SRP_RSP_VALID_RSPVALID ) ?
600 ntohl ( rsp->response_data_len ) : 0 );
601 }
602
603 /**
604 * Get sense data portion of SCSI response
605 *
606 * @v rsp SCSI response
607 * @ret sense_data Sense data, or NULL if not present
608 */
srp_rsp_sense_data(const struct srp_rsp * rsp)609 static inline const void * srp_rsp_sense_data ( const struct srp_rsp *rsp ) {
610 return ( ( rsp->valid & SRP_RSP_VALID_SNSVALID ) ?
611 ( ( ( const void * ) rsp ) + sizeof ( *rsp ) +
612 srp_rsp_response_data_len ( rsp ) ) : NULL );
613 }
614
615 /**
616 * Get length of sense data portion of SCSI response
617 *
618 * @v rsp SCSI response
619 * @ret sense_data_len Sense data length
620 */
srp_rsp_sense_data_len(const struct srp_rsp * rsp)621 static inline size_t srp_rsp_sense_data_len ( const struct srp_rsp *rsp ) {
622 return ( ( rsp->valid & SRP_RSP_VALID_SNSVALID ) ?
623 ntohl ( rsp->sense_data_len ) : 0 );
624 }
625
626 /*****************************************************************************
627 *
628 * Credit request
629 *
630 *****************************************************************************
631 */
632
633 /** An SRP credit request */
634 struct srp_cred_req {
635 /** Information unit type
636 *
637 * This must be @c SRP_CRED_REQ
638 */
639 uint8_t type;
640 /** Flags
641 *
642 * This is the bitwise OR of zero or more
643 * @c SRP_CRED_REQ_FLAG_XXX constants.
644 */
645 uint8_t flags;
646 /** Reserved */
647 uint8_t reserved0[2];
648 /** Request limit delta */
649 uint32_t request_limit_delta;
650 /** Tag */
651 union srp_tag tag;
652 } __attribute__ (( packed ));
653
654 /** Type of an SRP credit request */
655 #define SRP_CRED_REQ 0x81
656
657 /** The initiator specified solicited notification of credit requests */
658 #define SRP_CRED_REQ_FLAG_SOLNT 0x01
659
660 /*****************************************************************************
661 *
662 * Credit response
663 *
664 *****************************************************************************
665 */
666
667 /** An SRP credit response */
668 struct srp_cred_rsp {
669 /** Information unit type
670 *
671 * This must be @c SRP_CRED_RSP
672 */
673 uint8_t type;
674 /** Reserved */
675 uint8_t reserved0[7];
676 /** Tag */
677 union srp_tag tag;
678 } __attribute__ (( packed ));
679
680 /** Type of an SRP credit response */
681 #define SRP_CRED_RSP 0x41
682
683 /*****************************************************************************
684 *
685 * Asynchronous event request
686 *
687 *****************************************************************************
688 */
689
690 /** An SRP asynchronous event request */
691 struct srp_aer_req {
692 /** Information unit type
693 *
694 * This must be @c SRP_AER_REQ
695 */
696 uint8_t type;
697 /** Flags
698 *
699 * This is the bitwise OR of zero or more @c
700 * SRP_AER_REQ_FLAG_XXX constants.
701 */
702 uint8_t flags;
703 /** Reserved */
704 uint8_t reserved0[2];
705 /** Request limit delta */
706 uint32_t request_limit_delta;
707 /** Tag */
708 union srp_tag tag;
709 /** Reserved */
710 uint8_t reserved1[4];
711 /** Logical unit number */
712 struct scsi_lun lun;
713 /** Sense data list length */
714 uint32_t sense_data_len;
715 /** Reserved */
716 uint8_t reserved2[4];
717 } __attribute__ (( packed ));
718
719 /** Type of an SRP asynchronous event request */
720 #define SRP_AER_REQ 0x82
721
722 /** The initiator specified solicited notification of asynchronous events */
723 #define SRP_AER_REQ_FLAG_SOLNT 0x01
724
725 /**
726 * Get sense data portion of asynchronous event request
727 *
728 * @v aer_req SRP asynchronous event request
729 * @ret sense_data Sense data
730 */
731 static inline __always_inline void *
srp_aer_req_sense_data(struct srp_aer_req * aer_req)732 srp_aer_req_sense_data ( struct srp_aer_req *aer_req ) {
733 return ( ( ( void * ) aer_req ) + sizeof ( *aer_req ) );
734 }
735
736 /**
737 * Get length of sense data portion of asynchronous event request
738 *
739 * @v aer_req SRP asynchronous event request
740 * @ret sense_data_len Sense data length
741 */
742 static inline __always_inline size_t
srp_aer_req_sense_data_len(struct srp_aer_req * aer_req)743 srp_aer_req_sense_data_len ( struct srp_aer_req *aer_req ) {
744 return ( ntohl ( aer_req->sense_data_len ) );
745 }
746
747 /*****************************************************************************
748 *
749 * Asynchronous event response
750 *
751 *****************************************************************************
752 */
753
754 /** An SRP asynchronous event response */
755 struct srp_aer_rsp {
756 /** Information unit type
757 *
758 * This must be @c SRP_AER_RSP
759 */
760 uint8_t type;
761 /** Reserved */
762 uint8_t reserved0[7];
763 /** Tag */
764 union srp_tag tag;
765 } __attribute__ (( packed ));
766
767 /** Type of an SRP asynchronous event response */
768 #define SRP_AER_RSP 0x42
769
770 /*****************************************************************************
771 *
772 * SRP boot firmware table
773 *
774 * The working draft specification for the SRP boot firmware table can
775 * be found at
776 *
777 * http://ipxe.org/wiki/srp/sbft
778 *
779 *****************************************************************************
780 */
781
782 /** SRP Boot Firmware Table signature */
783 #define SBFT_SIG ACPI_SIGNATURE ( 's', 'B', 'F', 'T' )
784
785 /** An offset from the start of the sBFT */
786 typedef uint16_t sbft_off_t;
787
788 /**
789 * SRP Boot Firmware Table
790 */
791 struct sbft_table {
792 /** ACPI header */
793 struct acpi_header acpi;
794 /** Offset to SCSI subtable */
795 sbft_off_t scsi_offset;
796 /** Offset to SRP subtable */
797 sbft_off_t srp_offset;
798 /** Offset to IB subtable, if present */
799 sbft_off_t ib_offset;
800 /** Reserved */
801 uint8_t reserved[6];
802 } __attribute__ (( packed ));
803
804 /**
805 * sBFT SCSI subtable
806 */
807 struct sbft_scsi_subtable {
808 /** LUN */
809 struct scsi_lun lun;
810 } __attribute__ (( packed ));
811
812 /**
813 * sBFT SRP subtable
814 */
815 struct sbft_srp_subtable {
816 /** Initiator port identifier */
817 union srp_port_id initiator;
818 /** Target port identifier */
819 union srp_port_id target;
820 } __attribute__ (( packed ));
821
822 /*****************************************************************************
823 *
824 * SRP devices
825 *
826 *****************************************************************************
827 */
828
829 extern int srp_open ( struct interface *block, struct interface *socket,
830 union srp_port_id *initiator, union srp_port_id *target,
831 uint32_t memory_handle, struct scsi_lun *lun );
832
833 #endif /* _IPXE_SRP_H */
834