IScsiDriver.h@ 69222

Last change on this file since 69222 was 58466, checked in by vboxsync, 9 years ago
EFI/Firmware: Merged in the svn:eol-style, svn:mime-type and trailing whitespace cleanup that was done after the initial UDK2014.SP1 import: svn merge ^{/vendor/edk2/UDK2014.SP1}/vendor/edk2/current .
Property svn:eol-style set to `native`
File size: 40.1 KB

Line
1	/** @file
2	The header file of IScsiDriver.c.
3
4	Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>
5	This program and the accompanying materials
6	are licensed and made available under the terms and conditions of the BSD License
7	which accompanies this distribution. The full text of the license may be found at
8	http://opensource.org/licenses/bsd-license.php
9
10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13	**/
14
15	#ifndef _ISCSI_DRIVER_H_
16	#define _ISCSI_DRIVER_H_
17
18	#define ISCSI_V4_PRIVATE_GUID \
19	{ \
20	0xfa3cde4c, 0x87c2, 0x427d, { 0xae, 0xde, 0x7d, 0xd0, 0x96, 0xc8, 0x8c, 0x58 } \
21	}
22
23	#define ISCSI_V6_PRIVATE_GUID \
24	{ \
25	0x28be27e5, 0x66cc, 0x4a31, { 0xa3, 0x15, 0xdb, 0x14, 0xc3, 0x74, 0x4d, 0x85 } \
26	}
27
28	#define ISCSI_INITIATOR_NAME_VAR_NAME L"I_NAME"
29
30	#define IP_MODE_AUTOCONFIG_IP4 3
31	#define IP_MODE_AUTOCONFIG_IP6 4
32	#define IP_MODE_AUTOCONFIG_SUCCESS 5
33
34	extern EFI_COMPONENT_NAME2_PROTOCOL gIScsiComponentName2;
35	extern EFI_COMPONENT_NAME_PROTOCOL gIScsiComponentName;
36	extern EFI_UNICODE_STRING_TABLE *gIScsiControllerNameTable;
37	extern EFI_ISCSI_INITIATOR_NAME_PROTOCOL gIScsiInitiatorName;
38	extern EFI_AUTHENTICATION_INFO_PROTOCOL gIScsiAuthenticationInfo;
39	extern EFI_EXT_SCSI_PASS_THRU_PROTOCOL gIScsiExtScsiPassThruProtocolTemplate;
40	extern EFI_GUID gIScsiV4PrivateGuid;
41	extern EFI_GUID gIScsiV6PrivateGuid;
42
43	typedef struct {
44	CHAR16 PortString[ISCSI_NAME_IFR_MAX_SIZE];
45	LIST_ENTRY NicInfoList;
46	UINT8 NicCount;
47	UINT8 CurrentNic;
48	UINT8 MaxNic;
49	BOOLEAN Ipv6Flag;
50	BOOLEAN OneSessionEstablished;
51	BOOLEAN EnableMpio;
52	UINT8 MpioCount; // The number of attempts in MPIO.
53	UINT8 Krb5MpioCount; // The number of attempts login with KRB5 in MPIO.
54	UINT8 SinglePathCount; // The number of single path attempts.
55	UINT8 ValidSinglePathCount; // The number of valid single path attempts.
56	UINT8 BootSelectedIndex;
57	UINT8 AttemptCount;
58	LIST_ENTRY AttemptConfigs; // User configured Attempt list.
59	CHAR8 InitiatorName[ISCSI_NAME_MAX_SIZE];
60	UINTN InitiatorNameLength;
61	VOID *NewAttempt; // Attempt is created but not saved.
62	} ISCSI_PRIVATE_DATA;
63
64	extern ISCSI_PRIVATE_DATA *mPrivate;
65
66	typedef struct {
67	LIST_ENTRY Link;
68	UINT32 HwAddressSize;
69	EFI_MAC_ADDRESS PermanentAddress;
70	UINT8 NicIndex;
71	UINT16 VlanId;
72	UINTN BusNumber;
73	UINTN DeviceNumber;
74	UINTN FunctionNumber;
75	} ISCSI_NIC_INFO;
76
77	typedef struct _ISCSI_PRIVATE_PROTOCOL {
78	UINT32 Reserved;
79	} ISCSI_PRIVATE_PROTOCOL;
80
81	//
82	// EFI Driver Binding Protocol for iSCSI driver.
83	//
84
85	/**
86	Tests to see if this driver supports a given controller. If a child device is provided,
87	it tests to see if this driver supports creating a handle for the specified child device.
88
89	This function checks to see if the driver specified by This supports the device specified by
90	ControllerHandle. Drivers typically use the device path attached to
91	ControllerHandle and/or the services from the bus I/O abstraction attached to
92	ControllerHandle to determine if the driver supports ControllerHandle. This function
93	may be called many times during platform initialization. In order to reduce boot times, the tests
94	performed by this function must be very small and take as little time as possible to execute. This
95	function must not change the state of any hardware devices, and this function must be aware that the
96	device specified by ControllerHandle may already be managed by the same driver or a
97	different driver. This function must match its calls to AllocatePages() with FreePages(),
98	AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
99	Since ControllerHandle may have been previously started by the same driver, if a protocol is
100	already in the opened state, then it must not be closed with CloseProtocol(). This is required
101	to guarantee the state of ControllerHandle is not modified by this function.
102
103	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
104	@param[in] ControllerHandle The handle of the controller to test. This handle
105	must support a protocol interface that supplies
106	an I/O abstraction to the driver.
107	@param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
108	parameter is ignored by device drivers, and is optional for bus
109	drivers. For bus drivers, if this parameter is not NULL, then
110	the bus driver must determine if the bus controller specified
111	by ControllerHandle and the child controller specified
112	by RemainingDevicePath are both supported by this
113	bus driver.
114
115	@retval EFI_SUCCESS The device specified by ControllerHandle and
116	RemainingDevicePath is supported by the driver specified by This.
117	@retval EFI_ALREADY_STARTED The device specified by ControllerHandle and
118	RemainingDevicePath is already managed by the driver
119	specified by This.
120	@retval EFI_ACCESS_DENIED The device specified by ControllerHandle and
121	RemainingDevicePath is already managed by a different
122	driver or an application that requires exclusive access.
123	Currently not implemented.
124	@retval EFI_UNSUPPORTED The device specified by ControllerHandle and
125	RemainingDevicePath is not supported by the driver specified by This.
126	**/
127	EFI_STATUS
128	EFIAPI
129	IScsiIp4DriverBindingSupported (
130	IN EFI_DRIVER_BINDING_PROTOCOL *This,
131	IN EFI_HANDLE ControllerHandle,
132	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
133	);
134
135	/**
136	Starts a device controller or a bus controller.
137
138	The Start() function is designed to be invoked from the EFI boot service ConnectController().
139	As a result, much of the error checking on the parameters to Start() has been moved into this
140	common boot service. It is legal to call Start() from other locations,
141	but the following calling restrictions must be followed or the system behavior will not be deterministic.
142	1. ControllerHandle must be a valid EFI_HANDLE.
143	2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
144	EFI_DEVICE_PATH_PROTOCOL.
145	3. Prior to calling Start(), the Supported() function for the driver specified by This must
146	have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
147
148	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
149	@param[in] ControllerHandle The handle of the controller to start. This handle
150	must support a protocol interface that supplies
151	an I/O abstraction to the driver.
152	@param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
153	parameter is ignored by device drivers, and is optional for bus
154	drivers. For a bus driver, if this parameter is NULL, then handles
155	for all the children of Controller are created by this driver.
156	If this parameter is not NULL and the first Device Path Node is
157	not the End of Device Path Node, then only the handle for the
158	child device specified by the first Device Path Node of
159	RemainingDevicePath is created by this driver.
160	If the first Device Path Node of RemainingDevicePath is
161	the End of Device Path Node, no child handle is created by this
162	driver.
163
164	@retval EFI_SUCCESS The device was started.
165	@retval EFI_DEVICE_ERROR The device could not be started due to a device error. Currently not implemented.
166	@retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
167	@retval Others The driver failed to start the device.
168
169	**/
170	EFI_STATUS
171	EFIAPI
172	IScsiIp4DriverBindingStart (
173	IN EFI_DRIVER_BINDING_PROTOCOL *This,
174	IN EFI_HANDLE ControllerHandle,
175	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
176	);
177
178	/**
179	Stops a device controller or a bus controller.
180
181	The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
182	As a result, much of the error checking on the parameters to Stop() has been moved
183	into this common boot service. It is legal to call Stop() from other locations,
184	but the following calling restrictions must be followed or the system behavior will not be deterministic.
185	1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
186	same driver's Start() function.
187	2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
188	EFI_HANDLE. In addition, all of these handles must have been created in this driver's
189	Start() function, and the Start() function must have called OpenProtocol() on
190	ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
191
192	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
193	@param[in] ControllerHandle A handle to the device being stopped. The handle must
194	support a bus specific I/O protocol for the driver
195	to use to stop the device.
196	@param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer.
197	@param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
198	if NumberOfChildren is 0.
199
200	@retval EFI_SUCCESS The device was stopped.
201	@retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
202
203	**/
204	EFI_STATUS
205	EFIAPI
206	IScsiIp4DriverBindingStop (
207	IN EFI_DRIVER_BINDING_PROTOCOL *This,
208	IN EFI_HANDLE ControllerHandle,
209	IN UINTN NumberOfChildren,
210	IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
211	);
212
213	/**
214	Tests to see if this driver supports a given controller. If a child device is provided,
215	it tests to see if this driver supports creating a handle for the specified child device.
216
217	This function checks to see if the driver specified by This supports the device specified by
218	ControllerHandle. Drivers typically use the device path attached to
219	ControllerHandle and/or the services from the bus I/O abstraction attached to
220	ControllerHandle to determine if the driver supports ControllerHandle. This function
221	may be called many times during platform initialization. In order to reduce boot times, the tests
222	performed by this function must be very small and take as little time as possible to execute. This
223	function must not change the state of any hardware devices, and this function must be aware that the
224	device specified by ControllerHandle may already be managed by the same driver or a
225	different driver. This function must match its calls to AllocatePages() with FreePages(),
226	AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
227	Since ControllerHandle may have been previously started by the same driver, if a protocol is
228	already in the opened state, then it must not be closed with CloseProtocol(). This is required
229	to guarantee the state of ControllerHandle is not modified by this function.
230
231	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
232	@param[in] ControllerHandle The handle of the controller to test. This handle
233	must support a protocol interface that supplies
234	an I/O abstraction to the driver.
235	@param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
236	parameter is ignored by device drivers, and is optional for bus
237	drivers. For bus drivers, if this parameter is not NULL, then
238	the bus driver must determine if the bus controller specified
239	by ControllerHandle and the child controller specified
240	by RemainingDevicePath are both supported by this
241	bus driver.
242
243	@retval EFI_SUCCESS The device specified by ControllerHandle and
244	RemainingDevicePath is supported by the driver specified by This.
245	@retval EFI_ALREADY_STARTED The device specified by ControllerHandle and
246	RemainingDevicePath is already managed by the driver
247	specified by This.
248	@retval EFI_ACCESS_DENIED The device specified by ControllerHandle and
249	RemainingDevicePath is already managed by a different
250	driver or an application that requires exclusive access.
251	Currently not implemented.
252	@retval EFI_UNSUPPORTED The device specified by ControllerHandle and
253	RemainingDevicePath is not supported by the driver specified by This.
254	**/
255	EFI_STATUS
256	EFIAPI
257	IScsiIp6DriverBindingSupported (
258	IN EFI_DRIVER_BINDING_PROTOCOL *This,
259	IN EFI_HANDLE ControllerHandle,
260	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
261	);
262
263	/**
264	Starts a device controller or a bus controller.
265
266	The Start() function is designed to be invoked from the EFI boot service ConnectController().
267	As a result, much of the error checking on the parameters to Start() has been moved into this
268	common boot service. It is legal to call Start() from other locations,
269	but the following calling restrictions must be followed or the system behavior will not be deterministic.
270	1. ControllerHandle must be a valid EFI_HANDLE.
271	2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
272	EFI_DEVICE_PATH_PROTOCOL.
273	3. Prior to calling Start(), the Supported() function for the driver specified by This must
274	have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
275
276	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
277	@param[in] ControllerHandle The handle of the controller to start. This handle
278	must support a protocol interface that supplies
279	an I/O abstraction to the driver.
280	@param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
281	parameter is ignored by device drivers, and is optional for bus
282	drivers. For a bus driver, if this parameter is NULL, then handles
283	for all the children of Controller are created by this driver.
284	If this parameter is not NULL and the first Device Path Node is
285	not the End of Device Path Node, then only the handle for the
286	child device specified by the first Device Path Node of
287	RemainingDevicePath is created by this driver.
288	If the first Device Path Node of RemainingDevicePath is
289	the End of Device Path Node, no child handle is created by this
290	driver.
291
292	@retval EFI_SUCCESS The device was started.
293	@retval EFI_DEVICE_ERROR The device could not be started due to a device error. Currently not implemented.
294	@retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
295	@retval Others The driver failed to start the device.
296
297	**/
298	EFI_STATUS
299	EFIAPI
300	IScsiIp6DriverBindingStart (
301	IN EFI_DRIVER_BINDING_PROTOCOL *This,
302	IN EFI_HANDLE ControllerHandle,
303	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
304	);
305
306	/**
307	Stops a device controller or a bus controller.
308
309	The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
310	As a result, much of the error checking on the parameters to Stop() has been moved
311	into this common boot service. It is legal to call Stop() from other locations,
312	but the following calling restrictions must be followed or the system behavior will not be deterministic.
313	1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
314	same driver's Start() function.
315	2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
316	EFI_HANDLE. In addition, all of these handles must have been created in this driver's
317	Start() function, and the Start() function must have called OpenProtocol() on
318	ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
319
320	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
321	@param[in] ControllerHandle A handle to the device being stopped. The handle must
322	support a bus specific I/O protocol for the driver
323	to use to stop the device.
324	@param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer.
325	@param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
326	if NumberOfChildren is 0.
327
328	@retval EFI_SUCCESS The device was stopped.
329	@retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
330
331	**/
332	EFI_STATUS
333	EFIAPI
334	IScsiIp6DriverBindingStop (
335	IN EFI_DRIVER_BINDING_PROTOCOL *This,
336	IN EFI_HANDLE ControllerHandle,
337	IN UINTN NumberOfChildren,
338	IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
339	);
340
341	//
342	// EFI Component Name(2) Protocol for iSCSI driver.
343	//
344
345	/**
346	Retrieves a Unicode string that is the user readable name of the driver.
347
348	This function retrieves the user readable name of a driver in the form of a
349	Unicode string. If the driver specified by This has a user readable name in
350	the language specified by Language, then a pointer to the driver name is
351	returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
352	by This does not support the language specified by Language,
353	then EFI_UNSUPPORTED is returned.
354
355	@param[in] This A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
356	EFI_COMPONENT_NAME_PROTOCOL instance.
357
358	@param[in] Language A pointer to a Null-terminated ASCII string
359	array indicating the language. This is the
360	language of the driver name that the caller is
361	requesting, and it must match one of the
362	languages specified in SupportedLanguages. The
363	number of languages supported by a driver is up
364	to the driver writer. Language is specified
365	in RFC 4646 or ISO 639-2 language code format.
366
367	@param[out] DriverName A pointer to the Unicode string to return.
368	This Unicode string is the name of the
369	driver specified by This in the language
370	specified by Language.
371
372	@retval EFI_SUCCESS The Unicode string for the Driver specified by
373	This and the language specified by Language was
374	returned in DriverName.
375
376	@retval EFI_INVALID_PARAMETER Language is NULL.
377
378	@retval EFI_INVALID_PARAMETER DriverName is NULL.
379
380	@retval EFI_UNSUPPORTED The driver specified by This does not support
381	the language specified by Language.
382
383	**/
384	EFI_STATUS
385	EFIAPI
386	IScsiComponentNameGetDriverName (
387	IN EFI_COMPONENT_NAME_PROTOCOL *This,
388	IN CHAR8 *Language,
389	OUT CHAR16 **DriverName
390	);
391
392	/**
393	Retrieves a Unicode string that is the user readable name of the controller
394	that is being managed by a driver.
395
396	This function retrieves the user readable name of the controller specified by
397	ControllerHandle and ChildHandle in the form of a Unicode string. If the
398	driver specified by This has a user readable name in the language specified by
399	Language, then a pointer to the controller name is returned in ControllerName,
400	and EFI_SUCCESS is returned. If the driver specified by This is not currently
401	managing the controller specified by ControllerHandle and ChildHandle,
402	then EFI_UNSUPPORTED is returned. If the driver specified by This does not
403	support the language specified by Language, then EFI_UNSUPPORTED is returned.
404
405	@param[in] This A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
406	EFI_COMPONENT_NAME_PROTOCOL instance.
407
408	@param[in] ControllerHandle The handle of a controller that the driver
409	specified by This is managing. This handle
410	specifies the controller whose name is to be
411	returned.
412
413	@param[in] ChildHandle The handle of the child controller to retrieve
414	the name of. This is an optional parameter that
415	may be NULL. It will be NULL for device
416	drivers. It will also be NULL for a bus drivers
417	that wish to retrieve the name of the bus
418	controller. It will not be NULL for a bus
419	driver that wishes to retrieve the name of a
420	child controller.
421
422	@param[in] Language A pointer to a Null-terminated ASCII string
423	array indicating the language. This is the
424	language of the driver name that the caller is
425	requesting, and it must match one of the
426	languages specified in SupportedLanguages. The
427	number of languages supported by a driver is
428	determined by the driver writer. Language is
429	specified inRFC 4646 or ISO 639-2 language code
430	format.
431
432	@param[out] ControllerName A pointer to the Unicode string to return.
433	This Unicode string is the name of the
434	controller specified by ControllerHandle and
435	ChildHandle in the language specified by
436	Language from the point of view of the driver
437	specified by This.
438
439	@retval EFI_SUCCESS The Unicode string for the user readable name in
440	the language specified by Language for the
441	driver specified by This was returned in
442	DriverName.
443
444	@retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
445
446	@retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
447	EFI_HANDLE.
448
449	@retval EFI_INVALID_PARAMETER Language is NULL.
450
451	@retval EFI_INVALID_PARAMETER ControllerName is NULL.
452
453	@retval EFI_UNSUPPORTED The driver specified by This is not currently
454	managing the controller specified by
455	ControllerHandle and ChildHandle.
456
457	@retval EFI_UNSUPPORTED The driver specified by This does not support
458	the language specified by Language.
459
460	**/
461	EFI_STATUS
462	EFIAPI
463	IScsiComponentNameGetControllerName (
464	IN EFI_COMPONENT_NAME_PROTOCOL *This,
465	IN EFI_HANDLE ControllerHandle,
466	IN EFI_HANDLE ChildHandle OPTIONAL,
467	IN CHAR8 *Language,
468	OUT CHAR16 **ControllerName
469	);
470
471	//
472	// EFI iSCSI Initiator Name Protocol for iSCSI driver.
473	//
474
475	/**
476	Retrieves the current set value of iSCSI Initiator Name.
477
478	@param[in] This Pointer to the EFI_ISCSI_INITIATOR_NAME_PROTOCOL
479	instance.
480	@param[in, out] BufferSize Size of the buffer in bytes pointed to by Buffer /
481	Actual size of the variable data buffer.
482	@param[out] Buffer Pointer to the buffer for data to be read.
483
484	@retval EFI_SUCCESS Data was successfully retrieved into the provided
485	buffer and the BufferSize was sufficient to handle
486	the iSCSI initiator name.
487	@retval EFI_BUFFER_TOO_SMALL BufferSize is too small for the result. BufferSize
488	will be updated with the size required to complete
489	the request. Buffer will not be affected.
490	@retval EFI_INVALID_PARAMETER BufferSize is NULL. BufferSize and Buffer will not
491	be affected.
492	@retval EFI_INVALID_PARAMETER Buffer is NULL. BufferSize and Buffer will not be
493	affected.
494	@retval EFI_DEVICE_ERROR The iSCSI initiator name could not be retrieved
495	due to a hardware error.
496
497	**/
498	EFI_STATUS
499	EFIAPI
500	IScsiGetInitiatorName (
501	IN EFI_ISCSI_INITIATOR_NAME_PROTOCOL *This,
502	IN OUT UINTN *BufferSize,
503	OUT VOID *Buffer
504	);
505
506	/**
507	Sets the iSSI Initiator Name.
508
509	@param[in] This Pointer to the EFI_ISCSI_INITIATOR_NAME_PROTOCOL
510	instance.
511	@param[in, out] BufferSize Size of the buffer in bytes pointed to by Buffer.
512	@param[in] Buffer Pointer to the buffer for data to be written.
513
514	@retval EFI_SUCCESS Data was successfully stored by the protocol.
515	@retval EFI_UNSUPPORTED Platform policies do not allow for data to be
516	written.
517	@retval EFI_INVALID_PARAMETER BufferSize exceeds the maximum allowed limit.
518	BufferSize will be updated with the maximum size
519	required to complete the request.
520	@retval EFI_INVALID_PARAMETER Buffersize is NULL. BufferSize and Buffer will not
521	be affected.
522	@retval EFI_INVALID_PARAMETER Buffer is NULL. BufferSize and Buffer will not be
523	affected.
524	@retval EFI_DEVICE_ERROR The data could not be stored due to a hardware
525	error.
526	@retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the data
527	@retval EFI_PROTOCOL_ERROR Input iSCSI initiator name does not adhere to RFC
528	3720
529
530	**/
531	EFI_STATUS
532	EFIAPI
533	IScsiSetInitiatorName (
534	IN EFI_ISCSI_INITIATOR_NAME_PROTOCOL *This,
535	IN OUT UINTN *BufferSize,
536	IN VOID *Buffer
537	);
538
539	//
540	// EFI_AUTHENTICATION_INFO_PROTOCOL for iSCSI driver.
541	//
542
543	/**
544	Retrieves the authentication information associated with a particular controller handle.
545
546	@param[in] This Pointer to the EFI_AUTHENTICATION_INFO_PROTOCOL.
547	@param[in] ControllerHandle Handle to the Controller.
548	@param[out] Buffer Pointer to the authentication information. This function is
549	responsible for allocating the buffer and it is the caller's
550	responsibility to free buffer when the caller is finished with buffer.
551
552	@retval EFI_DEVICE_ERROR The authentication information could not be
553	retrieved due to a hardware error.
554
555	**/
556	EFI_STATUS
557	EFIAPI
558	IScsiGetAuthenticationInfo (
559	IN EFI_AUTHENTICATION_INFO_PROTOCOL *This,
560	IN EFI_HANDLE ControllerHandle,
561	OUT VOID **Buffer
562	);
563
564	/**
565	Set the authentication information for a given controller handle.
566
567	@param[in] This Pointer to the EFI_AUTHENTICATION_INFO_PROTOCOL.
568	@param[in] ControllerHandle Handle to the Controller.
569	@param[in] Buffer Pointer to the authentication information.
570
571	@retval EFI_UNSUPPORTED If the platform policies do not allow setting of
572	the authentication information.
573
574	**/
575	EFI_STATUS
576	EFIAPI
577	IScsiSetAuthenticationInfo (
578	IN EFI_AUTHENTICATION_INFO_PROTOCOL *This,
579	IN EFI_HANDLE ControllerHandle,
580	IN VOID *Buffer
581	);
582
583	//
584	// EFI_EXT_SCSI_PASS_THRU_PROTOCOL for iSCSI driver.
585	//
586
587	/**
588	Sends a SCSI Request Packet to a SCSI device that is attached to the SCSI channel.
589	This function supports both blocking I/O and nonblocking I/O. The blocking I/O
590	functionality is required, and the nonblocking I/O functionality is optional.
591
592	@param[in] This A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
593	@param[in] Target The Target is an array of size TARGET_MAX_BYTES and it
594	represents the id of the SCSI device to send the SCSI
595	Request Packet. Each transport driver may choose to
596	utilize a subset of this size to suit the needs
597	of transport target representation. For example, a
598	Fibre Channel driver may use only 8 bytes (WWN)
599	to represent an FC target.
600	@param[in] Lun The LUN of the SCSI device to send the SCSI Request Packet.
601	@param[in, out] Packet A pointer to the SCSI Request Packet to send to the
602	SCSI device specified by Target and Lun.
603	@param[in] Event If nonblocking I/O is not supported then Event is ignored,
604	and blocking I/O is performed. If Event is NULL, then
605	blocking I/O is performed. If Event is not NULL and non
606	blocking I/O is supported, then nonblocking I/O is performed,
607	and Event will be signaled when the SCSI Request Packet
608	completes.
609
610	@retval EFI_SUCCESS The SCSI Request Packet was sent by the host. For
611	bi-directional commands, InTransferLength bytes
612	were transferred from InDataBuffer.
613	For write and bi-directional commands, OutTransferLength
614	bytes were transferred by OutDataBuffer.
615	@retval EFI_BAD_BUFFER_SIZE The SCSI Request Packet was not executed.
616	The number of bytes that could be transferred is
617	returned in InTransferLength. For write and
618	bi-directional commands, OutTransferLength bytes
619	were transferred by OutDataBuffer.
620	@retval EFI_NOT_READY The SCSI Request Packet could not be sent because
621	there are too many SCSI Request Packets already
622	queued. The caller may retry later.
623	@retval EFI_DEVICE_ERROR A device error occurred while attempting to send
624	the SCSI Request Packet.
625	@retval EFI_INVALID_PARAMETER Target, Lun, or the contents of ScsiRequestPacket
626	are invalid.
627	@retval EFI_UNSUPPORTED The command described by the SCSI Request Packet
628	is not supported by the host adapter.
629	This includes the case of Bi-directional SCSI
630	commands not supported by the implementation.
631	The SCSI Request Packet was not sent,
632	so no additional status information is available.
633	@retval EFI_TIMEOUT A timeout occurred while waiting for the SCSI
634	Request Packet to execute.
635
636	**/
637	EFI_STATUS
638	EFIAPI
639	IScsiExtScsiPassThruFunction (
640	IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
641	IN UINT8 *Target,
642	IN UINT64 Lun,
643	IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
644	IN EFI_EVENT Event OPTIONAL
645	);
646
647	/**
648	Used to retrieve the list of legal Target IDs and LUNs for SCSI devices on
649	a SCSI channel. These can either be the list SCSI devices that are actually
650	present on the SCSI channel, or the list of legal Target Ids and LUNs for the
651	SCSI channel. Regardless, the caller of this function must probe the Target ID
652	and LUN returned to see if a SCSI device is actually present at that location
653	on the SCSI channel.
654
655	@param[in] This The EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
656	@param[in, out] Target On input, a pointer to the Target ID of a SCSI
657	device present on the SCSI channel. On output, a
658	pointer to the Target ID of the next SCSI device
659	present on a SCSI channel. An input value of
660	0xFFFFFFFF retrieves the Target ID of the first
661	SCSI device present on a SCSI channel.
662	@param[in, out] Lun On input, a pointer to the LUN of a SCSI device
663	present on the SCSI channel. On output, a pointer
664	to the LUN of the next SCSI device present on a
665	SCSI channel.
666
667	@retval EFI_SUCCESS The Target ID and Lun of the next SCSI device on
668	the SCSI channel was returned in Target and Lun.
669	@retval EFI_NOT_FOUND There are no more SCSI devices on this SCSI
670	channel.
671	@retval EFI_INVALID_PARAMETER Target is not 0xFFFFFFFF,and Target and Lun were
672	not returned on a previous call to
673	GetNextDevice().
674
675	**/
676	EFI_STATUS
677	EFIAPI
678	IScsiExtScsiPassThruGetNextTargetLun (
679	IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
680	IN OUT UINT8 **Target,
681	IN OUT UINT64 *Lun
682	);
683
684	/**
685	Allocate and build a device path node for a SCSI device on a SCSI channel.
686
687	@param[in] This Protocol instance pointer.
688	@param[in] Target The Target ID of the SCSI device for which a
689	device path node is to be allocated and built.
690	@param[in] Lun The LUN of the SCSI device for which a device
691	path node is to be allocated and built.
692	@param[in, out] DevicePath A pointer to a single device path node that
693	describes the SCSI device specified by Target and
694	Lun. This function is responsible for allocating
695	the buffer DevicePath with the boot service
696	AllocatePool(). It is the caller's
697	responsibility to free DevicePath when the caller
698	is finished with DevicePath.
699
700	@retval EFI_SUCCESS The device path node that describes the SCSI
701	device specified by Target and Lun was allocated
702	and returned in DevicePath.
703	@retval EFI_NOT_FOUND The SCSI devices specified by Target and Lun does
704	not exist on the SCSI channel.
705	@retval EFI_INVALID_PARAMETER DevicePath is NULL.
706	@retval EFI_OUT_OF_RESOURCES There are not enough resources to allocate
707	DevicePath.
708
709	**/
710	EFI_STATUS
711	EFIAPI
712	IScsiExtScsiPassThruBuildDevicePath (
713	IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
714	IN UINT8 *Target,
715	IN UINT64 Lun,
716	IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath
717	);
718
719	/**
720	Translate a device path node to a Target ID and LUN.
721
722	@param[in] This Protocol instance pointer.
723	@param[in] DevicePath A pointer to the device path node that describes
724	a SCSI device on the SCSI channel.
725	@param[out] Target A pointer to the Target ID of a SCSI device on
726	the SCSI channel.
727	@param[out] Lun A pointer to the LUN of a SCSI device on the SCSI
728	channel.
729
730	@retval EFI_SUCCESS DevicePath was successfully translated to a
731	Target ID and LUN, and they were returned in
732	Target and Lun.
733	@retval EFI_INVALID_PARAMETER DevicePath/Target/Lun is NULL.
734	@retval EFI_UNSUPPORTED This driver does not support the device path node
735	type in DevicePath.
736	@retval EFI_NOT_FOUND A valid translation from DevicePath to a Target
737	ID and LUN does not exist.
738
739	**/
740	EFI_STATUS
741	EFIAPI
742	IScsiExtScsiPassThruGetTargetLun (
743	IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
744	IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
745	OUT UINT8 **Target,
746	OUT UINT64 *Lun
747	);
748
749	/**
750	Resets a SCSI channel.This operation resets all the SCSI devices connected to
751	the SCSI channel.
752
753	@param[in] This Protocol instance pointer.
754
755	@retval EFI_UNSUPPORTED It is not supported.
756
757	**/
758	EFI_STATUS
759	EFIAPI
760	IScsiExtScsiPassThruResetChannel (
761	IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This
762	);
763
764	/**
765	Resets a SCSI device that is connected to a SCSI channel.
766
767	@param[in] This Protocol instance pointer.
768	@param[in] Target The Target ID of the SCSI device to reset.
769	@param[in] Lun The LUN of the SCSI device to reset.
770
771	@retval EFI_UNSUPPORTED It is not supported.
772
773	**/
774	EFI_STATUS
775	EFIAPI
776	IScsiExtScsiPassThruResetTargetLun (
777	IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
778	IN UINT8 *Target,
779	IN UINT64 Lun
780	);
781
782	/**
783	Retrieve the list of legal Target IDs for SCSI devices on a SCSI channel.
784
785	@param[in] This A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL
786	instance.
787	@param[in, out] Target (TARGET_MAX_BYTES) of a SCSI device present on
788	the SCSI channel. On output, a pointer to the
789	Target ID (an array of TARGET_MAX_BYTES) of the
790	next SCSI device present on a SCSI channel.
791	An input value of 0xF(all bytes in the array are 0xF)
792	in the Target array retrieves the Target ID of the
793	first SCSI device present on a SCSI channel.
794
795	@retval EFI_SUCCESS The Target ID of the next SCSI device on the SCSI
796	channel was returned in Target.
797	@retval EFI_INVALID_PARAMETER Target or Lun is NULL.
798	@retval EFI_TIMEOUT Target array is not all 0xF, and Target was not
799	returned on a previous call to GetNextTarget().
800	@retval EFI_NOT_FOUND There are no more SCSI devices on this SCSI channel.
801
802	**/
803	EFI_STATUS
804	EFIAPI
805	IScsiExtScsiPassThruGetNextTarget (
806	IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
807	IN OUT UINT8 **Target
808	);
809
810	#endif

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/IScsiDxe/IScsiDriver.h@ 69222

Download in other formats: