EmbeddedPkg: Added SATA Silicon Image driver
[mirror_edk2.git] / EmbeddedPkg / Drivers / SataSiI3132Dxe / SataSiI3132.c
1 /** @file
2 * PCIe Sata support for the Silicon Image I3132
3 *
4 * Copyright (c) 2011-2015, ARM Limited. All rights reserved.
5 *
6 * This program and the accompanying materials
7 * are licensed and made available under the terms and conditions of the BSD License
8 * which accompanies this distribution. The full text of the license may be found at
9 * http://opensource.org/licenses/bsd-license.php
10 *
11 * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13 *
14 **/
15
16 #include "SataSiI3132.h"
17
18 #include <IndustryStandard/Acpi10.h>
19
20 #include <Library/MemoryAllocationLib.h>
21 #include <Library/UefiBootServicesTableLib.h>
22 #include <Library/DxeServicesTableLib.h>
23 #include <Library/BaseLib.h>
24
25 #define ACPI_SPECFLAG_PREFETCHABLE 0x06
26
27 EFI_DRIVER_BINDING_PROTOCOL
28 gSataSiI3132DriverBinding = {
29 SataSiI3132DriverBindingSupported,
30 SataSiI3132DriverBindingStart,
31 SataSiI3132DriverBindingStop,
32 0x30,
33 NULL,
34 NULL
35 };
36
37 EFI_STATUS
38 SataSiI3132PortConstructor (
39 IN SATA_SI3132_INSTANCE *SataSiI3132Instance,
40 IN UINTN Index
41 )
42 {
43 EFI_STATUS Status;
44 SATA_SI3132_PORT *Port;
45 VOID *HostPRB;
46 EFI_PHYSICAL_ADDRESS PhysAddrHostPRB;
47 VOID *PciAllocMappingPRB;
48 UINTN NumberOfBytes;
49
50 Port = &(SataSiI3132Instance->Ports[Index]);
51
52 Port->Index = Index;
53 Port->RegBase = Index * 0x2000;
54 Port->Instance = SataSiI3132Instance;
55 InitializeListHead (&(Port->Devices));
56
57 NumberOfBytes = sizeof (SATA_SI3132_PRB);
58 Status = SataSiI3132Instance->PciIo->AllocateBuffer (
59 SataSiI3132Instance->PciIo, AllocateAnyPages, EfiBootServicesData,
60 EFI_SIZE_TO_PAGES (NumberOfBytes), &HostPRB, 0
61 );
62 if (EFI_ERROR (Status)) {
63 return Status;
64 }
65
66 // Check the alignment of the PCI Buffer
67 ASSERT (((UINTN)HostPRB & (0x1000 - 1)) == 0);
68 Status = SataSiI3132Instance->PciIo->Map (
69 SataSiI3132Instance->PciIo, EfiPciIoOperationBusMasterCommonBuffer, HostPRB,
70 &NumberOfBytes, &PhysAddrHostPRB, &PciAllocMappingPRB
71 );
72 if (EFI_ERROR (Status)) {
73 return Status;
74 }
75
76 Port->HostPRB = HostPRB;
77 Port->PhysAddrHostPRB = PhysAddrHostPRB;
78 Port->PciAllocMappingPRB = PciAllocMappingPRB;
79
80 return Status;
81 }
82
83 STATIC
84 EFI_STATUS
85 SataSiI3132Constructor (
86 IN EFI_PCI_IO_PROTOCOL *PciIo,
87 OUT SATA_SI3132_INSTANCE** SataSiI3132Instance
88 )
89 {
90 SATA_SI3132_INSTANCE *Instance;
91 EFI_ATA_PASS_THRU_MODE *AtaPassThruMode;
92
93 if (!SataSiI3132Instance) {
94 return EFI_INVALID_PARAMETER;
95 }
96
97 Instance = (SATA_SI3132_INSTANCE*)AllocateZeroPool (sizeof (SATA_SI3132_INSTANCE));
98 if (Instance == NULL) {
99 return EFI_OUT_OF_RESOURCES;
100 }
101
102 Instance->Signature = SATA_SII3132_SIGNATURE;
103 Instance->PciIo = PciIo;
104
105 AtaPassThruMode = (EFI_ATA_PASS_THRU_MODE*)AllocatePool (sizeof (EFI_ATA_PASS_THRU_MODE));
106 AtaPassThruMode->Attributes = EFI_ATA_PASS_THRU_ATTRIBUTES_PHYSICAL | EFI_ATA_PASS_THRU_ATTRIBUTES_LOGICAL;
107 AtaPassThruMode->IoAlign = 0x1000;
108
109 // Initialize SiI3132 ports
110 SataSiI3132PortConstructor (Instance, 0);
111 SataSiI3132PortConstructor (Instance, 1);
112
113 // Set ATA Pass Thru Protocol
114 Instance->AtaPassThruProtocol.Mode = AtaPassThruMode;
115 Instance->AtaPassThruProtocol.PassThru = SiI3132AtaPassThru;
116 Instance->AtaPassThruProtocol.GetNextPort = SiI3132GetNextPort;
117 Instance->AtaPassThruProtocol.GetNextDevice = SiI3132GetNextDevice;
118 Instance->AtaPassThruProtocol.BuildDevicePath = SiI3132BuildDevicePath;
119 Instance->AtaPassThruProtocol.GetDevice = SiI3132GetDevice;
120 Instance->AtaPassThruProtocol.ResetPort = SiI3132ResetPort;
121 Instance->AtaPassThruProtocol.ResetDevice = SiI3132ResetDevice;
122
123 *SataSiI3132Instance = Instance;
124
125 return EFI_SUCCESS;
126 }
127
128 EFI_STATUS
129 SiI3132SoftResetCommand (
130 IN SATA_SI3132_PORT *Port,
131 OUT UINT32* Signature
132 )
133 {
134 EFI_STATUS Status;
135 EFI_ATA_PASS_THRU_COMMAND_PACKET Packet;
136 EFI_ATA_STATUS_BLOCK Asb;
137 EFI_ATA_COMMAND_BLOCK Acb;
138 CONST UINT16 PortMultiplierPort = 0;
139
140 ZeroMem (&Acb, sizeof (EFI_ATA_COMMAND_BLOCK));
141
142 Acb.Reserved1[1] = 0;
143
144 Packet.Asb = &Asb;
145 Packet.Acb = &Acb;
146 Packet.Timeout = 100000;
147 Packet.Protocol = EFI_ATA_PASS_THRU_PROTOCOL_ATA_SOFTWARE_RESET;
148
149 Status = SiI3132AtaPassThruCommand (Port->Instance, Port, PortMultiplierPort, &Packet, 0);
150
151 if (Status == EFI_SUCCESS) {
152 *Signature = (Asb.AtaCylinderHigh << 24) | (Asb.AtaCylinderLow << 16) |
153 (Asb.AtaSectorNumber << 8 ) | (Asb.AtaSectorCount);
154 }
155 return Status;
156 }
157
158 EFI_STATUS
159 SataSiI3132PortInitialization (
160 IN SATA_SI3132_PORT *Port
161 )
162 {
163 UINT32 Value32;
164 SATA_SI3132_DEVICE* Device;
165 UINT32 Signature;
166 EFI_STATUS Status;
167 EFI_PCI_IO_PROTOCOL* PciIo;
168
169 Status = SiI3132HwResetPort (Port);
170 if (EFI_ERROR (Status)) {
171 return Status;
172 }
173
174 PciIo = Port->Instance->PciIo;
175
176 // Is a device is present ?
177 Status = SATA_PORT_READ32 (Port->RegBase + SII3132_PORT_SSTATUS_REG, &Value32);
178 if (!EFI_ERROR (Status) && (Value32 & 0x3)) {
179 // Do a soft reset to see if it is a port multiplier
180 SATA_TRACE ("SataSiI3132PortInitialization: soft reset - it is a port multiplier\n");
181 Status = SiI3132SoftResetCommand (Port, &Signature);
182 if (!EFI_ERROR (Status)) {
183 if (Signature == SII3132_PORT_SIGNATURE_PMP) {
184 SATA_TRACE ("SataSiI3132PortInitialization(): a Port Multiplier is present");
185 if (FeaturePcdGet (PcdSataSiI3132FeaturePMPSupport)) {
186 ASSERT (0); // Not supported yet
187 } else {
188 return EFI_UNSUPPORTED;
189 }
190 } else if (Signature == SII3132_PORT_SIGNATURE_ATAPI) {
191 ASSERT (0); // Not supported yet
192 SATA_TRACE ("SataSiI3132PortInitialization(): an ATAPI device is present");
193 return EFI_UNSUPPORTED;
194 } else if (Signature == SII3132_PORT_SIGNATURE_ATA) {
195 SATA_TRACE ("SataSiI3132PortInitialization(): an ATA device is present");
196 } else {
197 SATA_TRACE ("SataSiI3132PortInitialization(): Present device unknown!");
198 ASSERT (0); // Not supported
199 return EFI_UNSUPPORTED;
200 }
201
202 // Create Device
203 Device = (SATA_SI3132_DEVICE*)AllocatePool (sizeof (SATA_SI3132_DEVICE));
204 Device->Index = Port->Index; //TODO: Could need to be fixed when SATA Port Multiplier support
205 Device->Port = Port;
206 Device->BlockSize = 0;
207
208 // Attached the device to the Sata Port
209 InsertTailList (&Port->Devices, &Device->Link);
210
211 SATA_TRACE ("SataSiI3132PortInitialization(): Port Ready");
212 }
213 }
214 return Status;
215 }
216
217 EFI_STATUS
218 SataSiI3132Initialization (
219 IN SATA_SI3132_INSTANCE* SataSiI3132Instance
220 )
221 {
222 UINTN Index;
223 EFI_PCI_IO_PROTOCOL* PciIo;
224
225 if (!SataSiI3132Instance) {
226 return EFI_INVALID_PARAMETER;
227 }
228
229 PciIo = SataSiI3132Instance->PciIo;
230
231 // Turn Off GPIO
232 SATA_GLOBAL_WRITE32 (SII3132_GLOBAL_FLASHADDR_REG, 0x0);
233
234 // Clear Global Control Register
235 SATA_GLOBAL_WRITE32 (SII3132_GLOBAL_CONTROL_REG, 0x0);
236
237 for (Index = 0; Index < SATA_SII3132_MAXPORT; Index++) {
238 SataSiI3132PortInitialization (&(SataSiI3132Instance->Ports[Index]));
239 }
240
241 return EFI_SUCCESS;
242 }
243
244 /**
245 Test to see if this driver supports ControllerHandle.
246
247 @param This Protocol instance pointer.
248 @param Controller Handle of device to test.
249 @param RemainingDevicePath Not used.
250
251 @return EFI_SUCCESS This driver supports this device.
252 @return EFI_UNSUPPORTED This driver does not support this device.
253
254 **/
255 EFI_STATUS
256 EFIAPI
257 SataSiI3132DriverBindingSupported (
258 IN EFI_DRIVER_BINDING_PROTOCOL *This,
259 IN EFI_HANDLE Controller,
260 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
261 )
262 {
263 EFI_STATUS Status;
264 EFI_PCI_IO_PROTOCOL *PciIo;
265 UINT32 PciID;
266
267 //
268 // Test whether there is PCI IO Protocol attached on the controller handle.
269 //
270 Status = gBS->OpenProtocol (
271 Controller,
272 &gEfiPciIoProtocolGuid,
273 (VOID **) &PciIo,
274 This->DriverBindingHandle,
275 Controller,
276 EFI_OPEN_PROTOCOL_BY_DRIVER
277 );
278 if (EFI_ERROR (Status)) {
279 return Status;
280 }
281
282 Status = PciIo->Pci.Read (
283 PciIo,
284 EfiPciIoWidthUint32,
285 PCI_VENDOR_ID_OFFSET,
286 1,
287 &PciID
288 );
289 if (EFI_ERROR (Status)) {
290 Status = EFI_UNSUPPORTED;
291 goto ON_EXIT;
292 }
293
294 //
295 // Test whether the controller belongs to SATA Mass Storage type
296 //
297 if (PciID != ((SATA_SII3132_DEVICE_ID << 16) | SATA_SII3132_VENDOR_ID)) {
298 Status = EFI_UNSUPPORTED;
299 }
300
301 ON_EXIT:
302 gBS->CloseProtocol (
303 Controller,
304 &gEfiPciIoProtocolGuid,
305 This->DriverBindingHandle,
306 Controller
307 );
308
309 return Status;
310 }
311
312 BOOLEAN mbStarted = FALSE;
313
314 /**
315 Starting the Pci SATA Driver.
316
317 @param This Protocol instance pointer.
318 @param Controller Handle of device to test.
319 @param RemainingDevicePath Not used.
320
321 @return EFI_SUCCESS supports this device.
322 @return EFI_UNSUPPORTED do not support this device.
323 @return EFI_DEVICE_ERROR cannot be started due to device Error.
324 @return EFI_OUT_OF_RESOURCES cannot allocate resources.
325
326 **/
327 EFI_STATUS
328 EFIAPI
329 SataSiI3132DriverBindingStart (
330 IN EFI_DRIVER_BINDING_PROTOCOL *This,
331 IN EFI_HANDLE Controller,
332 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
333 )
334 {
335 EFI_STATUS Status;
336 EFI_PCI_IO_PROTOCOL *PciIo;
337 UINT64 Supports;
338 UINT64 OriginalPciAttributes;
339 BOOLEAN PciAttributesSaved;
340 UINT32 PciID;
341 SATA_SI3132_INSTANCE *SataSiI3132Instance = NULL;
342
343 SATA_TRACE ("SataSiI3132DriverBindingStart()");
344
345 //TODO: Find a nicer way to do it !
346 if (mbStarted) {
347 return EFI_SUCCESS; // Don't restart me !
348 }
349
350 //
351 // Open the PciIo Protocol
352 //
353 Status = gBS->OpenProtocol (
354 Controller,
355 &gEfiPciIoProtocolGuid,
356 (VOID **) &PciIo,
357 This->DriverBindingHandle,
358 Controller,
359 EFI_OPEN_PROTOCOL_BY_DRIVER
360 );
361 if (EFI_ERROR (Status)) {
362 return Status;
363 }
364
365 PciAttributesSaved = FALSE;
366 //
367 // Save original PCI attributes
368 //
369 Status = PciIo->Attributes (
370 PciIo,
371 EfiPciIoAttributeOperationGet,
372 0,
373 &OriginalPciAttributes
374 );
375 if (EFI_ERROR (Status)) {
376 goto CLOSE_PCIIO;
377 }
378 PciAttributesSaved = TRUE;
379
380 Status = PciIo->Attributes (
381 PciIo,
382 EfiPciIoAttributeOperationSupported,
383 0,
384 &Supports
385 );
386 if (!EFI_ERROR (Status)) {
387 Supports &= EFI_PCI_DEVICE_ENABLE;
388 Status = PciIo->Attributes (
389 PciIo,
390 EfiPciIoAttributeOperationEnable,
391 Supports,
392 NULL
393 );
394 }
395 if (EFI_ERROR (Status)) {
396 DEBUG ((EFI_D_ERROR, "SataSiI3132DriverBindingStart: failed to enable controller\n"));
397 goto CLOSE_PCIIO;
398 }
399
400 //
401 // Get the Pci device class code.
402 //
403 Status = PciIo->Pci.Read (
404 PciIo,
405 EfiPciIoWidthUint32,
406 PCI_VENDOR_ID_OFFSET,
407 1,
408 &PciID
409 );
410 if (EFI_ERROR (Status)) {
411 Status = EFI_UNSUPPORTED;
412 goto CLOSE_PCIIO;
413 }
414
415 //
416 // Test whether the controller belongs to SATA Mass Storage type
417 //
418 if (PciID != ((SATA_SII3132_DEVICE_ID << 16) | SATA_SII3132_VENDOR_ID)) {
419 Status = EFI_UNSUPPORTED;
420 goto CLOSE_PCIIO;
421 }
422
423 // Create SiI3132 Sata Instance
424 Status = SataSiI3132Constructor (PciIo, &SataSiI3132Instance);
425 if (EFI_ERROR (Status)) {
426 return Status;
427 }
428
429 // Initialize SiI3132 Sata Controller
430 Status = SataSiI3132Initialization (SataSiI3132Instance);
431 if (EFI_ERROR (Status)) {
432 return Status;
433 }
434
435 // Install Ata Pass Thru Protocol
436 Status = gBS->InstallProtocolInterface (
437 &Controller,
438 &gEfiAtaPassThruProtocolGuid,
439 EFI_NATIVE_INTERFACE,
440 &(SataSiI3132Instance->AtaPassThruProtocol)
441 );
442 if (EFI_ERROR (Status)) {
443 goto FREE_POOL;
444 }
445
446 /* //
447 // Create event to stop the HC when exit boot service.
448 //
449 Status = gBS->CreateEventEx (
450 EVT_NOTIFY_SIGNAL,
451 TPL_NOTIFY,
452 EhcExitBootService,
453 Ehc,
454 &gEfiEventExitBootServicesGuid,
455 &Ehc->ExitBootServiceEvent
456 );
457 if (EFI_ERROR (Status)) {
458 goto UNINSTALL_USBHC;
459 }*/
460
461 mbStarted = TRUE;
462
463 SATA_TRACE ("SataSiI3132DriverBindingStart() Success!");
464 return EFI_SUCCESS;
465
466 FREE_POOL:
467 //TODO: Free SATA Instance
468
469 CLOSE_PCIIO:
470 if (PciAttributesSaved) {
471 //
472 // Restore original PCI attributes
473 //
474 PciIo->Attributes (
475 PciIo,
476 EfiPciIoAttributeOperationSet,
477 OriginalPciAttributes,
478 NULL
479 );
480 }
481
482 gBS->CloseProtocol (
483 Controller,
484 &gEfiPciIoProtocolGuid,
485 This->DriverBindingHandle,
486 Controller
487 );
488
489 return Status;
490 }
491
492 /**
493 Stop this driver on ControllerHandle. Support stoping any child handles
494 created by this driver.
495
496 @param This Protocol instance pointer.
497 @param Controller Handle of device to stop driver on.
498 @param NumberOfChildren Number of Children in the ChildHandleBuffer.
499 @param ChildHandleBuffer List of handles for the children we need to stop.
500
501 @return EFI_SUCCESS Success.
502 @return EFI_DEVICE_ERROR Fail.
503
504 **/
505 EFI_STATUS
506 EFIAPI
507 SataSiI3132DriverBindingStop (
508 IN EFI_DRIVER_BINDING_PROTOCOL *This,
509 IN EFI_HANDLE Controller,
510 IN UINTN NumberOfChildren,
511 IN EFI_HANDLE *ChildHandleBuffer
512 )
513 {
514 SATA_TRACE ("SataSiI3132DriverBindingStop()");
515 return EFI_UNSUPPORTED;
516 }
517
518 /**
519 Entry point of this driver
520
521 @param ImageHandle Handle of driver image
522 @param SystemTable Point to EFI_SYSTEM_TABLE
523
524 @retval EFI_OUT_OF_RESOURCES Can not allocate memory resource
525 @retval EFI_DEVICE_ERROR Can not install the protocol instance
526 @retval EFI_SUCCESS Success to initialize the Pci host bridge.
527 **/
528 EFI_STATUS
529 EFIAPI
530 InitializeSataSiI3132 (
531 IN EFI_HANDLE ImageHandle,
532 IN EFI_SYSTEM_TABLE *SystemTable
533 )
534 {
535 SATA_TRACE ("InitializeSataSiI3132 ()");
536
537 return EfiLibInstallDriverBindingComponentName2 (
538 ImageHandle,
539 SystemTable,
540 &gSataSiI3132DriverBinding,
541 ImageHandle,
542 &gSataSiI3132ComponentName,
543 &gSataSiI3132ComponentName2
544 );
545 }