SataController.c@ 79205

Last change on this file since 79205 was 77662, checked in by vboxsync, 6 years ago
EFI: First step in UDK2018 merge. Does not build yet.
Property svn:eol-style set to `native`
File size: 36.4 KB

Line
1	/** @file
2	This driver module produces IDE_CONTROLLER_INIT protocol for Sata Controllers.
3
4	Copyright (c) 2011, 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	#include "SataController.h"
16
17	///
18	/// EFI_DRIVER_BINDING_PROTOCOL instance
19	///
20	EFI_DRIVER_BINDING_PROTOCOL gSataControllerDriverBinding = {
21	SataControllerSupported,
22	SataControllerStart,
23	SataControllerStop,
24	0xa,
25	NULL,
26	NULL
27	};
28
29	/**
30	Read AHCI Operation register.
31
32	@param PciIo The PCI IO protocol instance.
33	@param Offset The operation register offset.
34
35	@return The register content read.
36
37	**/
38	UINT32
39	EFIAPI
40	AhciReadReg (
41	IN EFI_PCI_IO_PROTOCOL *PciIo,
42	IN UINT32 Offset
43	)
44	{
45	UINT32 Data;
46
47	ASSERT (PciIo != NULL);
48
49	Data = 0;
50
51	PciIo->Mem.Read (
52	PciIo,
53	EfiPciIoWidthUint32,
54	AHCI_BAR_INDEX,
55	(UINT64) Offset,
56	1,
57	&Data
58	);
59
60	return Data;
61	}
62
63	/**
64	Write AHCI Operation register.
65
66	@param PciIo The PCI IO protocol instance.
67	@param Offset The operation register offset.
68	@param Data The data used to write down.
69
70	**/
71	VOID
72	EFIAPI
73	AhciWriteReg (
74	IN EFI_PCI_IO_PROTOCOL *PciIo,
75	IN UINT32 Offset,
76	IN UINT32 Data
77	)
78	{
79	ASSERT (PciIo != NULL);
80
81	PciIo->Mem.Write (
82	PciIo,
83	EfiPciIoWidthUint32,
84	AHCI_BAR_INDEX,
85	(UINT64) Offset,
86	1,
87	&Data
88	);
89
90	return;
91	}
92
93	/**
94	This function is used to calculate the best PIO mode supported by specific IDE device
95
96	@param IdentifyData The identify data of specific IDE device.
97	@param DisPioMode Disqualified PIO modes collection.
98	@param SelectedMode Available PIO modes collection.
99
100	@retval EFI_SUCCESS Best PIO modes are returned.
101	@retval EFI_UNSUPPORTED The device doesn't support PIO mode,
102	or all supported modes have been disqualified.
103	**/
104	EFI_STATUS
105	CalculateBestPioMode (
106	IN EFI_IDENTIFY_DATA *IdentifyData,
107	IN UINT16 *DisPioMode OPTIONAL,
108	OUT UINT16 *SelectedMode
109	)
110	{
111	UINT16 PioMode;
112	UINT16 AdvancedPioMode;
113	UINT16 Temp;
114	UINT16 Index;
115	UINT16 MinimumPioCycleTime;
116
117	Temp = 0xff;
118
119	PioMode = (UINT8) (((ATA5_IDENTIFY_DATA *) (&(IdentifyData->AtaData)))->pio_cycle_timing >> 8);
120
121	//
122	// See whether Identify Data word 64 - 70 are valid
123	//
124	if ((IdentifyData->AtaData.field_validity & 0x02) == 0x02) {
125
126	AdvancedPioMode = IdentifyData->AtaData.advanced_pio_modes;
127	DEBUG ((EFI_D_INFO, "CalculateBestPioMode: AdvancedPioMode = %x\n", AdvancedPioMode));
128
129	for (Index = 0; Index < 8; Index++) {
130	if ((AdvancedPioMode & 0x01) != 0) {
131	Temp = Index;
132	}
133
134	AdvancedPioMode >>= 1;
135	}
136
137	//
138	// If Temp is modified, mean the advanced_pio_modes is not zero;
139	// if Temp is not modified, mean there is no advanced PIO mode supported,
140	// the best PIO Mode is the value in pio_cycle_timing.
141	//
142	if (Temp != 0xff) {
143	AdvancedPioMode = (UINT16) (Temp + 3);
144	} else {
145	AdvancedPioMode = PioMode;
146	}
147
148	//
149	// Limit the PIO mode to at most PIO4.
150	//
151	PioMode = (UINT16) MIN (AdvancedPioMode, 4);
152
153	MinimumPioCycleTime = IdentifyData->AtaData.min_pio_cycle_time_with_flow_control;
154
155	if (MinimumPioCycleTime <= 120) {
156	PioMode = (UINT16) MIN (4, PioMode);
157	} else if (MinimumPioCycleTime <= 180) {
158	PioMode = (UINT16) MIN (3, PioMode);
159	} else if (MinimumPioCycleTime <= 240) {
160	PioMode = (UINT16) MIN (2, PioMode);
161	} else {
162	PioMode = 0;
163	}
164
165	//
166	// Degrade the PIO mode if the mode has been disqualified
167	//
168	if (DisPioMode != NULL) {
169	if (*DisPioMode < 2) {
170	return EFI_UNSUPPORTED; // no mode below ATA_PIO_MODE_BELOW_2
171	}
172
173	if (PioMode >= *DisPioMode) {
174	PioMode = (UINT16) (*DisPioMode - 1);
175	}
176	}
177
178	if (PioMode < 2) {
179	*SelectedMode = 1; // ATA_PIO_MODE_BELOW_2;
180	} else {
181	*SelectedMode = PioMode; // ATA_PIO_MODE_2 to ATA_PIO_MODE_4;
182	}
183
184	} else {
185	//
186	// Identify Data word 64 - 70 are not valid
187	// Degrade the PIO mode if the mode has been disqualified
188	//
189	if (DisPioMode != NULL) {
190	if (*DisPioMode < 2) {
191	return EFI_UNSUPPORTED; // no mode below ATA_PIO_MODE_BELOW_2
192	}
193
194	if (PioMode == *DisPioMode) {
195	PioMode--;
196	}
197	}
198
199	if (PioMode < 2) {
200	*SelectedMode = 1; // ATA_PIO_MODE_BELOW_2;
201	} else {
202	*SelectedMode = 2; // ATA_PIO_MODE_2;
203	}
204
205	}
206
207	return EFI_SUCCESS;
208	}
209
210	/**
211	This function is used to calculate the best UDMA mode supported by specific IDE device
212
213	@param IdentifyData The identify data of specific IDE device.
214	@param DisUDmaMode Disqualified UDMA modes collection.
215	@param SelectedMode Available UDMA modes collection.
216
217	@retval EFI_SUCCESS Best UDMA modes are returned.
218	@retval EFI_UNSUPPORTED The device doesn't support UDMA mode,
219	or all supported modes have been disqualified.
220	**/
221	EFI_STATUS
222	CalculateBestUdmaMode (
223	IN EFI_IDENTIFY_DATA *IdentifyData,
224	IN UINT16 *DisUDmaMode OPTIONAL,
225	OUT UINT16 *SelectedMode
226	)
227	{
228	UINT16 TempMode;
229	UINT16 DeviceUDmaMode;
230
231	DeviceUDmaMode = 0;
232
233	//
234	// Check whether the WORD 88 (supported UltraDMA by drive) is valid
235	//
236	if ((IdentifyData->AtaData.field_validity & 0x04) == 0x00) {
237	return EFI_UNSUPPORTED;
238	}
239
240	DeviceUDmaMode = IdentifyData->AtaData.ultra_dma_mode;
241	DEBUG ((EFI_D_INFO, "CalculateBestUdmaMode: DeviceUDmaMode = %x\n", DeviceUDmaMode));
242	DeviceUDmaMode &= 0x3f;
243	TempMode = 0; // initialize it to UDMA-0
244
245	while ((DeviceUDmaMode >>= 1) != 0) {
246	TempMode++;
247	}
248
249	//
250	// Degrade the UDMA mode if the mode has been disqualified
251	//
252	if (DisUDmaMode != NULL) {
253	if (*DisUDmaMode == 0) {
254	*SelectedMode = 0;
255	return EFI_UNSUPPORTED; // no mode below ATA_UDMA_MODE_0
256	}
257
258	if (TempMode >= *DisUDmaMode) {
259	TempMode = (UINT16) (*DisUDmaMode - 1);
260	}
261	}
262
263	//
264	// Possible returned mode is between ATA_UDMA_MODE_0 and ATA_UDMA_MODE_5
265	//
266	*SelectedMode = TempMode;
267
268	return EFI_SUCCESS;
269	}
270
271	/**
272	The Entry Point of module. It follows the standard UEFI driver model.
273
274	@param[in] ImageHandle The firmware allocated handle for the EFI image.
275	@param[in] SystemTable A pointer to the EFI System Table.
276
277	@retval EFI_SUCCESS The entry point is executed successfully.
278	@retval other Some error occurs when executing this entry point.
279
280	**/
281	EFI_STATUS
282	EFIAPI
283	InitializeSataControllerDriver (
284	IN EFI_HANDLE ImageHandle,
285	IN EFI_SYSTEM_TABLE *SystemTable
286	)
287	{
288	EFI_STATUS Status;
289
290	//
291	// Install driver model protocol(s).
292	//
293	Status = EfiLibInstallDriverBindingComponentName2 (
294	ImageHandle,
295	SystemTable,
296	&gSataControllerDriverBinding,
297	ImageHandle,
298	&gSataControllerComponentName,
299	&gSataControllerComponentName2
300	);
301	ASSERT_EFI_ERROR (Status);
302
303	return Status;
304	}
305
306	/**
307	Supported function of Driver Binding protocol for this driver.
308	Test to see if this driver supports ControllerHandle.
309
310	@param This Protocol instance pointer.
311	@param Controller Handle of device to test.
312	@param RemainingDevicePath A pointer to the device path.
313	it should be ignored by device driver.
314
315	@retval EFI_SUCCESS This driver supports this device.
316	@retval EFI_ALREADY_STARTED This driver is already running on this device.
317	@retval other This driver does not support this device.
318
319	**/
320	EFI_STATUS
321	EFIAPI
322	SataControllerSupported (
323	IN EFI_DRIVER_BINDING_PROTOCOL *This,
324	IN EFI_HANDLE Controller,
325	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
326	)
327	{
328	EFI_STATUS Status;
329	EFI_PCI_IO_PROTOCOL *PciIo;
330	PCI_TYPE00 PciData;
331
332	//
333	// Attempt to open PCI I/O Protocol
334	//
335	Status = gBS->OpenProtocol (
336	Controller,
337	&gEfiPciIoProtocolGuid,
338	(VOID **) &PciIo,
339	This->DriverBindingHandle,
340	Controller,
341	EFI_OPEN_PROTOCOL_GET_PROTOCOL
342	);
343	if (EFI_ERROR (Status)) {
344	return Status;
345	}
346
347	//
348	// Now further check the PCI header: Base Class (offset 0x0B) and
349	// Sub Class (offset 0x0A). This controller should be an SATA controller
350	//
351	Status = PciIo->Pci.Read (
352	PciIo,
353	EfiPciIoWidthUint8,
354	PCI_CLASSCODE_OFFSET,
355	sizeof (PciData.Hdr.ClassCode),
356	PciData.Hdr.ClassCode
357	);
358	if (EFI_ERROR (Status)) {
359	return EFI_UNSUPPORTED;
360	}
361
362	if (IS_PCI_IDE (&PciData) \|\| IS_PCI_SATADPA (&PciData)) {
363	return EFI_SUCCESS;
364	}
365
366	return EFI_UNSUPPORTED;
367	}
368
369	/**
370	This routine is called right after the .Supported() called and
371	Start this driver on ControllerHandle.
372
373	@param This Protocol instance pointer.
374	@param Controller Handle of device to bind driver to.
375	@param RemainingDevicePath A pointer to the device path.
376	it should be ignored by device driver.
377
378	@retval EFI_SUCCESS This driver is added to this device.
379	@retval EFI_ALREADY_STARTED This driver is already running on this device.
380	@retval other Some error occurs when binding this driver to this device.
381
382	**/
383	EFI_STATUS
384	EFIAPI
385	SataControllerStart (
386	IN EFI_DRIVER_BINDING_PROTOCOL *This,
387	IN EFI_HANDLE Controller,
388	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
389	)
390	{
391	UINTN BailLogMask;
392	EFI_STATUS Status;
393	EFI_PCI_IO_PROTOCOL *PciIo;
394	UINT64 OriginalPciAttributes;
395	PCI_TYPE00 PciData;
396	EFI_SATA_CONTROLLER_PRIVATE_DATA *SataPrivateData;
397	UINT32 Data32;
398	UINTN ChannelDeviceCount;
399
400	DEBUG ((EFI_D_INFO, "SataControllerStart START\n"));
401
402	BailLogMask = DEBUG_ERROR;
403	SataPrivateData = NULL;
404
405	//
406	// Now test and open PCI I/O Protocol
407	//
408	Status = gBS->OpenProtocol (
409	Controller,
410	&gEfiPciIoProtocolGuid,
411	(VOID **) &PciIo,
412	This->DriverBindingHandle,
413	Controller,
414	EFI_OPEN_PROTOCOL_BY_DRIVER
415	);
416	if (EFI_ERROR (Status)) {
417	if (Status == EFI_ALREADY_STARTED) {
418	//
419	// This is an expected condition for OpenProtocol() / BY_DRIVER, in a
420	// DriverBindingStart() member function; degrade the log mask to
421	// DEBUG_INFO.
422	//
423	BailLogMask = DEBUG_INFO;
424	}
425	goto Bail;
426	}
427
428	//
429	// Save original PCI attributes, and enable IO space access, memory space
430	// access, and Bus Master (DMA).
431	//
432	Status = PciIo->Attributes (PciIo, EfiPciIoAttributeOperationGet, 0,
433	&OriginalPciAttributes);
434	if (EFI_ERROR (Status)) {
435	goto ClosePciIo;
436	}
437	Status = PciIo->Attributes (PciIo, EfiPciIoAttributeOperationEnable,
438	EFI_PCI_DEVICE_ENABLE, NULL);
439	if (EFI_ERROR (Status)) {
440	goto ClosePciIo;
441	}
442
443	//
444	// Allocate Sata Private Data structure
445	//
446	SataPrivateData = AllocateZeroPool (sizeof (EFI_SATA_CONTROLLER_PRIVATE_DATA));
447	if (SataPrivateData == NULL) {
448	Status = EFI_OUT_OF_RESOURCES;
449	goto RestorePciAttributes;
450	}
451
452	//
453	// Initialize Sata Private Data
454	//
455	SataPrivateData->Signature = SATA_CONTROLLER_SIGNATURE;
456	SataPrivateData->PciIo = PciIo;
457	SataPrivateData->OriginalPciAttributes = OriginalPciAttributes;
458	SataPrivateData->IdeInit.GetChannelInfo = IdeInitGetChannelInfo;
459	SataPrivateData->IdeInit.NotifyPhase = IdeInitNotifyPhase;
460	SataPrivateData->IdeInit.SubmitData = IdeInitSubmitData;
461	SataPrivateData->IdeInit.DisqualifyMode = IdeInitDisqualifyMode;
462	SataPrivateData->IdeInit.CalculateMode = IdeInitCalculateMode;
463	SataPrivateData->IdeInit.SetTiming = IdeInitSetTiming;
464	SataPrivateData->IdeInit.EnumAll = SATA_ENUMER_ALL;
465
466	Status = PciIo->Pci.Read (
467	PciIo,
468	EfiPciIoWidthUint8,
469	PCI_CLASSCODE_OFFSET,
470	sizeof (PciData.Hdr.ClassCode),
471	PciData.Hdr.ClassCode
472	);
473	if (EFI_ERROR (Status)) {
474	goto FreeSataPrivateData;
475	}
476
477	if (IS_PCI_IDE (&PciData)) {
478	SataPrivateData->IdeInit.ChannelCount = IDE_MAX_CHANNEL;
479	SataPrivateData->DeviceCount = IDE_MAX_DEVICES;
480	} else if (IS_PCI_SATADPA (&PciData)) {
481	//
482	// Read Host Capability Register(CAP) to get Number of Ports(NPS) and Supports Port Multiplier(SPM)
483	// NPS is 0's based value indicating the maximum number of ports supported by the HBA silicon.
484	// A maximum of 32 ports can be supported. A value of '0h', indicating one port, is the minimum requirement.
485	//
486	Data32 = AhciReadReg (PciIo, R_AHCI_CAP);
487	SataPrivateData->IdeInit.ChannelCount = (UINT8) ((Data32 & B_AHCI_CAP_NPS) + 1);
488	SataPrivateData->DeviceCount = AHCI_MAX_DEVICES;
489	if ((Data32 & B_AHCI_CAP_SPM) == B_AHCI_CAP_SPM) {
490	SataPrivateData->DeviceCount = AHCI_MULTI_MAX_DEVICES;
491	}
492	}
493
494	ChannelDeviceCount = (UINTN) (SataPrivateData->IdeInit.ChannelCount) * (UINTN) (SataPrivateData->DeviceCount);
495	SataPrivateData->DisqualifiedModes = AllocateZeroPool ((sizeof (EFI_ATA_COLLECTIVE_MODE)) * ChannelDeviceCount);
496	if (SataPrivateData->DisqualifiedModes == NULL) {
497	Status = EFI_OUT_OF_RESOURCES;
498	goto FreeSataPrivateData;
499	}
500
501	SataPrivateData->IdentifyData = AllocateZeroPool ((sizeof (EFI_IDENTIFY_DATA)) * ChannelDeviceCount);
502	if (SataPrivateData->IdentifyData == NULL) {
503	Status = EFI_OUT_OF_RESOURCES;
504	goto FreeDisqualifiedModes;
505	}
506
507	SataPrivateData->IdentifyValid = AllocateZeroPool ((sizeof (BOOLEAN)) * ChannelDeviceCount);
508	if (SataPrivateData->IdentifyValid == NULL) {
509	Status = EFI_OUT_OF_RESOURCES;
510	goto FreeIdentifyData;
511	}
512
513	//
514	// Install IDE Controller Init Protocol to this instance
515	//
516	Status = gBS->InstallMultipleProtocolInterfaces (
517	&Controller,
518	&gEfiIdeControllerInitProtocolGuid,
519	&(SataPrivateData->IdeInit),
520	NULL
521	);
522
523	if (EFI_ERROR (Status)) {
524	goto FreeIdentifyValid;
525	}
526
527	DEBUG ((EFI_D_INFO, "SataControllerStart END status = %r\n", Status));
528	return Status;
529
530	FreeIdentifyValid:
531	FreePool (SataPrivateData->IdentifyValid);
532
533	FreeIdentifyData:
534	FreePool (SataPrivateData->IdentifyData);
535
536	FreeDisqualifiedModes:
537	FreePool (SataPrivateData->DisqualifiedModes);
538
539	FreeSataPrivateData:
540	FreePool (SataPrivateData);
541
542	RestorePciAttributes:
543	PciIo->Attributes (PciIo, EfiPciIoAttributeOperationSet,
544	OriginalPciAttributes, NULL);
545
546	ClosePciIo:
547	gBS->CloseProtocol (
548	Controller,
549	&gEfiPciIoProtocolGuid,
550	This->DriverBindingHandle,
551	Controller
552	);
553
554	Bail:
555	DEBUG ((BailLogMask, "SataControllerStart error return status = %r\n",
556	Status));
557	return Status;
558	}
559
560	/**
561	Stop this driver on ControllerHandle.
562
563	@param This Protocol instance pointer.
564	@param Controller Handle of device to stop driver on.
565	@param NumberOfChildren Not used.
566	@param ChildHandleBuffer Not used.
567
568	@retval EFI_SUCCESS This driver is removed from this device.
569	@retval other Some error occurs when removing this driver from this device.
570
571	**/
572	EFI_STATUS
573	EFIAPI
574	SataControllerStop (
575	IN EFI_DRIVER_BINDING_PROTOCOL *This,
576	IN EFI_HANDLE Controller,
577	IN UINTN NumberOfChildren,
578	IN EFI_HANDLE *ChildHandleBuffer
579	)
580	{
581	EFI_STATUS Status;
582	EFI_IDE_CONTROLLER_INIT_PROTOCOL *IdeInit;
583	EFI_SATA_CONTROLLER_PRIVATE_DATA *SataPrivateData;
584	EFI_PCI_IO_PROTOCOL *PciIo;
585	UINT64 OriginalPciAttributes;
586
587	//
588	// Open the produced protocol
589	//
590	Status = gBS->OpenProtocol (
591	Controller,
592	&gEfiIdeControllerInitProtocolGuid,
593	(VOID **) &IdeInit,
594	This->DriverBindingHandle,
595	Controller,
596	EFI_OPEN_PROTOCOL_GET_PROTOCOL
597	);
598	if (EFI_ERROR (Status)) {
599	return EFI_UNSUPPORTED;
600	}
601
602	SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (IdeInit);
603	ASSERT (SataPrivateData != NULL);
604
605	PciIo = SataPrivateData->PciIo;
606	OriginalPciAttributes = SataPrivateData->OriginalPciAttributes;
607
608	//
609	// Uninstall the IDE Controller Init Protocol from this instance
610	//
611	Status = gBS->UninstallMultipleProtocolInterfaces (
612	Controller,
613	&gEfiIdeControllerInitProtocolGuid,
614	&(SataPrivateData->IdeInit),
615	NULL
616	);
617	if (EFI_ERROR (Status)) {
618	return Status;
619	}
620
621	if (SataPrivateData->DisqualifiedModes != NULL) {
622	FreePool (SataPrivateData->DisqualifiedModes);
623	}
624	if (SataPrivateData->IdentifyData != NULL) {
625	FreePool (SataPrivateData->IdentifyData);
626	}
627	if (SataPrivateData->IdentifyValid != NULL) {
628	FreePool (SataPrivateData->IdentifyValid);
629	}
630	FreePool (SataPrivateData);
631
632	//
633	// Restore original PCI attributes
634	//
635	PciIo->Attributes (
636	PciIo,
637	EfiPciIoAttributeOperationSet,
638	OriginalPciAttributes,
639	NULL
640	);
641
642	//
643	// Close protocols opened by Sata Controller driver
644	//
645	return gBS->CloseProtocol (
646	Controller,
647	&gEfiPciIoProtocolGuid,
648	This->DriverBindingHandle,
649	Controller
650	);
651	}
652
653	/**
654	Calculate the flat array subscript of a (Channel, Device) pair.
655
656	@param[in] SataPrivateData The private data structure corresponding to the
657	SATA controller that attaches the device for
658	which the flat array subscript is being
659	calculated.
660
661	@param[in] Channel The channel (ie. port) number on the SATA
662	controller that the device is attached to.
663
664	@param[in] Device The device number on the channel.
665
666	@return The flat array subscript suitable for indexing DisqualifiedModes,
667	IdentifyData, and IdentifyValid.
668	**/
669	STATIC
670	UINTN
671	FlatDeviceIndex (
672	IN CONST EFI_SATA_CONTROLLER_PRIVATE_DATA *SataPrivateData,
673	IN UINTN Channel,
674	IN UINTN Device
675	)
676	{
677	ASSERT (SataPrivateData != NULL);
678	ASSERT (Channel < SataPrivateData->IdeInit.ChannelCount);
679	ASSERT (Device < SataPrivateData->DeviceCount);
680
681	return Channel * SataPrivateData->DeviceCount + Device;
682	}
683
684	//
685	// Interface functions of IDE_CONTROLLER_INIT protocol
686	//
687	/**
688	Returns the information about the specified IDE channel.
689
690	This function can be used to obtain information about a particular IDE channel.
691	The driver entity uses this information during the enumeration process.
692
693	If Enabled is set to FALSE, the driver entity will not scan the channel. Note
694	that it will not prevent an operating system driver from scanning the channel.
695
696	For most of today's controllers, MaxDevices will either be 1 or 2. For SATA
697	controllers, this value will always be 1. SATA configurations can contain SATA
698	port multipliers. SATA port multipliers behave like SATA bridges and can support
699	up to 16 devices on the other side. If a SATA port out of the IDE controller
700	is connected to a port multiplier, MaxDevices will be set to the number of SATA
701	devices that the port multiplier supports. Because today's port multipliers
702	support up to fifteen SATA devices, this number can be as large as fifteen. The IDE
703	bus driver is required to scan for the presence of port multipliers behind an SATA
704	controller and enumerate up to MaxDevices number of devices behind the port
705	multiplier.
706
707	In this context, the devices behind a port multiplier constitute a channel.
708
709	@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
710	@param[in] Channel Zero-based channel number.
711	@param[out] Enabled TRUE if this channel is enabled. Disabled channels
712	are not scanned to see if any devices are present.
713	@param[out] MaxDevices The maximum number of IDE devices that the bus driver
714	can expect on this channel. For the ATA/ATAPI
715	specification, version 6, this number will either be
716	one or two. For Serial ATA (SATA) configurations with a
717	port multiplier, this number can be as large as fifteen.
718
719	@retval EFI_SUCCESS Information was returned without any errors.
720	@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
721
722	**/
723	EFI_STATUS
724	EFIAPI
725	IdeInitGetChannelInfo (
726	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
727	IN UINT8 Channel,
728	OUT BOOLEAN *Enabled,
729	OUT UINT8 *MaxDevices
730	)
731	{
732	EFI_SATA_CONTROLLER_PRIVATE_DATA *SataPrivateData;
733	SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This);
734	ASSERT (SataPrivateData != NULL);
735
736	if (Channel < This->ChannelCount) {
737	*Enabled = TRUE;
738	*MaxDevices = SataPrivateData->DeviceCount;
739	return EFI_SUCCESS;
740	}
741
742	*Enabled = FALSE;
743	return EFI_INVALID_PARAMETER;
744	}
745
746	/**
747	The notifications from the driver entity that it is about to enter a certain
748	phase of the IDE channel enumeration process.
749
750	This function can be used to notify the IDE controller driver to perform
751	specific actions, including any chipset-specific initialization, so that the
752	chipset is ready to enter the next phase. Seven notification points are defined
753	at this time.
754
755	More synchronization points may be added as required in the future.
756
757	@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
758	@param[in] Phase The phase during enumeration.
759	@param[in] Channel Zero-based channel number.
760
761	@retval EFI_SUCCESS The notification was accepted without any errors.
762	@retval EFI_UNSUPPORTED Phase is not supported.
763	@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
764	@retval EFI_NOT_READY This phase cannot be entered at this time; for
765	example, an attempt was made to enter a Phase
766	without having entered one or more previous
767	Phase.
768
769	**/
770	EFI_STATUS
771	EFIAPI
772	IdeInitNotifyPhase (
773	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
774	IN EFI_IDE_CONTROLLER_ENUM_PHASE Phase,
775	IN UINT8 Channel
776	)
777	{
778	return EFI_SUCCESS;
779	}
780
781	/**
782	Submits the device information to the IDE controller driver.
783
784	This function is used by the driver entity to pass detailed information about
785	a particular device to the IDE controller driver. The driver entity obtains
786	this information by issuing an ATA or ATAPI IDENTIFY_DEVICE command. IdentifyData
787	is the pointer to the response data buffer. The IdentifyData buffer is owned
788	by the driver entity, and the IDE controller driver must make a local copy
789	of the entire buffer or parts of the buffer as needed. The original IdentifyData
790	buffer pointer may not be valid when
791
792	- EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() or
793	- EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() is called at a later point.
794
795	The IDE controller driver may consult various fields of EFI_IDENTIFY_DATA to
796	compute the optimum mode for the device. These fields are not limited to the
797	timing information. For example, an implementation of the IDE controller driver
798	may examine the vendor and type/mode field to match known bad drives.
799
800	The driver entity may submit drive information in any order, as long as it
801	submits information for all the devices belonging to the enumeration group
802	before EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() is called for any device
803	in that enumeration group. If a device is absent, EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
804	should be called with IdentifyData set to NULL. The IDE controller driver may
805	not have any other mechanism to know whether a device is present or not. Therefore,
806	setting IdentifyData to NULL does not constitute an error condition.
807	EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() can be called only once for a
808	given (Channel, Device) pair.
809
810	@param[in] This A pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
811	@param[in] Channel Zero-based channel number.
812	@param[in] Device Zero-based device number on the Channel.
813	@param[in] IdentifyData The device's response to the ATA IDENTIFY_DEVICE command.
814
815	@retval EFI_SUCCESS The information was accepted without any errors.
816	@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
817	@retval EFI_INVALID_PARAMETER Device is invalid.
818
819	**/
820	EFI_STATUS
821	EFIAPI
822	IdeInitSubmitData (
823	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
824	IN UINT8 Channel,
825	IN UINT8 Device,
826	IN EFI_IDENTIFY_DATA *IdentifyData
827	)
828	{
829	EFI_SATA_CONTROLLER_PRIVATE_DATA *SataPrivateData;
830	UINTN DeviceIndex;
831
832	SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This);
833	ASSERT (SataPrivateData != NULL);
834
835	if ((Channel >= This->ChannelCount) \|\| (Device >= SataPrivateData->DeviceCount)) {
836	return EFI_INVALID_PARAMETER;
837	}
838
839	DeviceIndex = FlatDeviceIndex (SataPrivateData, Channel, Device);
840
841	//
842	// Make a local copy of device's IdentifyData and mark the valid flag
843	//
844	if (IdentifyData != NULL) {
845	CopyMem (
846	&(SataPrivateData->IdentifyData[DeviceIndex]),
847	IdentifyData,
848	sizeof (EFI_IDENTIFY_DATA)
849	);
850
851	SataPrivateData->IdentifyValid[DeviceIndex] = TRUE;
852	} else {
853	SataPrivateData->IdentifyValid[DeviceIndex] = FALSE;
854	}
855
856	return EFI_SUCCESS;
857	}
858
859	/**
860	Disqualifies specific modes for an IDE device.
861
862	This function allows the driver entity or other drivers (such as platform
863	drivers) to reject certain timing modes and request the IDE controller driver
864	to recalculate modes. This function allows the driver entity and the IDE
865	controller driver to negotiate the timings on a per-device basis. This function
866	is useful in the case of drives that lie about their capabilities. An example
867	is when the IDE device fails to accept the timing modes that are calculated
868	by the IDE controller driver based on the response to the Identify Drive command.
869
870	If the driver entity does not want to limit the ATA timing modes and leave that
871	decision to the IDE controller driver, it can either not call this function for
872	the given device or call this function and set the Valid flag to FALSE for all
873	modes that are listed in EFI_ATA_COLLECTIVE_MODE.
874
875	The driver entity may disqualify modes for a device in any order and any number
876	of times.
877
878	This function can be called multiple times to invalidate multiple modes of the
879	same type (e.g., Programmed Input/Output [PIO] modes 3 and 4). See the ATA/ATAPI
880	specification for more information on PIO modes.
881
882	For Serial ATA (SATA) controllers, this member function can be used to disqualify
883	a higher transfer rate mode on a given channel. For example, a platform driver
884	may inform the IDE controller driver to not use second-generation (Gen2) speeds
885	for a certain SATA drive.
886
887	@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
888	@param[in] Channel The zero-based channel number.
889	@param[in] Device The zero-based device number on the Channel.
890	@param[in] BadModes The modes that the device does not support and that
891	should be disqualified.
892
893	@retval EFI_SUCCESS The modes were accepted without any errors.
894	@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
895	@retval EFI_INVALID_PARAMETER Device is invalid.
896	@retval EFI_INVALID_PARAMETER IdentifyData is NULL.
897
898	**/
899	EFI_STATUS
900	EFIAPI
901	IdeInitDisqualifyMode (
902	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
903	IN UINT8 Channel,
904	IN UINT8 Device,
905	IN EFI_ATA_COLLECTIVE_MODE *BadModes
906	)
907	{
908	EFI_SATA_CONTROLLER_PRIVATE_DATA *SataPrivateData;
909	UINTN DeviceIndex;
910
911	SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This);
912	ASSERT (SataPrivateData != NULL);
913
914	if ((Channel >= This->ChannelCount) \|\| (BadModes == NULL) \|\| (Device >= SataPrivateData->DeviceCount)) {
915	return EFI_INVALID_PARAMETER;
916	}
917
918	DeviceIndex = FlatDeviceIndex (SataPrivateData, Channel, Device);
919
920	//
921	// Record the disqualified modes per channel per device. From ATA/ATAPI spec,
922	// if a mode is not supported, the modes higher than it is also not supported.
923	//
924	CopyMem (
925	&(SataPrivateData->DisqualifiedModes[DeviceIndex]),
926	BadModes,
927	sizeof (EFI_ATA_COLLECTIVE_MODE)
928	);
929
930	return EFI_SUCCESS;
931	}
932
933	/**
934	Returns the information about the optimum modes for the specified IDE device.
935
936	This function is used by the driver entity to obtain the optimum ATA modes for
937	a specific device. The IDE controller driver takes into account the following
938	while calculating the mode:
939	- The IdentifyData inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
940	- The BadModes inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode()
941
942	The driver entity is required to call EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
943	for all the devices that belong to an enumeration group before calling
944	EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() for any device in the same group.
945
946	The IDE controller driver will use controller- and possibly platform-specific
947	algorithms to arrive at SupportedModes. The IDE controller may base its
948	decision on user preferences and other considerations as well. This function
949	may be called multiple times because the driver entity may renegotiate the mode
950	with the IDE controller driver using EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode().
951
952	The driver entity may collect timing information for various devices in any
953	order. The driver entity is responsible for making sure that all the dependencies
954	are satisfied. For example, the SupportedModes information for device A that
955	was previously returned may become stale after a call to
956	EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() for device B.
957
958	The buffer SupportedModes is allocated by the callee because the caller does
959	not necessarily know the size of the buffer. The type EFI_ATA_COLLECTIVE_MODE
960	is defined in a way that allows for future extensibility and can be of variable
961	length. This memory pool should be deallocated by the caller when it is no
962	longer necessary.
963
964	The IDE controller driver for a Serial ATA (SATA) controller can use this
965	member function to force a lower speed (first-generation [Gen1] speeds on a
966	second-generation [Gen2]-capable hardware). The IDE controller driver can
967	also allow the driver entity to stay with the speed that has been negotiated
968	by the physical layer.
969
970	@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
971	@param[in] Channel A zero-based channel number.
972	@param[in] Device A zero-based device number on the Channel.
973	@param[out] SupportedModes The optimum modes for the device.
974
975	@retval EFI_SUCCESS SupportedModes was returned.
976	@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
977	@retval EFI_INVALID_PARAMETER Device is invalid.
978	@retval EFI_INVALID_PARAMETER SupportedModes is NULL.
979	@retval EFI_NOT_READY Modes cannot be calculated due to a lack of
980	data. This error may happen if
981	EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
982	and EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyData()
983	were not called for at least one drive in the
984	same enumeration group.
985
986	**/
987	EFI_STATUS
988	EFIAPI
989	IdeInitCalculateMode (
990	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
991	IN UINT8 Channel,
992	IN UINT8 Device,
993	OUT EFI_ATA_COLLECTIVE_MODE **SupportedModes
994	)
995	{
996	EFI_SATA_CONTROLLER_PRIVATE_DATA *SataPrivateData;
997	EFI_IDENTIFY_DATA *IdentifyData;
998	BOOLEAN IdentifyValid;
999	EFI_ATA_COLLECTIVE_MODE *DisqualifiedModes;
1000	UINT16 SelectedMode;
1001	EFI_STATUS Status;
1002	UINTN DeviceIndex;
1003
1004	SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This);
1005	ASSERT (SataPrivateData != NULL);
1006
1007	if ((Channel >= This->ChannelCount) \|\| (SupportedModes == NULL) \|\| (Device >= SataPrivateData->DeviceCount)) {
1008	return EFI_INVALID_PARAMETER;
1009	}
1010
1011	*SupportedModes = AllocateZeroPool (sizeof (EFI_ATA_COLLECTIVE_MODE));
1012	if (*SupportedModes == NULL) {
1013	ASSERT (*SupportedModes != NULL);
1014	return EFI_OUT_OF_RESOURCES;
1015	}
1016
1017	DeviceIndex = FlatDeviceIndex (SataPrivateData, Channel, Device);
1018
1019	IdentifyData = &(SataPrivateData->IdentifyData[DeviceIndex]);
1020	IdentifyValid = SataPrivateData->IdentifyValid[DeviceIndex];
1021	DisqualifiedModes = &(SataPrivateData->DisqualifiedModes[DeviceIndex]);
1022
1023	//
1024	// Make sure we've got the valid identify data of the device from SubmitData()
1025	//
1026	if (!IdentifyValid) {
1027	FreePool (*SupportedModes);
1028	return EFI_NOT_READY;
1029	}
1030
1031	Status = CalculateBestPioMode (
1032	IdentifyData,
1033	(DisqualifiedModes->PioMode.Valid ? ((UINT16 *) &(DisqualifiedModes->PioMode.Mode)) : NULL),
1034	&SelectedMode
1035	);
1036	if (!EFI_ERROR (Status)) {
1037	(*SupportedModes)->PioMode.Valid = TRUE;
1038	(*SupportedModes)->PioMode.Mode = SelectedMode;
1039
1040	} else {
1041	(*SupportedModes)->PioMode.Valid = FALSE;
1042	}
1043	DEBUG ((EFI_D_INFO, "IdeInitCalculateMode: PioMode = %x\n", (*SupportedModes)->PioMode.Mode));
1044
1045	Status = CalculateBestUdmaMode (
1046	IdentifyData,
1047	(DisqualifiedModes->UdmaMode.Valid ? ((UINT16 *) &(DisqualifiedModes->UdmaMode.Mode)) : NULL),
1048	&SelectedMode
1049	);
1050
1051	if (!EFI_ERROR (Status)) {
1052	(*SupportedModes)->UdmaMode.Valid = TRUE;
1053	(*SupportedModes)->UdmaMode.Mode = SelectedMode;
1054
1055	} else {
1056	(*SupportedModes)->UdmaMode.Valid = FALSE;
1057	}
1058	DEBUG ((EFI_D_INFO, "IdeInitCalculateMode: UdmaMode = %x\n", (*SupportedModes)->UdmaMode.Mode));
1059
1060	//
1061	// The modes other than PIO and UDMA are not supported
1062	//
1063	return EFI_SUCCESS;
1064	}
1065
1066	/**
1067	Commands the IDE controller driver to program the IDE controller hardware
1068	so that the specified device can operate at the specified mode.
1069
1070	This function is used by the driver entity to instruct the IDE controller
1071	driver to program the IDE controller hardware to the specified modes. This
1072	function can be called only once for a particular device. For a Serial ATA
1073	(SATA) Advanced Host Controller Interface (AHCI) controller, no controller-
1074	specific programming may be required.
1075
1076	@param[in] This Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
1077	@param[in] Channel Zero-based channel number.
1078	@param[in] Device Zero-based device number on the Channel.
1079	@param[in] Modes The modes to set.
1080
1081	@retval EFI_SUCCESS The command was accepted without any errors.
1082	@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
1083	@retval EFI_INVALID_PARAMETER Device is invalid.
1084	@retval EFI_NOT_READY Modes cannot be set at this time due to lack of data.
1085	@retval EFI_DEVICE_ERROR Modes cannot be set due to hardware failure.
1086	The driver entity should not use this device.
1087
1088	**/
1089	EFI_STATUS
1090	EFIAPI
1091	IdeInitSetTiming (
1092	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
1093	IN UINT8 Channel,
1094	IN UINT8 Device,
1095	IN EFI_ATA_COLLECTIVE_MODE *Modes
1096	)
1097	{
1098	return EFI_SUCCESS;
1099	}

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

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/OvmfPkg/SataControllerDxe/SataController.c@ 79205

Download in other formats: