Minor changes for ATAPI Srb Functions
[reactos.git] / drivers / storage / storahci / storahci.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GNU GPLv2 only as published by the Free Software Foundation
4 * PURPOSE: To Implement AHCI Miniport driver targeting storport NT 5.2
5 * PROGRAMMERS: Aman Priyadarshi (aman.eureka@gmail.com)
6 */
7
8 #include "storahci.h"
9
10 /**
11 * @name AhciPortInitialize
12 * @implemented
13 *
14 * Initialize port by setting up PxCLB & PxFB Registers
15 *
16 * @param PortExtension
17 *
18 * @return
19 * Return true if intialization was successful
20 */
21 BOOLEAN
22 AhciPortInitialize (
23 __in PAHCI_PORT_EXTENSION PortExtension
24 )
25 {
26 AHCI_PORT_CMD cmd;
27 PAHCI_MEMORY_REGISTERS abar;
28 ULONG mappedLength, portNumber, ticks;
29 PAHCI_ADAPTER_EXTENSION adapterExtension;
30 STOR_PHYSICAL_ADDRESS commandListPhysical, receivedFISPhysical;
31
32 AhciDebugPrint("AhciPortInitialize()\n");
33
34 adapterExtension = PortExtension->AdapterExtension;
35 abar = adapterExtension->ABAR_Address;
36 portNumber = PortExtension->PortNumber;
37
38 NT_ASSERT(abar != NULL);
39 NT_ASSERT(portNumber < adapterExtension->PortCount);
40
41 PortExtension->Port = &abar->PortList[portNumber];
42
43 commandListPhysical = StorPortGetPhysicalAddress(adapterExtension,
44 NULL,
45 PortExtension->CommandList,
46 &mappedLength);
47
48 if ((mappedLength == 0) || ((commandListPhysical.LowPart % 1024) != 0))
49 {
50 AhciDebugPrint("\tcommandListPhysical mappedLength:%d\n", mappedLength);
51 return FALSE;
52 }
53
54 receivedFISPhysical = StorPortGetPhysicalAddress(adapterExtension,
55 NULL,
56 PortExtension->ReceivedFIS,
57 &mappedLength);
58
59 if ((mappedLength == 0) || ((receivedFISPhysical.LowPart % 256) != 0))
60 {
61 AhciDebugPrint("\treceivedFISPhysical mappedLength:%d\n", mappedLength);
62 return FALSE;
63 }
64
65 // Ensure that the controller is not in the running state by reading and examining each
66 // implemented port’s PxCMD register. If PxCMD.ST, PxCMD.CR, PxCMD.FRE and
67 // PxCMD.FR are all cleared, the port is in an idle state. Otherwise, the port is not idle and
68 // should be placed in the idle state prior to manipulating HBA and port specific registers.
69 // System software places a port into the idle state by clearing PxCMD.ST and waiting for
70 // PxCMD.CR to return ‘0’ when read. Software should wait at least 500 milliseconds for
71 // this to occur. If PxCMD.FRE is set to ‘1’, software should clear it to ‘0’ and wait at least
72 // 500 milliseconds for PxCMD.FR to return ‘0’ when read. If PxCMD.CR or PxCMD.FR do
73 // not clear to ‘0’ correctly, then software may attempt a port reset or a full HBA reset to recove
74
75 // TODO: Check if port is in idle state or not, if not then restart port
76 cmd.Status = StorPortReadRegisterUlong(adapterExtension, &PortExtension->Port->CMD);
77 if ((cmd.FR != 0) || (cmd.CR != 0) || (cmd.FRE != 0) || (cmd.ST != 0))
78 {
79 cmd.ST = 0;
80 cmd.FRE = 0;
81
82 ticks = 3;
83 do
84 {
85 StorPortStallExecution(50000);
86 cmd.Status = StorPortReadRegisterUlong(adapterExtension, &PortExtension->Port->CMD);
87 if (ticks == 0)
88 {
89 AhciDebugPrint("\tAttempt to reset port failed: %x\n", cmd);
90 return FALSE;
91 }
92 ticks--;
93 }
94 while(cmd.CR != 0 || cmd.FR != 0);
95 }
96
97 // 10.1.2 For each implemented port, system software shall allocate memory for and program:
98 //  PxCLB and PxCLBU (if CAP.S64A is set to ‘1’)
99 //  PxFB and PxFBU (if CAP.S64A is set to ‘1’)
100 // Note: Assuming 32bit support only
101 StorPortWriteRegisterUlong(adapterExtension, &PortExtension->Port->CLB, commandListPhysical.LowPart);
102 if (IsAdapterCAPS64(adapterExtension->CAP))
103 {
104 StorPortWriteRegisterUlong(adapterExtension, &PortExtension->Port->CLBU, commandListPhysical.HighPart);
105 }
106
107 StorPortWriteRegisterUlong(adapterExtension, &PortExtension->Port->FB, receivedFISPhysical.LowPart);
108 if (IsAdapterCAPS64(adapterExtension->CAP))
109 {
110 StorPortWriteRegisterUlong(adapterExtension, &PortExtension->Port->FBU, receivedFISPhysical.HighPart);
111 }
112
113 PortExtension->IdentifyDeviceDataPhysicalAddress = StorPortGetPhysicalAddress(adapterExtension,
114 NULL,
115 PortExtension->IdentifyDeviceData,
116 &mappedLength);
117
118 // set device power state flag to D0
119 PortExtension->DevicePowerState = StorPowerDeviceD0;
120
121 // clear pending interrupts
122 StorPortWriteRegisterUlong(adapterExtension, &PortExtension->Port->SERR, (ULONG)~0);
123 StorPortWriteRegisterUlong(adapterExtension, &PortExtension->Port->IS, (ULONG)~0);
124 StorPortWriteRegisterUlong(adapterExtension, adapterExtension->IS, (1 << PortExtension->PortNumber));
125
126 return TRUE;
127 }// -- AhciPortInitialize();
128
129 /**
130 * @name AhciAllocateResourceForAdapter
131 * @implemented
132 *
133 * Allocate memory from poll for required pointers
134 *
135 * @param AdapterExtension
136 * @param ConfigInfo
137 *
138 * @return
139 * return TRUE if allocation was successful
140 */
141 BOOLEAN
142 AhciAllocateResourceForAdapter (
143 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
144 __in PPORT_CONFIGURATION_INFORMATION ConfigInfo
145 )
146 {
147 PCHAR nonCachedExtension, tmp;
148 ULONG index, NCS, AlignedNCS;
149 ULONG portCount, portImplemented, nonCachedExtensionSize;
150 PAHCI_PORT_EXTENSION PortExtension;
151
152 AhciDebugPrint("AhciAllocateResourceForAdapter()\n");
153
154 NCS = AHCI_Global_Port_CAP_NCS(AdapterExtension->CAP);
155 AlignedNCS = ROUND_UP(NCS, 8);
156
157 // get port count -- Number of set bits in `AdapterExtension->PortImplemented`
158 portCount = 0;
159 portImplemented = AdapterExtension->PortImplemented;
160
161 NT_ASSERT(portImplemented != 0);
162 for (index = MAXIMUM_AHCI_PORT_COUNT - 1; index > 0; index--)
163 if ((portImplemented & (1 << index)) != 0)
164 break;
165
166 portCount = index + 1;
167 AhciDebugPrint("\tPort Count: %d\n", portCount);
168
169 AdapterExtension->PortCount = portCount;
170 nonCachedExtensionSize = sizeof(AHCI_COMMAND_HEADER) * AlignedNCS + //should be 1K aligned
171 sizeof(AHCI_RECEIVED_FIS) +
172 sizeof(IDENTIFY_DEVICE_DATA);
173
174 // align nonCachedExtensionSize to 1024
175 nonCachedExtensionSize = ROUND_UP(nonCachedExtensionSize, 1024);
176
177 AdapterExtension->NonCachedExtension = StorPortGetUncachedExtension(AdapterExtension,
178 ConfigInfo,
179 nonCachedExtensionSize * portCount);
180
181 if (AdapterExtension->NonCachedExtension == NULL)
182 {
183 AhciDebugPrint("\tadapterExtension->NonCachedExtension == NULL\n");
184 return FALSE;
185 }
186
187 nonCachedExtension = AdapterExtension->NonCachedExtension;
188 AhciZeroMemory(nonCachedExtension, nonCachedExtensionSize * portCount);
189
190 for (index = 0; index < portCount; index++)
191 {
192 PortExtension = &AdapterExtension->PortExtension[index];
193
194 PortExtension->DeviceParams.IsActive = FALSE;
195 if ((AdapterExtension->PortImplemented & (1 << index)) != 0)
196 {
197 PortExtension->PortNumber = index;
198 PortExtension->DeviceParams.IsActive = TRUE;
199 PortExtension->AdapterExtension = AdapterExtension;
200 PortExtension->CommandList = (PAHCI_COMMAND_HEADER)nonCachedExtension;
201
202 tmp = (PCHAR)(nonCachedExtension + sizeof(AHCI_COMMAND_HEADER) * AlignedNCS);
203
204 PortExtension->ReceivedFIS = (PAHCI_RECEIVED_FIS)tmp;
205 PortExtension->IdentifyDeviceData = (PIDENTIFY_DEVICE_DATA)(tmp + sizeof(AHCI_RECEIVED_FIS));
206 PortExtension->MaxPortQueueDepth = NCS;
207 nonCachedExtension += nonCachedExtensionSize;
208 }
209 }
210
211 return TRUE;
212 }// -- AhciAllocateResourceForAdapter();
213
214 /**
215 * @name AhciStartPort
216 * @implemented
217 *
218 * Try to start the port device
219 *
220 * @param AdapterExtension
221 * @param PortExtension
222 *
223 */
224 BOOLEAN
225 AhciStartPort (
226 __in PAHCI_PORT_EXTENSION PortExtension
227 )
228 {
229 ULONG index;
230 AHCI_PORT_CMD cmd;
231 AHCI_TASK_FILE_DATA tfd;
232 AHCI_INTERRUPT_ENABLE ie;
233 AHCI_SERIAL_ATA_STATUS ssts;
234 AHCI_SERIAL_ATA_CONTROL sctl;
235 PAHCI_ADAPTER_EXTENSION AdapterExtension;
236
237 AhciDebugPrint("AhciStartPort()\n");
238
239 AdapterExtension = PortExtension->AdapterExtension;
240 cmd.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->CMD);
241
242 if ((cmd.FR == 1) && (cmd.CR == 1) && (cmd.FRE == 1) && (cmd.ST == 1))
243 {
244 // Already Running
245 return TRUE;
246 }
247
248 cmd.SUD = 1;
249 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->CMD, cmd.Status);
250
251 if (((cmd.FR == 1) && (cmd.FRE == 0)) ||
252 ((cmd.CR == 1) && (cmd.ST == 0)))
253 {
254 AhciDebugPrint("\tCOMRESET\n");
255 // perform COMRESET
256 // section 10.4.2
257
258 // Software causes a port reset (COMRESET) by writing 1h to the PxSCTL.DET field to invoke a
259 // COMRESET on the interface and start a re-establishment of Phy layer communications. Software shall
260 // wait at least 1 millisecond before clearing PxSCTL.DET to 0h; this ensures that at least one COMRESET
261 // signal is sent over the interface. After clearing PxSCTL.DET to 0h, software should wait for
262 // communication to be re-established as indicated by PxSSTS.DET being set to 3h. Then software should
263 // write all 1s to the PxSERR register to clear any bits that were set as part of the port reset.
264
265 sctl.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->SCTL);
266 sctl.DET = 1;
267 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->SCTL, sctl.Status);
268
269 StorPortStallExecution(1000);
270
271 sctl.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->SCTL);
272 sctl.DET = 0;
273 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->SCTL, sctl.Status);
274
275 // Poll DET to verify if a device is attached to the port
276 index = 0;
277 do
278 {
279 StorPortStallExecution(1000);
280 ssts.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->SSTS);
281
282 index++;
283 if (ssts.DET != 0)
284 {
285 break;
286 }
287 }
288 while(index < 30);
289 }
290
291 ssts.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->SSTS);
292 switch (ssts.DET)
293 {
294 case 0x3:
295 {
296 NT_ASSERT(cmd.ST == 0);
297
298 // make sure FIS Recieve is enabled (cmd.FRE)
299 index = 0;
300 do
301 {
302 StorPortStallExecution(10000);
303 cmd.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->CMD);
304 cmd.FRE = 1;
305 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->CMD, cmd.Status);
306 index++;
307 }
308 while((cmd.FR != 1) && (index < 3));
309
310 if (cmd.FR != 1)
311 {
312 // failed to start FIS DMA engine
313 // it can crash the driver later
314 // so better to turn this port off
315 return FALSE;
316 }
317
318 // start port channel
319 // set cmd.ST
320
321 NT_ASSERT(cmd.FRE == 1);
322 NT_ASSERT(cmd.CR == 0);
323
324 // why assert? well If we face such condition on DET = 0x3
325 // then we don't have port in idle state and hence before executing this part of code
326 // we must have restarted it.
327 tfd.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->TFD);
328
329 if ((tfd.STS.BSY) || (tfd.STS.DRQ))
330 {
331 AhciDebugPrint("\tUnhandled Case BSY-DRQ\n");
332 }
333
334 // clear pending interrupts
335 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->SERR, (ULONG)~0);
336 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->IS, (ULONG)~0);
337 StorPortWriteRegisterUlong(AdapterExtension, AdapterExtension->IS, (1 << PortExtension->PortNumber));
338
339 // set IE
340 ie.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->IE);
341 /* Device to Host Register FIS Interrupt Enable */
342 ie.DHRE = 1;
343 /* PIO Setup FIS Interrupt Enable */
344 ie.PSE = 1;
345 /* DMA Setup FIS Interrupt Enable */
346 ie.DSE = 1;
347 /* Set Device Bits FIS Interrupt Enable */
348 ie.SDBE = 1;
349 /* Unknown FIS Interrupt Enable */
350 ie.UFE = 0;
351 /* Descriptor Processed Interrupt Enable */
352 ie.DPE = 0;
353 /* Port Change Interrupt Enable */
354 ie.PCE = 1;
355 /* Device Mechanical Presence Enable */
356 ie.DMPE = 0;
357 /* PhyRdy Change Interrupt Enable */
358 ie.PRCE = 1;
359 /* Incorrect Port Multiplier Enable */
360 ie.IPME = 0;
361 /* Overflow Enable */
362 ie.OFE = 1;
363 /* Interface Non-fatal Error Enable */
364 ie.INFE = 1;
365 /* Interface Fatal Error Enable */
366 ie.IFE = 1;
367 /* Host Bus Data Error Enable */
368 ie.HBDE = 1;
369 /* Host Bus Fatal Error Enable */
370 ie.HBFE = 1;
371 /* Task File Error Enable */
372 ie.TFEE = 1;
373
374 cmd.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->CMD);
375 /* Cold Presence Detect Enable */
376 if (cmd.CPD) // does it support CPD?
377 {
378 // disable it for now
379 ie.CPDE = 0;
380 }
381
382 // should I replace this to single line?
383 // by directly setting ie.Status?
384
385 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->IE, ie.Status);
386
387 cmd.ST = 1;
388 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->CMD, cmd.Status);
389 cmd.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->CMD);
390
391 if (cmd.ST != 1)
392 {
393 AhciDebugPrint("\tFailed to start Port\n");
394 return FALSE;
395 }
396
397 return TRUE;
398 }
399 default:
400 // unhandled case
401 AhciDebugPrint("\tDET == %x Unsupported\n", ssts.DET);
402 return FALSE;
403 }
404 }// -- AhciStartPort();
405
406 /**
407 * @name AhciCommandCompletionDpcRoutine
408 * @implemented
409 *
410 * Handles Completed Commands
411 *
412 * @param Dpc
413 * @param AdapterExtension
414 * @param SystemArgument1
415 * @param SystemArgument2
416 */
417 VOID
418 AhciCommandCompletionDpcRoutine (
419 __in PSTOR_DPC Dpc,
420 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
421 __in PAHCI_PORT_EXTENSION PortExtension,
422 __in PVOID SystemArgument2
423 )
424 {
425 PSCSI_REQUEST_BLOCK Srb;
426 PAHCI_SRB_EXTENSION SrbExtension;
427 STOR_LOCK_HANDLE lockhandle = {0};
428 PAHCI_COMPLETION_ROUTINE CompletionRoutine;
429
430 UNREFERENCED_PARAMETER(Dpc);
431 UNREFERENCED_PARAMETER(SystemArgument2);
432
433 AhciDebugPrint("AhciCommandCompletionDpcRoutine()\n");
434
435 StorPortAcquireSpinLock(AdapterExtension, InterruptLock, NULL, &lockhandle);
436 Srb = RemoveQueue(&PortExtension->CompletionQueue);
437 StorPortReleaseSpinLock(AdapterExtension, &lockhandle);
438
439 NT_ASSERT(Srb != NULL);
440
441 if (Srb->SrbStatus == SRB_STATUS_PENDING)
442 {
443 Srb->SrbStatus = SRB_STATUS_SUCCESS;
444 }
445 else
446 {
447 return;
448 }
449
450 SrbExtension = GetSrbExtension(Srb);
451
452 CompletionRoutine = SrbExtension->CompletionRoutine;
453 NT_ASSERT(CompletionRoutine != NULL);
454
455 // now it's completion routine responsibility to set SrbStatus
456 CompletionRoutine(PortExtension, Srb);
457
458 StorPortNotification(RequestComplete, AdapterExtension, Srb);
459
460 return;
461 }// -- AhciCommandCompletionDpcRoutine();
462
463 /**
464 * @name AhciHwPassiveInitialize
465 * @implemented
466 *
467 * initializes the HBA and finds all devices that are of interest to the miniport driver. (at PASSIVE LEVEL)
468 *
469 * @param adapterExtension
470 *
471 * @return
472 * return TRUE if intialization was successful
473 */
474 BOOLEAN
475 AhciHwPassiveInitialize (
476 __in PAHCI_ADAPTER_EXTENSION AdapterExtension
477 )
478 {
479 ULONG index;
480 PAHCI_PORT_EXTENSION PortExtension;
481
482 AhciDebugPrint("AhciHwPassiveInitialize()\n");
483
484 for (index = 0; index < AdapterExtension->PortCount; index++)
485 {
486 if ((AdapterExtension->PortImplemented & (0x1 << index)) != 0)
487 {
488 PortExtension = &AdapterExtension->PortExtension[index];
489 PortExtension->DeviceParams.IsActive = AhciStartPort(PortExtension);
490 StorPortInitializeDpc(AdapterExtension, &PortExtension->CommandCompletion, AhciCommandCompletionDpcRoutine);
491 }
492 }
493
494 return TRUE;
495 }// -- AhciHwPassiveInitialize();
496
497 /**
498 * @name AhciHwInitialize
499 * @implemented
500 *
501 * initializes the HBA and finds all devices that are of interest to the miniport driver.
502 *
503 * @param adapterExtension
504 *
505 * @return
506 * return TRUE if intialization was successful
507 */
508 BOOLEAN
509 AhciHwInitialize (
510 __in PAHCI_ADAPTER_EXTENSION AdapterExtension
511 )
512 {
513 AHCI_GHC ghc;
514
515 AhciDebugPrint("AhciHwInitialize()\n");
516
517 AdapterExtension->StateFlags.MessagePerPort = FALSE;
518
519 // First check what type of interrupt/synchronization device is using
520 ghc.Status = StorPortReadRegisterUlong(AdapterExtension, &AdapterExtension->ABAR_Address->GHC);
521
522 // When set to ‘1’ by hardware, indicates that the HBA requested more than one MSI vector
523 // but has reverted to using the first vector only. When this bit is cleared to ‘0’,
524 // the HBA has not reverted to single MSI mode (i.e. hardware is already in single MSI mode,
525 // software has allocated the number of messages requested
526 if (ghc.MRSM == 0)
527 {
528 AdapterExtension->StateFlags.MessagePerPort = TRUE;
529 AhciDebugPrint("\tMultiple MSI based message not supported\n");
530 }
531
532 StorPortEnablePassiveInitialization(AdapterExtension, AhciHwPassiveInitialize);
533
534 return TRUE;
535 }// -- AhciHwInitialize();
536
537 /**
538 * @name AhciCompleteIssuedSrb
539 * @implemented
540 *
541 * Complete issued Srbs
542 *
543 * @param PortExtension
544 *
545 */
546 VOID
547 AhciCompleteIssuedSrb (
548 __in PAHCI_PORT_EXTENSION PortExtension,
549 __in ULONG CommandsToComplete
550 )
551 {
552 ULONG NCS, i;
553 PSCSI_REQUEST_BLOCK Srb;
554 PAHCI_SRB_EXTENSION SrbExtension;
555 PAHCI_ADAPTER_EXTENSION AdapterExtension;
556
557 AhciDebugPrint("AhciCompleteIssuedSrb()\n");
558
559 NT_ASSERT(CommandsToComplete != 0);
560
561 AhciDebugPrint("\tCompleted Commands: %d\n", CommandsToComplete);
562
563 AdapterExtension = PortExtension->AdapterExtension;
564 NCS = AHCI_Global_Port_CAP_NCS(AdapterExtension->CAP);
565
566 for (i = 0; i < NCS; i++)
567 {
568 if (((1 << i) & CommandsToComplete) != 0)
569 {
570 Srb = PortExtension->Slot[i];
571
572 if (Srb == NULL)
573 {
574 continue;
575 }
576
577 SrbExtension = GetSrbExtension(Srb);
578 NT_ASSERT(SrbExtension != NULL);
579
580 if (SrbExtension->CompletionRoutine != NULL)
581 {
582 AddQueue(&PortExtension->CompletionQueue, Srb);
583 StorPortIssueDpc(AdapterExtension, &PortExtension->CommandCompletion, PortExtension, Srb);
584 }
585 else
586 {
587 NT_ASSERT(Srb->SrbStatus == SRB_STATUS_PENDING);
588 Srb->SrbStatus = SRB_STATUS_SUCCESS;
589 StorPortNotification(RequestComplete, AdapterExtension, Srb);
590 }
591 }
592 }
593
594 return;
595 }// -- AhciCompleteIssuedSrb();
596
597 /**
598 * @name AhciInterruptHandler
599 * @not_implemented
600 *
601 * Interrupt Handler for PortExtension
602 *
603 * @param PortExtension
604 *
605 */
606 VOID
607 AhciInterruptHandler (
608 __in PAHCI_PORT_EXTENSION PortExtension
609 )
610 {
611 ULONG is, ci, sact, outstanding;
612 AHCI_INTERRUPT_STATUS PxIS;
613 AHCI_INTERRUPT_STATUS PxISMasked;
614 PAHCI_ADAPTER_EXTENSION AdapterExtension;
615
616 AhciDebugPrint("AhciInterruptHandler()\n");
617 AhciDebugPrint("\tPort Number: %d\n", PortExtension->PortNumber);
618
619 AdapterExtension = PortExtension->AdapterExtension;
620 NT_ASSERT(IsPortValid(AdapterExtension, PortExtension->PortNumber));
621
622 // 5.5.3
623 // 1. Software determines the cause of the interrupt by reading the PxIS register.
624 // It is possible for multiple bits to be set
625 // 2. Software clears appropriate bits in the PxIS register corresponding to the cause of the interrupt.
626 // 3. Software clears the interrupt bit in IS.IPS corresponding to the port.
627 // 4. If executing non-queued commands, software reads the PxCI register, and compares the current value to
628 // the list of commands previously issued by software that are still outstanding.
629 // If executing native queued commands, software reads the PxSACT register and compares the current
630 // value to the list of commands previously issued by software.
631 // Software completes with success any outstanding command whose corresponding bit has been cleared in
632 // the respective register. PxCI and PxSACT are volatile registers; software should only use their values
633 // to determine commands that have completed, not to determine which commands have previously been issued.
634 // 5. If there were errors, noted in the PxIS register, software performs error recovery actions (see section 6.2.2).
635 PxISMasked.Status = 0;
636 PxIS.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->IS);
637
638 // 6.2.2
639 // Fatal Error
640 // signified by the setting of PxIS.HBFS, PxIS.HBDS, PxIS.IFS, or PxIS.TFES
641 if (PxIS.HBFS || PxIS.HBDS || PxIS.IFS || PxIS.TFES)
642 {
643 // In this state, the HBA shall not issue any new commands nor acknowledge DMA Setup FISes to process
644 // any native command queuing commands. To recover, the port must be restarted
645 // To detect an error that requires software recovery actions to be performed,
646 // software should check whether any of the following status bits are set on an interrupt:
647 // PxIS.HBFS, PxIS.HBDS, PxIS.IFS, and PxIS.TFES. If any of these bits are set,
648 // software should perform the appropriate error recovery actions based on whether
649 // non-queued commands were being issued or native command queuing commands were being issued.
650
651 AhciDebugPrint("\tFatal Error: %x\n", PxIS.Status);
652 }
653
654 // Normal Command Completion
655 // 3.3.5
656 // A D2H Register FIS has been received with the ‘I’ bit set, and has been copied into system memory.
657 PxISMasked.DHRS = PxIS.DHRS;
658 // A PIO Setup FIS has been received with the ‘I’ bit set, it has been copied into system memory.
659 PxISMasked.PSS = PxIS.PSS;
660 // A DMA Setup FIS has been received with the ‘I’ bit set and has been copied into system memory.
661 PxISMasked.DSS = PxIS.DSS;
662 // A Set Device Bits FIS has been received with the ‘I’ bit set and has been copied into system memory/
663 PxISMasked.SDBS = PxIS.SDBS;
664 // A PRD with the ‘I’ bit set has transferred all of its data.
665 PxISMasked.DPS = PxIS.DPS;
666
667 if (PxISMasked.Status != 0)
668 {
669 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->IS, PxISMasked.Status);
670 }
671
672 // 10.7.1.1
673 // Clear port interrupt
674 // It is set by the level of the virtual interrupt line being a set, and cleared by a write of ‘1’ from the software.
675 is = (1 << PortExtension->PortNumber);
676 StorPortWriteRegisterUlong(AdapterExtension, AdapterExtension->IS, is);
677
678 ci = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->CI);
679 sact = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->SACT);
680
681 outstanding = ci | sact; // NOTE: Including both non-NCQ and NCQ based commands
682 if ((PortExtension->CommandIssuedSlots & (~outstanding)) != 0)
683 {
684 AhciCompleteIssuedSrb(PortExtension, (PortExtension->CommandIssuedSlots & (~outstanding)));
685 PortExtension->CommandIssuedSlots &= outstanding;
686 }
687
688 return;
689 }// -- AhciInterruptHandler();
690
691 /**
692 * @name AhciHwInterrupt
693 * @implemented
694 *
695 * The Storport driver calls the HwStorInterrupt routine after the HBA generates an interrupt request.
696 *
697 * @param AdapterExtension
698 *
699 * @return
700 * return TRUE Indicates that an interrupt was pending on adapter.
701 * return FALSE Indicates the interrupt was not ours.
702 */
703 BOOLEAN
704 AhciHwInterrupt (
705 __in PAHCI_ADAPTER_EXTENSION AdapterExtension
706 )
707 {
708 ULONG portPending, nextPort, i, portCount;
709
710 if (AdapterExtension->StateFlags.Removed)
711 {
712 return FALSE;
713 }
714
715 portPending = StorPortReadRegisterUlong(AdapterExtension, AdapterExtension->IS);
716
717 // we process interrupt for implemented ports only
718 portCount = AdapterExtension->PortCount;
719 portPending = portPending & AdapterExtension->PortImplemented;
720
721 if (portPending == 0)
722 {
723 return FALSE;
724 }
725
726 for (i = 1; i <= portCount; i++)
727 {
728 nextPort = (AdapterExtension->LastInterruptPort + i) % portCount;
729 if ((portPending & (0x1 << nextPort)) == 0)
730 continue;
731
732 NT_ASSERT(IsPortValid(AdapterExtension, nextPort));
733
734 if (AdapterExtension->PortExtension[nextPort].DeviceParams.IsActive == FALSE)
735 {
736 continue;
737 }
738
739 // we can assign this interrupt to this port
740 AdapterExtension->LastInterruptPort = nextPort;
741 AhciInterruptHandler(&AdapterExtension->PortExtension[nextPort]);
742
743 portPending &= ~(1 << nextPort);
744
745 // interrupt belongs to this device
746 // should always return TRUE
747 return TRUE;
748 }
749
750 AhciDebugPrint("\tSomething went wrong");
751 return FALSE;
752 }// -- AhciHwInterrupt();
753
754 /**
755 * @name AhciHwStartIo
756 * @not_implemented
757 *
758 * The Storport driver calls the HwStorStartIo routine one time for each incoming I/O request.
759 *
760 * @param adapterExtension
761 * @param Srb
762 *
763 * @return
764 * return TRUE if the request was accepted
765 * return FALSE if the request must be submitted later
766 */
767 BOOLEAN
768 AhciHwStartIo (
769 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
770 __in PSCSI_REQUEST_BLOCK Srb
771 )
772 {
773 AhciDebugPrint("AhciHwStartIo()\n");
774
775 if (!IsPortValid(AdapterExtension, Srb->PathId))
776 {
777 Srb->SrbStatus = SRB_STATUS_NO_DEVICE;
778 StorPortNotification(RequestComplete, AdapterExtension, Srb);
779 return TRUE;
780 }
781
782 switch(Srb->Function)
783 {
784 case SRB_FUNCTION_PNP:
785 {
786 // https://msdn.microsoft.com/windows/hardware/drivers/storage/handling-srb-function-pnp
787 // If the function member of an SRB is set to SRB_FUNCTION_PNP,
788 // the SRB is a structure of type SCSI_PNP_REQUEST_BLOCK.
789
790 PSCSI_PNP_REQUEST_BLOCK pnpRequest;
791 pnpRequest = (PSCSI_PNP_REQUEST_BLOCK)Srb;
792 if ((pnpRequest->SrbPnPFlags & SRB_PNP_FLAGS_ADAPTER_REQUEST) != 0)
793 {
794 switch(pnpRequest->PnPAction)
795 {
796 case StorRemoveDevice:
797 case StorSurpriseRemoval:
798 {
799 Srb->SrbStatus = SRB_STATUS_SUCCESS;
800 AdapterExtension->StateFlags.Removed = 1;
801 AhciDebugPrint("\tAdapter removed\n");
802 }
803 break;
804 case StorStopDevice:
805 {
806 Srb->SrbStatus = SRB_STATUS_SUCCESS;
807 AhciDebugPrint("\tRequested to Stop the adapter\n");
808 }
809 break;
810 default:
811 Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
812 break;
813 }
814 }
815 else
816 {
817 Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
818 }
819 }
820 break;
821 case SRB_FUNCTION_EXECUTE_SCSI:
822 {
823 // https://msdn.microsoft.com/en-us/windows/hardware/drivers/storage/handling-srb-function-execute-scsi
824 // On receipt of an SRB_FUNCTION_EXECUTE_SCSI request, a miniport driver's HwScsiStartIo
825 // routine does the following:
826 //
827 // - Gets and/or sets up whatever context the miniport driver maintains in its device,
828 // logical unit, and/or SRB extensions
829 // For example, a miniport driver might set up a logical unit extension with pointers
830 // to the SRB itself and the SRB DataBuffer pointer, the SRB DataTransferLength value,
831 // and a driver-defined value (or CDB SCSIOP_XXX value) indicating the operation to be
832 // carried out on the HBA.
833 //
834 // - Calls an internal routine to program the HBA, as partially directed by the SrbFlags,
835 // for the requested operation
836 // For a device I/O operation, such an internal routine generally selects the target device
837 // and sends the CDB over the bus to the target logical unit.
838 PCDB cdb = (PCDB)&Srb->Cdb;
839 if (Srb->CdbLength == 0)
840 {
841 AhciDebugPrint("\tOperationCode: %d\n", cdb->CDB10.OperationCode);
842 Srb->SrbStatus = SRB_STATUS_BAD_FUNCTION;
843 break;
844 }
845
846 NT_ASSERT(cdb != NULL);
847
848 switch(cdb->CDB10.OperationCode)
849 {
850 case SCSIOP_INQUIRY:
851 Srb->SrbStatus = DeviceInquiryRequest(AdapterExtension, Srb, cdb);
852 break;
853 case SCSIOP_REPORT_LUNS:
854 Srb->SrbStatus = DeviceReportLuns(AdapterExtension, Srb, cdb);
855 break;
856 case SCSIOP_READ_CAPACITY:
857 Srb->SrbStatus = DeviceRequestCapacity(AdapterExtension, Srb, cdb);
858 break;
859 case SCSIOP_TEST_UNIT_READY:
860 Srb->SrbStatus = DeviceRequestComplete(AdapterExtension, Srb, cdb);
861 break;
862 case SCSIOP_MODE_SENSE:
863 Srb->SrbStatus = DeviceRequestSense(AdapterExtension, Srb, cdb);
864 break;
865 case SCSIOP_READ:
866 case SCSIOP_WRITE:
867 Srb->SrbStatus = DeviceRequestReadWrite(AdapterExtension, Srb, cdb);
868 break;
869 default:
870 AhciDebugPrint("\tOperationCode: %d\n", cdb->CDB10.OperationCode);
871 Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
872 break;
873 }
874 }
875 break;
876 default:
877 AhciDebugPrint("\tUnknown function code recieved: %x\n", Srb->Function);
878 Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
879 break;
880 }
881
882 if (Srb->SrbStatus != SRB_STATUS_PENDING)
883 {
884 StorPortNotification(RequestComplete, AdapterExtension, Srb);
885 }
886 else
887 {
888 AhciProcessIO(AdapterExtension, Srb->PathId, Srb);
889 }
890 return TRUE;
891 }// -- AhciHwStartIo();
892
893 /**
894 * @name AhciHwResetBus
895 * @not_implemented
896 *
897 * The HwStorResetBus routine is called by the port driver to clear error conditions.
898 *
899 * @param adapterExtension
900 * @param PathId
901 *
902 * @return
903 * return TRUE if bus was successfully reset
904 */
905 BOOLEAN
906 AhciHwResetBus (
907 __in PVOID AdapterExtension,
908 __in ULONG PathId
909 )
910 {
911 STOR_LOCK_HANDLE lockhandle = {0};
912 PAHCI_ADAPTER_EXTENSION adapterExtension;
913
914 AhciDebugPrint("AhciHwResetBus()\n");
915
916 adapterExtension = AdapterExtension;
917
918 if (IsPortValid(AdapterExtension, PathId))
919 {
920 // Acquire Lock
921 StorPortAcquireSpinLock(AdapterExtension, InterruptLock, NULL, &lockhandle);
922
923 // TODO: Perform port reset
924
925 // Release lock
926 StorPortReleaseSpinLock(AdapterExtension, &lockhandle);
927 }
928
929 return FALSE;
930 }// -- AhciHwResetBus();
931
932 /**
933 * @name AhciHwFindAdapter
934 * @implemented
935 *
936 * The HwStorFindAdapter routine uses the supplied configuration to determine whether a specific
937 * HBA is supported and, if it is, to return configuration information about that adapter.
938 *
939 * 10.1 Platform Communication
940 * http://www.intel.in/content/dam/www/public/us/en/documents/technical-specifications/serial-ata-ahci-spec-rev1_2.pdf
941
942 * @param DeviceExtension
943 * @param HwContext
944 * @param BusInformation
945 * @param ArgumentString
946 * @param ConfigInfo
947 * @param Reserved3
948 *
949 * @return
950 * SP_RETURN_FOUND
951 * Indicates that a supported HBA was found and that the HBA-relevant configuration information was successfully determined and set in the PORT_CONFIGURATION_INFORMATION structure.
952 *
953 * SP_RETURN_ERROR
954 * Indicates that an HBA was found but there was an error obtaining the configuration information. If possible, such an error should be logged with StorPortLogError.
955 *
956 * SP_RETURN_BAD_CONFIG
957 * Indicates that the supplied configuration information was invalid for the adapter.
958 *
959 * SP_RETURN_NOT_FOUND
960 * Indicates that no supported HBA was found for the supplied configuration information.
961 *
962 * @remarks Called by Storport.
963 */
964 ULONG
965 AhciHwFindAdapter (
966 __in PVOID AdapterExtension,
967 __in PVOID HwContext,
968 __in PVOID BusInformation,
969 __in PVOID ArgumentString,
970 __inout PPORT_CONFIGURATION_INFORMATION ConfigInfo,
971 __in PBOOLEAN Reserved3
972 )
973 {
974 AHCI_GHC ghc;
975 ULONG index, pci_cfg_len;
976 PACCESS_RANGE accessRange;
977 UCHAR pci_cfg_buf[sizeof(PCI_COMMON_CONFIG)];
978
979 PAHCI_MEMORY_REGISTERS abar;
980 PPCI_COMMON_CONFIG pciConfigData;
981 PAHCI_ADAPTER_EXTENSION adapterExtension;
982
983 AhciDebugPrint("AhciHwFindAdapter()\n");
984
985 UNREFERENCED_PARAMETER(HwContext);
986 UNREFERENCED_PARAMETER(BusInformation);
987 UNREFERENCED_PARAMETER(ArgumentString);
988 UNREFERENCED_PARAMETER(Reserved3);
989
990 adapterExtension = AdapterExtension;
991 adapterExtension->SlotNumber = ConfigInfo->SlotNumber;
992 adapterExtension->SystemIoBusNumber = ConfigInfo->SystemIoBusNumber;
993
994 // get PCI configuration header
995 pci_cfg_len = StorPortGetBusData(
996 adapterExtension,
997 PCIConfiguration,
998 adapterExtension->SystemIoBusNumber,
999 adapterExtension->SlotNumber,
1000 pci_cfg_buf,
1001 sizeof(PCI_COMMON_CONFIG));
1002
1003 if (pci_cfg_len != sizeof(PCI_COMMON_CONFIG))
1004 {
1005 AhciDebugPrint("\tpci_cfg_len != %d :: %d", sizeof(PCI_COMMON_CONFIG), pci_cfg_len);
1006 return SP_RETURN_ERROR;//Not a valid device at the given bus number
1007 }
1008
1009 pciConfigData = (PPCI_COMMON_CONFIG)pci_cfg_buf;
1010 adapterExtension->VendorID = pciConfigData->VendorID;
1011 adapterExtension->DeviceID = pciConfigData->DeviceID;
1012 adapterExtension->RevisionID = pciConfigData->RevisionID;
1013 // The last PCI base address register (BAR[5], header offset 0x24) points to the AHCI base memory, it’s called ABAR (AHCI Base Memory Register).
1014 adapterExtension->AhciBaseAddress = pciConfigData->u.type0.BaseAddresses[5] & (0xFFFFFFF0);
1015
1016 AhciDebugPrint("\tVendorID:%d DeviceID:%d RevisionID:%d\n", adapterExtension->VendorID,
1017 adapterExtension->DeviceID,
1018 adapterExtension->RevisionID);
1019
1020 // 2.1.11
1021 abar = NULL;
1022 if (ConfigInfo->NumberOfAccessRanges > 0)
1023 {
1024 accessRange = *(ConfigInfo->AccessRanges);
1025 for (index = 0; index < ConfigInfo->NumberOfAccessRanges; index++)
1026 {
1027 if (accessRange[index].RangeStart.QuadPart == adapterExtension->AhciBaseAddress)
1028 {
1029 abar = StorPortGetDeviceBase(adapterExtension,
1030 ConfigInfo->AdapterInterfaceType,
1031 ConfigInfo->SystemIoBusNumber,
1032 accessRange[index].RangeStart,
1033 accessRange[index].RangeLength,
1034 !accessRange[index].RangeInMemory);
1035 break;
1036 }
1037 }
1038 }
1039
1040 if (abar == NULL)
1041 {
1042 AhciDebugPrint("\tabar == NULL\n");
1043 return SP_RETURN_ERROR; // corrupted information supplied
1044 }
1045
1046 adapterExtension->ABAR_Address = abar;
1047 adapterExtension->CAP = StorPortReadRegisterUlong(adapterExtension, &abar->CAP);
1048 adapterExtension->CAP2 = StorPortReadRegisterUlong(adapterExtension, &abar->CAP2);
1049 adapterExtension->Version = StorPortReadRegisterUlong(adapterExtension, &abar->VS);
1050 adapterExtension->LastInterruptPort = (ULONG)-1;
1051
1052 // 10.1.2
1053 // 1. Indicate that system software is AHCI aware by setting GHC.AE to ‘1’.
1054 // 3.1.2 -- AE bit is read-write only if CAP.SAM is '0'
1055 ghc.Status = StorPortReadRegisterUlong(adapterExtension, &abar->GHC);
1056 // AE := Highest Significant bit of GHC
1057 if (ghc.AE != 0)// Hmm, controller was already in power state
1058 {
1059 // reset controller to have it in known state
1060 AhciDebugPrint("\tAE Already set, Reset()\n");
1061 if (!AhciAdapterReset(adapterExtension))
1062 {
1063 AhciDebugPrint("\tReset Failed!\n");
1064 return SP_RETURN_ERROR;// reset failed
1065 }
1066 }
1067
1068 ghc.Status = 0;
1069 ghc.AE = 1;// only AE=1
1070 // tell the controller that we know about AHCI
1071 StorPortWriteRegisterUlong(adapterExtension, &abar->GHC, ghc.Status);
1072
1073 adapterExtension->IS = &abar->IS;
1074 adapterExtension->PortImplemented = StorPortReadRegisterUlong(adapterExtension, &abar->PI);
1075
1076 if (adapterExtension->PortImplemented == 0)
1077 {
1078 AhciDebugPrint("\tadapterExtension->PortImplemented == 0\n");
1079 return SP_RETURN_ERROR;
1080 }
1081
1082 ConfigInfo->Master = TRUE;
1083 ConfigInfo->AlignmentMask = 0x3;
1084 ConfigInfo->ScatterGather = TRUE;
1085 ConfigInfo->DmaWidth = Width32Bits;
1086 ConfigInfo->WmiDataProvider = FALSE;
1087 ConfigInfo->Dma32BitAddresses = TRUE;
1088
1089 if (IsAdapterCAPS64(adapterExtension->CAP))
1090 {
1091 ConfigInfo->Dma64BitAddresses = TRUE;
1092 }
1093
1094 ConfigInfo->MaximumNumberOfTargets = 1;
1095 ConfigInfo->ResetTargetSupported = TRUE;
1096 ConfigInfo->NumberOfPhysicalBreaks = 0x21;
1097 ConfigInfo->MaximumNumberOfLogicalUnits = 1;
1098 ConfigInfo->NumberOfBuses = MAXIMUM_AHCI_PORT_COUNT;
1099 ConfigInfo->MaximumTransferLength = MAXIMUM_TRANSFER_LENGTH;
1100 ConfigInfo->SynchronizationModel = StorSynchronizeFullDuplex;
1101
1102 // Turn IE -- Interrupt Enabled
1103 ghc.Status = StorPortReadRegisterUlong(adapterExtension, &abar->GHC);
1104 ghc.IE = 1;
1105 StorPortWriteRegisterUlong(adapterExtension, &abar->GHC, ghc.Status);
1106
1107 // allocate necessary resource for each port
1108 if (!AhciAllocateResourceForAdapter(adapterExtension, ConfigInfo))
1109 {
1110 NT_ASSERT(FALSE);
1111 return SP_RETURN_ERROR;
1112 }
1113
1114 for (index = 0; index < adapterExtension->PortCount; index++)
1115 {
1116 if ((adapterExtension->PortImplemented & (0x1 << index)) != 0)
1117 AhciPortInitialize(&adapterExtension->PortExtension[index]);
1118 }
1119
1120 return SP_RETURN_FOUND;
1121 }// -- AhciHwFindAdapter();
1122
1123 /**
1124 * @name DriverEntry
1125 * @implemented
1126 *
1127 * Initial Entrypoint for storahci miniport driver
1128 *
1129 * @param DriverObject
1130 * @param RegistryPath
1131 *
1132 * @return
1133 * NT_STATUS in case of driver loaded successfully.
1134 */
1135 ULONG
1136 DriverEntry (
1137 __in PVOID DriverObject,
1138 __in PVOID RegistryPath
1139 )
1140 {
1141 ULONG status;
1142 // initialize the hardware data structure
1143 HW_INITIALIZATION_DATA hwInitializationData = {0};
1144
1145 // set size of hardware initialization structure
1146 hwInitializationData.HwInitializationDataSize = sizeof(HW_INITIALIZATION_DATA);
1147
1148 // identity required miniport entry point routines
1149 hwInitializationData.HwStartIo = AhciHwStartIo;
1150 hwInitializationData.HwResetBus = AhciHwResetBus;
1151 hwInitializationData.HwInterrupt = AhciHwInterrupt;
1152 hwInitializationData.HwInitialize = AhciHwInitialize;
1153 hwInitializationData.HwFindAdapter = AhciHwFindAdapter;
1154
1155 // adapter specific information
1156 hwInitializationData.TaggedQueuing = TRUE;
1157 hwInitializationData.AutoRequestSense = TRUE;
1158 hwInitializationData.MultipleRequestPerLu = TRUE;
1159 hwInitializationData.NeedPhysicalAddresses = TRUE;
1160
1161 hwInitializationData.NumberOfAccessRanges = 6;
1162 hwInitializationData.AdapterInterfaceType = PCIBus;
1163 hwInitializationData.MapBuffers = STOR_MAP_NON_READ_WRITE_BUFFERS;
1164
1165 // set required extension sizes
1166 hwInitializationData.SrbExtensionSize = sizeof(AHCI_SRB_EXTENSION);
1167 hwInitializationData.DeviceExtensionSize = sizeof(AHCI_ADAPTER_EXTENSION);
1168
1169 // register our hw init data
1170 status = StorPortInitialize(DriverObject,
1171 RegistryPath,
1172 &hwInitializationData,
1173 NULL);
1174
1175 NT_ASSERT(status == STATUS_SUCCESS);
1176 return status;
1177 }// -- DriverEntry();
1178
1179 /**
1180 * @name AhciATA_CFIS
1181 * @implemented
1182 *
1183 * create ATA CFIS from Srb
1184 *
1185 * @param PortExtension
1186 * @param Srb
1187 *
1188 * @return
1189 * Number of CFIS fields used in DWORD
1190 */
1191 ULONG
1192 AhciATA_CFIS (
1193 __in PAHCI_PORT_EXTENSION PortExtension,
1194 __in PAHCI_SRB_EXTENSION SrbExtension
1195 )
1196 {
1197 PAHCI_COMMAND_TABLE cmdTable;
1198
1199 UNREFERENCED_PARAMETER(PortExtension);
1200
1201 AhciDebugPrint("AhciATA_CFIS()\n");
1202
1203 cmdTable = (PAHCI_COMMAND_TABLE)SrbExtension;
1204
1205 AhciZeroMemory((PCHAR)cmdTable->CFIS, sizeof(cmdTable->CFIS));
1206
1207 cmdTable->CFIS[AHCI_ATA_CFIS_FisType] = FIS_TYPE_REG_H2D; // FIS Type
1208 cmdTable->CFIS[AHCI_ATA_CFIS_PMPort_C] = (1 << 7); // PM Port & C
1209 cmdTable->CFIS[AHCI_ATA_CFIS_CommandReg] = SrbExtension->CommandReg;
1210
1211 cmdTable->CFIS[AHCI_ATA_CFIS_FeaturesLow] = SrbExtension->FeaturesLow;
1212 cmdTable->CFIS[AHCI_ATA_CFIS_LBA0] = SrbExtension->LBA0;
1213 cmdTable->CFIS[AHCI_ATA_CFIS_LBA1] = SrbExtension->LBA1;
1214 cmdTable->CFIS[AHCI_ATA_CFIS_LBA2] = SrbExtension->LBA2;
1215 cmdTable->CFIS[AHCI_ATA_CFIS_Device] = SrbExtension->Device;
1216 cmdTable->CFIS[AHCI_ATA_CFIS_LBA3] = SrbExtension->LBA3;
1217 cmdTable->CFIS[AHCI_ATA_CFIS_LBA4] = SrbExtension->LBA4;
1218 cmdTable->CFIS[AHCI_ATA_CFIS_LBA5] = SrbExtension->LBA5;
1219 cmdTable->CFIS[AHCI_ATA_CFIS_FeaturesHigh] = SrbExtension->FeaturesHigh;
1220 cmdTable->CFIS[AHCI_ATA_CFIS_SectorCountLow] = SrbExtension->SectorCountLow;
1221 cmdTable->CFIS[AHCI_ATA_CFIS_SectorCountHigh] = SrbExtension->SectorCountHigh;
1222
1223 return 5;
1224 }// -- AhciATA_CFIS();
1225
1226 /**
1227 * @name AhciATAPI_CFIS
1228 * @not_implemented
1229 *
1230 * create ATAPI CFIS from Srb
1231 *
1232 * @param PortExtension
1233 * @param Srb
1234 *
1235 * @return
1236 * Number of CFIS fields used in DWORD
1237 */
1238 ULONG
1239 AhciATAPI_CFIS (
1240 __in PAHCI_PORT_EXTENSION PortExtension,
1241 __in PAHCI_SRB_EXTENSION SrbExtension
1242 )
1243 {
1244 PAHCI_COMMAND_TABLE cmdTable;
1245 UNREFERENCED_PARAMETER(PortExtension);
1246
1247 AhciDebugPrint("AhciATAPI_CFIS()\n");
1248
1249 cmdTable = (PAHCI_COMMAND_TABLE)SrbExtension;
1250
1251 NT_ASSERT(SrbExtension->CommandReg == IDE_COMMAND_ATAPI_PACKET);
1252
1253 AhciZeroMemory((PCHAR)cmdTable->CFIS, sizeof(cmdTable->CFIS));
1254
1255 cmdTable->CFIS[AHCI_ATA_CFIS_FisType] = FIS_TYPE_REG_H2D; // FIS Type
1256 cmdTable->CFIS[AHCI_ATA_CFIS_PMPort_C] = (1 << 7); // PM Port & C
1257 cmdTable->CFIS[AHCI_ATA_CFIS_CommandReg] = SrbExtension->CommandReg;
1258
1259 cmdTable->CFIS[AHCI_ATA_CFIS_FeaturesLow] = SrbExtension->FeaturesLow;
1260 cmdTable->CFIS[AHCI_ATA_CFIS_LBA0] = SrbExtension->LBA0;
1261 cmdTable->CFIS[AHCI_ATA_CFIS_LBA1] = SrbExtension->LBA1;
1262 cmdTable->CFIS[AHCI_ATA_CFIS_LBA2] = SrbExtension->LBA2;
1263 cmdTable->CFIS[AHCI_ATA_CFIS_Device] = SrbExtension->Device;
1264 cmdTable->CFIS[AHCI_ATA_CFIS_LBA3] = SrbExtension->LBA3;
1265 cmdTable->CFIS[AHCI_ATA_CFIS_LBA4] = SrbExtension->LBA4;
1266 cmdTable->CFIS[AHCI_ATA_CFIS_LBA5] = SrbExtension->LBA5;
1267 cmdTable->CFIS[AHCI_ATA_CFIS_FeaturesHigh] = SrbExtension->FeaturesHigh;
1268 cmdTable->CFIS[AHCI_ATA_CFIS_SectorCountLow] = SrbExtension->SectorCountLow;
1269 cmdTable->CFIS[AHCI_ATA_CFIS_SectorCountHigh] = SrbExtension->SectorCountHigh;
1270
1271 return 5;
1272 }// -- AhciATAPI_CFIS();
1273
1274 /**
1275 * @name AhciBuild_PRDT
1276 * @implemented
1277 *
1278 * Build PRDT for data transfer
1279 *
1280 * @param PortExtension
1281 * @param Srb
1282 *
1283 * @return
1284 * Return number of entries in PRDT.
1285 */
1286 ULONG
1287 AhciBuild_PRDT (
1288 __in PAHCI_PORT_EXTENSION PortExtension,
1289 __in PAHCI_SRB_EXTENSION SrbExtension
1290 )
1291 {
1292 ULONG index;
1293 PAHCI_COMMAND_TABLE cmdTable;
1294 PLOCAL_SCATTER_GATHER_LIST sgl;
1295 PAHCI_ADAPTER_EXTENSION AdapterExtension;
1296
1297 AhciDebugPrint("AhciBuild_PRDT()\n");
1298
1299 sgl = SrbExtension->pSgl;
1300 cmdTable = (PAHCI_COMMAND_TABLE)SrbExtension;
1301 AdapterExtension = PortExtension->AdapterExtension;
1302
1303 NT_ASSERT(sgl != NULL);
1304 NT_ASSERT(sgl->NumberOfElements < MAXIMUM_AHCI_PRDT_ENTRIES);
1305
1306 for (index = 0; index < sgl->NumberOfElements; index++)
1307 {
1308 NT_ASSERT(sgl->List[index].Length <= MAXIMUM_TRANSFER_LENGTH);
1309
1310 cmdTable->PRDT[index].DBA = sgl->List[index].PhysicalAddress.LowPart;
1311 if (IsAdapterCAPS64(AdapterExtension->CAP))
1312 {
1313 cmdTable->PRDT[index].DBAU = sgl->List[index].PhysicalAddress.HighPart;
1314 }
1315
1316 // Data Byte Count (DBC): A ‘0’ based value that Indicates the length, in bytes, of the data block.
1317 // A maximum of length of 4MB may exist for any entry. Bit ‘0’ of this field must always be ‘1’ to
1318 // indicate an even byte count. A value of ‘1’ indicates 2 bytes, ‘3’ indicates 4 bytes, etc.
1319 cmdTable->PRDT[index].DBC = sgl->List[index].Length - 1;
1320 }
1321
1322 return sgl->NumberOfElements;
1323 }// -- AhciBuild_PRDT();
1324
1325 /**
1326 * @name AhciProcessSrb
1327 * @implemented
1328 *
1329 * Prepare Srb for IO processing
1330 *
1331 * @param PortExtension
1332 * @param Srb
1333 * @param SlotIndex
1334 *
1335 */
1336 VOID
1337 AhciProcessSrb (
1338 __in PAHCI_PORT_EXTENSION PortExtension,
1339 __in PSCSI_REQUEST_BLOCK Srb,
1340 __in ULONG SlotIndex
1341 )
1342 {
1343 ULONG prdtlen, sig, length, cfl;
1344 PAHCI_SRB_EXTENSION SrbExtension;
1345 PAHCI_COMMAND_HEADER CommandHeader;
1346 PAHCI_ADAPTER_EXTENSION AdapterExtension;
1347 STOR_PHYSICAL_ADDRESS CommandTablePhysicalAddress;
1348
1349 AhciDebugPrint("AhciProcessSrb()\n");
1350
1351 NT_ASSERT(Srb->PathId == PortExtension->PortNumber);
1352
1353 SrbExtension = GetSrbExtension(Srb);
1354 AdapterExtension = PortExtension->AdapterExtension;
1355
1356 NT_ASSERT(SrbExtension != NULL);
1357 NT_ASSERT(SrbExtension->AtaFunction != 0);
1358
1359 if ((SrbExtension->AtaFunction == ATA_FUNCTION_ATA_IDENTIFY) &&
1360 (SrbExtension->CommandReg == IDE_COMMAND_NOT_VALID))
1361 {
1362 // Here we are safe to check SIG register
1363 sig = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->SIG);
1364 if (sig == 0x101)
1365 {
1366 AhciDebugPrint("\tATA Device Found!\n");
1367 SrbExtension->CommandReg = IDE_COMMAND_IDENTIFY;
1368 }
1369 else
1370 {
1371 AhciDebugPrint("\tATAPI Device Found!\n");
1372 SrbExtension->CommandReg = IDE_COMMAND_ATAPI_IDENTIFY;
1373 }
1374 }
1375
1376 NT_ASSERT(SlotIndex < AHCI_Global_Port_CAP_NCS(AdapterExtension->CAP));
1377 SrbExtension->SlotIndex = SlotIndex;
1378
1379 // program the CFIS in the CommandTable
1380 CommandHeader = &PortExtension->CommandList[SlotIndex];
1381
1382 cfl = 0;
1383 if (IsAtapiCommand(SrbExtension->AtaFunction))
1384 {
1385 cfl = AhciATAPI_CFIS(PortExtension, SrbExtension);
1386 }
1387 else if (IsAtaCommand(SrbExtension->AtaFunction))
1388 {
1389 cfl = AhciATA_CFIS(PortExtension, SrbExtension);
1390 }
1391 else
1392 {
1393 NT_ASSERT(FALSE);
1394 }
1395
1396 prdtlen = 0;
1397 if (IsDataTransferNeeded(SrbExtension))
1398 {
1399 prdtlen = AhciBuild_PRDT(PortExtension, SrbExtension);
1400 NT_ASSERT(prdtlen != -1);
1401 }
1402
1403 // Program the command header
1404 CommandHeader->DI.PRDTL = prdtlen; // number of entries in PRD table
1405 CommandHeader->DI.CFL = cfl;
1406 CommandHeader->DI.A = (SrbExtension->AtaFunction & ATA_FUNCTION_ATAPI_COMMAND) ? 1 : 0;
1407 CommandHeader->DI.W = (SrbExtension->Flags & ATA_FLAGS_DATA_OUT) ? 1 : 0;
1408 CommandHeader->DI.P = 0; // ATA Specifications says so
1409 CommandHeader->DI.PMP = 0; // Port Multiplier
1410
1411 // Reset -- Manual Configuation
1412 CommandHeader->DI.R = 0;
1413 CommandHeader->DI.B = 0;
1414 CommandHeader->DI.C = 0;
1415
1416 CommandHeader->PRDBC = 0;
1417
1418 CommandHeader->Reserved[0] = 0;
1419 CommandHeader->Reserved[1] = 0;
1420 CommandHeader->Reserved[2] = 0;
1421 CommandHeader->Reserved[3] = 0;
1422
1423 // set CommandHeader CTBA
1424 CommandTablePhysicalAddress = StorPortGetPhysicalAddress(AdapterExtension,
1425 NULL,
1426 SrbExtension,
1427 &length);
1428
1429 NT_ASSERT(length != 0);
1430
1431 // command table alignment
1432 NT_ASSERT((CommandTablePhysicalAddress.LowPart % 128) == 0);
1433
1434 CommandHeader->CTBA = CommandTablePhysicalAddress.LowPart;
1435
1436 if (IsAdapterCAPS64(AdapterExtension->CAP))
1437 {
1438 CommandHeader->CTBA_U = CommandTablePhysicalAddress.HighPart;
1439 }
1440
1441 // mark this slot
1442 PortExtension->Slot[SlotIndex] = Srb;
1443 PortExtension->QueueSlots |= 1 << SlotIndex;
1444 return;
1445 }// -- AhciProcessSrb();
1446
1447 /**
1448 * @name AhciActivatePort
1449 * @implemented
1450 *
1451 * Program Port and populate command list
1452 *
1453 * @param PortExtension
1454 *
1455 */
1456 VOID
1457 AhciActivatePort (
1458 __in PAHCI_PORT_EXTENSION PortExtension
1459 )
1460 {
1461 AHCI_PORT_CMD cmd;
1462 ULONG QueueSlots, slotToActivate, tmp;
1463 PAHCI_ADAPTER_EXTENSION AdapterExtension;
1464
1465 AhciDebugPrint("AhciActivatePort()\n");
1466
1467 AdapterExtension = PortExtension->AdapterExtension;
1468 QueueSlots = PortExtension->QueueSlots;
1469
1470 if (QueueSlots == 0)
1471 {
1472 return;
1473 }
1474
1475 // section 3.3.14
1476 // Bits in this field shall only be set to ‘1’ by software when PxCMD.ST is set to ‘1’
1477 cmd.Status = StorPortReadRegisterUlong(AdapterExtension, &PortExtension->Port->CMD);
1478
1479 if (cmd.ST == 0) // PxCMD.ST == 0
1480 {
1481 return;
1482 }
1483
1484 // get the lowest set bit
1485 tmp = QueueSlots & (QueueSlots - 1);
1486
1487 if (tmp == 0)
1488 slotToActivate = QueueSlots;
1489 else
1490 slotToActivate = (QueueSlots & (~tmp));
1491
1492 // mark that bit off in QueueSlots
1493 // so we can know we it is really needed to activate port or not
1494 PortExtension->QueueSlots &= ~slotToActivate;
1495 // mark this CommandIssuedSlots
1496 // to validate in completeIssuedCommand
1497 PortExtension->CommandIssuedSlots |= slotToActivate;
1498
1499 // tell the HBA to issue this Command Slot to the given port
1500 StorPortWriteRegisterUlong(AdapterExtension, &PortExtension->Port->CI, slotToActivate);
1501
1502 return;
1503 }// -- AhciActivatePort();
1504
1505 /**
1506 * @name AhciProcessIO
1507 * @implemented
1508 *
1509 * Acquire Exclusive lock to port, populate pending commands to command List
1510 * program controller's port to process new commands in command list.
1511 *
1512 * @param AdapterExtension
1513 * @param PathId
1514 * @param Srb
1515 *
1516 */
1517 VOID
1518 AhciProcessIO (
1519 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
1520 __in UCHAR PathId,
1521 __in PSCSI_REQUEST_BLOCK Srb
1522 )
1523 {
1524 PSCSI_REQUEST_BLOCK tmpSrb;
1525 STOR_LOCK_HANDLE lockhandle = {0};
1526 PAHCI_PORT_EXTENSION PortExtension;
1527 ULONG commandSlotMask, occupiedSlots, slotIndex, NCS;
1528
1529 AhciDebugPrint("AhciProcessIO()\n");
1530 AhciDebugPrint("\tPathId: %d\n", PathId);
1531
1532 PortExtension = &AdapterExtension->PortExtension[PathId];
1533
1534 NT_ASSERT(PathId < AdapterExtension->PortCount);
1535
1536 // Acquire Lock
1537 StorPortAcquireSpinLock(AdapterExtension, InterruptLock, NULL, &lockhandle);
1538
1539 // add Srb to queue
1540 AddQueue(&PortExtension->SrbQueue, Srb);
1541
1542 if (PortExtension->DeviceParams.IsActive == FALSE)
1543 {
1544 // Release Lock
1545 StorPortReleaseSpinLock(AdapterExtension, &lockhandle);
1546 return; // we should wait for device to get active
1547 }
1548
1549 occupiedSlots = (PortExtension->QueueSlots | PortExtension->CommandIssuedSlots); // Busy command slots for given port
1550 NCS = AHCI_Global_Port_CAP_NCS(AdapterExtension->CAP);
1551 commandSlotMask = (1 << NCS) - 1; // available slots mask
1552
1553 commandSlotMask = (commandSlotMask & ~occupiedSlots);
1554 if(commandSlotMask != 0)
1555 {
1556 // iterate over HBA port slots
1557 for (slotIndex = 0; slotIndex < NCS; slotIndex++)
1558 {
1559 // find first free slot
1560 if ((commandSlotMask & (1 << slotIndex)) != 0)
1561 {
1562 tmpSrb = RemoveQueue(&PortExtension->SrbQueue);
1563 if (tmpSrb != NULL)
1564 {
1565 NT_ASSERT(tmpSrb->PathId == PathId);
1566 AhciProcessSrb(PortExtension, tmpSrb, slotIndex);
1567 }
1568 else
1569 {
1570 break;
1571 }
1572 }
1573 else
1574 {
1575 break;
1576 }
1577 }
1578 }
1579
1580 // program HBA port
1581 AhciActivatePort(PortExtension);
1582
1583 // Release Lock
1584 StorPortReleaseSpinLock(AdapterExtension, &lockhandle);
1585
1586 return;
1587 }// -- AhciProcessIO();
1588
1589 /**
1590 * @name AtapiInquiryCompletion
1591 * @implemented
1592 *
1593 * AtapiInquiryCompletion routine should be called after device signals
1594 * for device inquiry request is completed (through interrupt) -- ATAPI Device only
1595 *
1596 * @param PortExtension
1597 * @param Srb
1598 *
1599 */
1600 VOID
1601 AtapiInquiryCompletion (
1602 __in PAHCI_PORT_EXTENSION PortExtension,
1603 __in PSCSI_REQUEST_BLOCK Srb
1604 )
1605 {
1606 BOOLEAN status;
1607 PAHCI_ADAPTER_EXTENSION AdapterExtension;
1608
1609 AhciDebugPrint("AtapiInquiryCompletion()\n");
1610
1611 NT_ASSERT(Srb != NULL);
1612 NT_ASSERT(PortExtension != NULL);
1613
1614 AdapterExtension = PortExtension->AdapterExtension;
1615
1616 // send queue depth
1617 status = StorPortSetDeviceQueueDepth(PortExtension->AdapterExtension,
1618 Srb->PathId,
1619 Srb->TargetId,
1620 Srb->Lun,
1621 AHCI_Global_Port_CAP_NCS(AdapterExtension->CAP));
1622
1623 NT_ASSERT(status == TRUE);
1624 return;
1625 }// -- AtapiInquiryCompletion();
1626
1627 /**
1628 * @name InquiryCompletion
1629 * @implemented
1630 *
1631 * InquiryCompletion routine should be called after device signals
1632 * for device inquiry request is completed (through interrupt)
1633 *
1634 * @param PortExtension
1635 * @param Srb
1636 *
1637 */
1638 VOID
1639 InquiryCompletion (
1640 __in PAHCI_PORT_EXTENSION PortExtension,
1641 __in PSCSI_REQUEST_BLOCK Srb
1642 )
1643 {
1644 PCDB cdb;
1645 BOOLEAN status;
1646 PINQUIRYDATA InquiryData;
1647 PAHCI_SRB_EXTENSION SrbExtension;
1648 PAHCI_ADAPTER_EXTENSION AdapterExtension;
1649 PIDENTIFY_DEVICE_DATA IdentifyDeviceData;
1650
1651 AhciDebugPrint("InquiryCompletion()\n");
1652
1653 NT_ASSERT(Srb != NULL);
1654 NT_ASSERT(PortExtension != NULL);
1655
1656 cdb = (PCDB)&Srb->Cdb;
1657 InquiryData = Srb->DataBuffer;
1658 SrbExtension = GetSrbExtension(Srb);
1659 AdapterExtension = PortExtension->AdapterExtension;
1660 IdentifyDeviceData = PortExtension->IdentifyDeviceData;
1661
1662 if (Srb->SrbStatus != SRB_STATUS_SUCCESS)
1663 {
1664 if (Srb->SrbStatus == SRB_STATUS_NO_DEVICE)
1665 {
1666 PortExtension->DeviceParams.DeviceType = AHCI_DEVICE_TYPE_NODEVICE;
1667 }
1668 return;
1669 }
1670
1671 NT_ASSERT(InquiryData != NULL);
1672 NT_ASSERT(Srb->SrbStatus == SRB_STATUS_SUCCESS);
1673
1674 // Device specific data
1675 PortExtension->DeviceParams.MaxLba.QuadPart = 0;
1676
1677 if (SrbExtension->CommandReg == IDE_COMMAND_IDENTIFY)
1678 {
1679 PortExtension->DeviceParams.DeviceType = AHCI_DEVICE_TYPE_ATA;
1680 if (IdentifyDeviceData->GeneralConfiguration.RemovableMedia)
1681 {
1682 PortExtension->DeviceParams.RemovableDevice = 1;
1683 }
1684
1685 if ((IdentifyDeviceData->CommandSetSupport.BigLba) && (IdentifyDeviceData->CommandSetActive.BigLba))
1686 {
1687 PortExtension->DeviceParams.Lba48BitMode = 1;
1688 }
1689
1690 PortExtension->DeviceParams.AccessType = DIRECT_ACCESS_DEVICE;
1691
1692 /* Device max address lba */
1693 if (PortExtension->DeviceParams.Lba48BitMode)
1694 {
1695 PortExtension->DeviceParams.MaxLba.LowPart = IdentifyDeviceData->Max48BitLBA[0];
1696 PortExtension->DeviceParams.MaxLba.HighPart = IdentifyDeviceData->Max48BitLBA[1];
1697 }
1698 else
1699 {
1700 PortExtension->DeviceParams.MaxLba.LowPart = IdentifyDeviceData->UserAddressableSectors;
1701 }
1702
1703 /* Bytes Per Logical Sector */
1704 if (IdentifyDeviceData->PhysicalLogicalSectorSize.LogicalSectorLongerThan256Words)
1705 {
1706 AhciDebugPrint("\tBytesPerLogicalSector != DEVICE_ATA_BLOCK_SIZE\n");
1707 NT_ASSERT(FALSE);
1708 }
1709
1710 PortExtension->DeviceParams.BytesPerLogicalSector = DEVICE_ATA_BLOCK_SIZE;
1711
1712 /* Bytes Per Physical Sector */
1713 if (IdentifyDeviceData->PhysicalLogicalSectorSize.MultipleLogicalSectorsPerPhysicalSector)
1714 {
1715 AhciDebugPrint("\tBytesPerPhysicalSector != DEVICE_ATA_BLOCK_SIZE\n");
1716 NT_ASSERT(FALSE);
1717 }
1718
1719 PortExtension->DeviceParams.BytesPerPhysicalSector = DEVICE_ATA_BLOCK_SIZE;
1720
1721 // last byte should be NULL
1722 StorPortCopyMemory(PortExtension->DeviceParams.VendorId, IdentifyDeviceData->ModelNumber, sizeof(PortExtension->DeviceParams.VendorId) - 1);
1723 StorPortCopyMemory(PortExtension->DeviceParams.RevisionID, IdentifyDeviceData->FirmwareRevision, sizeof(PortExtension->DeviceParams.RevisionID) - 1);
1724 StorPortCopyMemory(PortExtension->DeviceParams.SerialNumber, IdentifyDeviceData->SerialNumber, sizeof(PortExtension->DeviceParams.SerialNumber) - 1);
1725
1726 PortExtension->DeviceParams.VendorId[sizeof(PortExtension->DeviceParams.VendorId) - 1] = '\0';
1727 PortExtension->DeviceParams.RevisionID[sizeof(PortExtension->DeviceParams.RevisionID) - 1] = '\0';
1728 PortExtension->DeviceParams.SerialNumber[sizeof(PortExtension->DeviceParams.SerialNumber) - 1] = '\0';
1729
1730 // TODO: Add other device params
1731 AhciDebugPrint("\tATA Device\n");
1732 }
1733 else
1734 {
1735 AhciDebugPrint("\tATAPI Device\n");
1736 PortExtension->DeviceParams.DeviceType = AHCI_DEVICE_TYPE_ATAPI;
1737 PortExtension->DeviceParams.AccessType = READ_ONLY_DIRECT_ACCESS_DEVICE;
1738 }
1739
1740 // INQUIRYDATABUFFERSIZE = 36 ; Defined in storport.h
1741 if (Srb->DataTransferLength < INQUIRYDATABUFFERSIZE)
1742 {
1743 AhciDebugPrint("\tDataBufferLength < sizeof(INQUIRYDATA), Could crash the driver.\n");
1744 NT_ASSERT(FALSE);
1745 }
1746
1747 // update data transfer length
1748 Srb->DataTransferLength = INQUIRYDATABUFFERSIZE;
1749
1750 // prepare data to send
1751 InquiryData->Versions = 2;
1752 InquiryData->Wide32Bit = 1;
1753 InquiryData->CommandQueue = 0; // NCQ not supported
1754 InquiryData->ResponseDataFormat = 0x2;
1755 InquiryData->DeviceTypeModifier = 0;
1756 InquiryData->DeviceTypeQualifier = DEVICE_CONNECTED;
1757 InquiryData->AdditionalLength = INQUIRYDATABUFFERSIZE - 5;
1758 InquiryData->DeviceType = PortExtension->DeviceParams.AccessType;
1759 InquiryData->RemovableMedia = PortExtension->DeviceParams.RemovableDevice;
1760
1761 // Fill VendorID, Product Revision Level and other string fields
1762 StorPortCopyMemory(InquiryData->VendorId, PortExtension->DeviceParams.VendorId, sizeof(InquiryData->VendorId) - 1);
1763 StorPortCopyMemory(InquiryData->ProductId, PortExtension->DeviceParams.RevisionID, sizeof(PortExtension->DeviceParams.RevisionID));
1764 StorPortCopyMemory(InquiryData->ProductRevisionLevel, PortExtension->DeviceParams.SerialNumber, sizeof(InquiryData->ProductRevisionLevel) - 1);
1765
1766 InquiryData->VendorId[sizeof(InquiryData->VendorId) - 1] = '\0';
1767 InquiryData->ProductId[sizeof(InquiryData->ProductId) - 1] = '\0';
1768 InquiryData->ProductRevisionLevel[sizeof(InquiryData->ProductRevisionLevel) - 1] = '\0';
1769
1770 // send queue depth
1771 status = StorPortSetDeviceQueueDepth(PortExtension->AdapterExtension,
1772 Srb->PathId,
1773 Srb->TargetId,
1774 Srb->Lun,
1775 AHCI_Global_Port_CAP_NCS(AdapterExtension->CAP));
1776
1777 NT_ASSERT(status == TRUE);
1778 return;
1779 }// -- InquiryCompletion();
1780
1781 /**
1782 * @name AhciATAPICommand
1783 * @implemented
1784 *
1785 * Handles ATAPI Requests commands
1786 *
1787 * @param AdapterExtension
1788 * @param Srb
1789 * @param Cdb
1790 *
1791 * @return
1792 * return STOR status for AhciATAPICommand
1793 */
1794 UCHAR
1795 AhciATAPICommand (
1796 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
1797 __in PSCSI_REQUEST_BLOCK Srb,
1798 __in PCDB Cdb
1799 )
1800 {
1801 ULONG SrbFlags, DataBufferLength;
1802 PAHCI_SRB_EXTENSION SrbExtension;
1803 PAHCI_PORT_EXTENSION PortExtension;
1804
1805 AhciDebugPrint("AhciATAPICommand()\n");
1806
1807 SrbFlags = Srb->SrbFlags;
1808 SrbExtension = GetSrbExtension(Srb);
1809 DataBufferLength = Srb->DataTransferLength;
1810 PortExtension = &AdapterExtension->PortExtension[Srb->PathId];
1811
1812 NT_ASSERT(PortExtension->DeviceParams.DeviceType == AHCI_DEVICE_TYPE_ATAPI);
1813
1814 NT_ASSERT(SrbExtension != NULL);
1815
1816 SrbExtension->AtaFunction = ATA_FUNCTION_ATAPI_COMMAND;
1817 SrbExtension->Flags = 0;
1818
1819 if (SrbFlags & SRB_FLAGS_DATA_IN)
1820 {
1821 SrbExtension->Flags |= ATA_FLAGS_DATA_IN;
1822 }
1823
1824 if (SrbFlags & SRB_FLAGS_DATA_OUT)
1825 {
1826 SrbExtension->Flags |= ATA_FLAGS_DATA_OUT;
1827 }
1828
1829 SrbExtension->FeaturesLow = 0;
1830
1831 SrbExtension->CompletionRoutine = NULL;
1832
1833 NT_ASSERT(Cdb != NULL);
1834 switch(Cdb->CDB10.OperationCode)
1835 {
1836 case SCSIOP_INQUIRY:
1837 SrbExtension->Flags |= ATA_FLAGS_DATA_IN;
1838 SrbExtension->CompletionRoutine = AtapiInquiryCompletion;
1839 break;
1840 case SCSIOP_READ:
1841 SrbExtension->Flags |= ATA_FLAGS_USE_DMA;
1842 SrbExtension->FeaturesLow = 0x5;
1843 break;
1844 case SCSIOP_WRITE:
1845 SrbExtension->Flags |= ATA_FLAGS_USE_DMA;
1846 SrbExtension->FeaturesLow = 0x1;
1847 break;
1848 }
1849
1850 SrbExtension->CommandReg = IDE_COMMAND_ATAPI_PACKET;
1851
1852 SrbExtension->LBA0 = 0;
1853 SrbExtension->LBA1 = (UCHAR)(DataBufferLength >> 0);
1854 SrbExtension->LBA2 = (UCHAR)(DataBufferLength >> 8);
1855 SrbExtension->Device = 0;
1856 SrbExtension->LBA3 = 0;
1857 SrbExtension->LBA4 = 0;
1858 SrbExtension->LBA5 = 0;
1859 SrbExtension->FeaturesHigh = 0;
1860 SrbExtension->SectorCountLow = 0;
1861 SrbExtension->SectorCountHigh = 0;
1862
1863 if ((SrbExtension->Flags & ATA_FLAGS_DATA_IN) || (SrbExtension->Flags & ATA_FLAGS_DATA_OUT))
1864 {
1865 SrbExtension->pSgl = (PLOCAL_SCATTER_GATHER_LIST)StorPortGetScatterGatherList(AdapterExtension, Srb);
1866 }
1867
1868 return SRB_STATUS_PENDING;
1869 }// -- AhciATAPICommand();
1870
1871 /**
1872 * @name DeviceRequestSense
1873 * @implemented
1874 *
1875 * Handle SCSIOP_MODE_SENSE OperationCode
1876 *
1877 * @param AdapterExtension
1878 * @param Srb
1879 * @param Cdb
1880 *
1881 * @return
1882 * return STOR status for DeviceRequestSense
1883 */
1884 UCHAR
1885 DeviceRequestSense (
1886 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
1887 __in PSCSI_REQUEST_BLOCK Srb,
1888 __in PCDB Cdb
1889 )
1890 {
1891 PMODE_PARAMETER_HEADER ModeHeader;
1892 PAHCI_PORT_EXTENSION PortExtension;
1893
1894 AhciDebugPrint("DeviceRequestSense()\n");
1895
1896 NT_ASSERT(IsPortValid(AdapterExtension, Srb->PathId));
1897 NT_ASSERT(Cdb->CDB10.OperationCode == SCSIOP_MODE_SENSE);
1898
1899 PortExtension = &AdapterExtension->PortExtension[Srb->PathId];
1900
1901 if (PortExtension->DeviceParams.DeviceType == AHCI_DEVICE_TYPE_ATAPI)
1902 {
1903 return AhciATAPICommand(AdapterExtension, Srb, Cdb);
1904 }
1905
1906 ModeHeader = (PMODE_PARAMETER_HEADER)Srb->DataBuffer;
1907
1908 NT_ASSERT(ModeHeader != NULL);
1909
1910 AhciZeroMemory((PCHAR)ModeHeader, Srb->DataTransferLength);
1911
1912 ModeHeader->ModeDataLength = sizeof(MODE_PARAMETER_HEADER);
1913 ModeHeader->MediumType = 0;
1914 ModeHeader->DeviceSpecificParameter = 0;
1915 ModeHeader->BlockDescriptorLength = 0;
1916
1917 if (Cdb->MODE_SENSE.PageCode == MODE_SENSE_CURRENT_VALUES)
1918 {
1919 ModeHeader->ModeDataLength = sizeof(MODE_PARAMETER_HEADER) + sizeof(MODE_PARAMETER_BLOCK);
1920 ModeHeader->BlockDescriptorLength = sizeof(MODE_PARAMETER_BLOCK);
1921 }
1922
1923 return SRB_STATUS_SUCCESS;
1924 }// -- DeviceRequestSense();
1925
1926 /**
1927 * @name DeviceRequestReadWrite
1928 * @implemented
1929 *
1930 * Handle SCSIOP_READ SCSIOP_WRITE OperationCode
1931 *
1932 * @param AdapterExtension
1933 * @param Srb
1934 * @param Cdb
1935 *
1936 * @return
1937 * return STOR status for DeviceRequestReadWrite
1938 */
1939 UCHAR
1940 DeviceRequestReadWrite (
1941 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
1942 __in PSCSI_REQUEST_BLOCK Srb,
1943 __in PCDB Cdb
1944 )
1945 {
1946 BOOLEAN IsReading;
1947 ULONG64 StartOffset;
1948 PAHCI_SRB_EXTENSION SrbExtension;
1949 PAHCI_PORT_EXTENSION PortExtension;
1950 ULONG DataTransferLength, BytesPerSector, SectorCount;
1951
1952 AhciDebugPrint("DeviceRequestReadWrite()\n");
1953
1954 NT_ASSERT(IsPortValid(AdapterExtension, Srb->PathId));
1955 NT_ASSERT((Cdb->CDB10.OperationCode == SCSIOP_READ) || (Cdb->CDB10.OperationCode == SCSIOP_WRITE));
1956
1957 SrbExtension = GetSrbExtension(Srb);
1958 PortExtension = &AdapterExtension->PortExtension[Srb->PathId];
1959
1960 if (PortExtension->DeviceParams.DeviceType == AHCI_DEVICE_TYPE_ATAPI)
1961 {
1962 return AhciATAPICommand(AdapterExtension, Srb, Cdb);
1963 }
1964
1965 DataTransferLength = Srb->DataTransferLength;
1966 BytesPerSector = PortExtension->DeviceParams.BytesPerLogicalSector;
1967
1968 NT_ASSERT(BytesPerSector > 0);
1969
1970 //ROUND_UP(DataTransferLength, BytesPerSector);
1971
1972 SectorCount = DataTransferLength / BytesPerSector;
1973
1974 Srb->DataTransferLength = SectorCount * BytesPerSector;
1975
1976 StartOffset = AhciGetLba(Cdb, Srb->CdbLength);
1977 IsReading = (Cdb->CDB10.OperationCode == SCSIOP_READ);
1978
1979 NT_ASSERT(SectorCount > 0);
1980
1981 SrbExtension->AtaFunction = ATA_FUNCTION_ATA_READ;
1982 SrbExtension->Flags |= ATA_FLAGS_USE_DMA;
1983 SrbExtension->CompletionRoutine = NULL;
1984
1985 if (IsReading)
1986 {
1987 SrbExtension->Flags |= ATA_FLAGS_DATA_IN;
1988 SrbExtension->CommandReg = IDE_COMMAND_READ_DMA;
1989 }
1990 else
1991 {
1992 SrbExtension->Flags |= ATA_FLAGS_DATA_OUT;
1993 SrbExtension->CommandReg = IDE_COMMAND_WRITE_DMA;
1994 }
1995
1996 SrbExtension->FeaturesLow = 0;
1997 SrbExtension->LBA0 = (StartOffset >> 0) & 0xFF;
1998 SrbExtension->LBA1 = (StartOffset >> 8) & 0xFF;
1999 SrbExtension->LBA2 = (StartOffset >> 16) & 0xFF;
2000
2001 SrbExtension->Device = (0xA0 | IDE_LBA_MODE);
2002
2003 if (PortExtension->DeviceParams.Lba48BitMode)
2004 {
2005 SrbExtension->Flags |= ATA_FLAGS_48BIT_COMMAND;
2006
2007 if (IsReading)
2008 {
2009 SrbExtension->CommandReg = IDE_COMMAND_READ_DMA_EXT;
2010 }
2011 else
2012 {
2013 SrbExtension->CommandReg = IDE_COMMAND_WRITE_DMA_EXT;
2014 }
2015
2016 SrbExtension->LBA3 = (StartOffset >> 24) & 0xFF;
2017 SrbExtension->LBA4 = (StartOffset >> 32) & 0xFF;
2018 SrbExtension->LBA5 = (StartOffset >> 40) & 0xFF;
2019 }
2020 else
2021 {
2022 NT_ASSERT(FALSE);
2023 }
2024
2025 SrbExtension->FeaturesHigh = 0;
2026 SrbExtension->SectorCountLow = (SectorCount >> 0) & 0xFF;
2027 SrbExtension->SectorCountHigh = (SectorCount >> 8) & 0xFF;
2028
2029 NT_ASSERT(SectorCount < 0x100);
2030
2031 SrbExtension->pSgl = (PLOCAL_SCATTER_GATHER_LIST)StorPortGetScatterGatherList(AdapterExtension, Srb);
2032
2033 return SRB_STATUS_PENDING;
2034 }// -- DeviceRequestReadWrite();
2035
2036 /**
2037 * @name DeviceRequestCapacity
2038 * @implemented
2039 *
2040 * Handle SCSIOP_READ_CAPACITY OperationCode
2041 *
2042 * @param AdapterExtension
2043 * @param Srb
2044 * @param Cdb
2045 *
2046 * @return
2047 * return STOR status for DeviceRequestCapacity
2048 */
2049 UCHAR
2050 DeviceRequestCapacity (
2051 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
2052 __in PSCSI_REQUEST_BLOCK Srb,
2053 __in PCDB Cdb
2054 )
2055 {
2056 ULONG MaxLba, BytesPerLogicalSector;
2057 PREAD_CAPACITY_DATA ReadCapacity;
2058 PAHCI_PORT_EXTENSION PortExtension;
2059
2060 AhciDebugPrint("DeviceRequestCapacity()\n");
2061
2062 UNREFERENCED_PARAMETER(AdapterExtension);
2063 UNREFERENCED_PARAMETER(Cdb);
2064
2065 NT_ASSERT(Srb->DataBuffer != NULL);
2066 NT_ASSERT(IsPortValid(AdapterExtension, Srb->PathId));
2067
2068
2069 PortExtension = &AdapterExtension->PortExtension[Srb->PathId];
2070
2071 if (PortExtension->DeviceParams.DeviceType == AHCI_DEVICE_TYPE_ATAPI)
2072 {
2073 return AhciATAPICommand(AdapterExtension, Srb, Cdb);
2074 }
2075
2076 if (Cdb->CDB10.OperationCode == SCSIOP_READ_CAPACITY)
2077 {
2078 ReadCapacity = (PREAD_CAPACITY_DATA)Srb->DataBuffer;
2079
2080 BytesPerLogicalSector = PortExtension->DeviceParams.BytesPerLogicalSector;
2081 MaxLba = (ULONG)PortExtension->DeviceParams.MaxLba.QuadPart - 1;
2082
2083 // I trust you windows :D
2084 NT_ASSERT(Srb->DataTransferLength >= sizeof(READ_CAPACITY_DATA));
2085
2086 // I trust you user :D
2087 NT_ASSERT(PortExtension->DeviceParams.MaxLba.QuadPart < (ULONG)-1);
2088
2089 // Actually I don't trust anyone :p
2090 Srb->DataTransferLength = sizeof(READ_CAPACITY_DATA);
2091
2092 REVERSE_BYTES(&ReadCapacity->BytesPerBlock, &BytesPerLogicalSector);
2093 REVERSE_BYTES(&ReadCapacity->LogicalBlockAddress, &MaxLba);
2094 }
2095 else
2096 {
2097 AhciDebugPrint("\tSCSIOP_READ_CAPACITY16 not supported\n");
2098 NT_ASSERT(FALSE);
2099 }
2100
2101 return SRB_STATUS_SUCCESS;
2102 }// -- DeviceRequestCapacity();
2103
2104 /**
2105 * @name DeviceRequestComplete
2106 * @implemented
2107 *
2108 * Handle UnHandled Requests
2109 *
2110 * @param AdapterExtension
2111 * @param Srb
2112 * @param Cdb
2113 *
2114 * @return
2115 * return STOR status for DeviceRequestComplete
2116 */
2117 UCHAR
2118 DeviceRequestComplete (
2119 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
2120 __in PSCSI_REQUEST_BLOCK Srb,
2121 __in PCDB Cdb
2122 )
2123 {
2124 AhciDebugPrint("DeviceRequestComplete()\n");
2125
2126 UNREFERENCED_PARAMETER(AdapterExtension);
2127 UNREFERENCED_PARAMETER(Cdb);
2128
2129 Srb->ScsiStatus = SCSISTAT_GOOD;
2130
2131 return SRB_STATUS_SUCCESS;
2132 }// -- DeviceRequestComplete();
2133
2134 /**
2135 * @name DeviceReportLuns
2136 * @implemented
2137 *
2138 * Handle SCSIOP_REPORT_LUNS OperationCode
2139 *
2140 * @param AdapterExtension
2141 * @param Srb
2142 * @param Cdb
2143 *
2144 * @return
2145 * return STOR status for DeviceReportLuns
2146 */
2147 UCHAR
2148 DeviceReportLuns (
2149 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
2150 __in PSCSI_REQUEST_BLOCK Srb,
2151 __in PCDB Cdb
2152 )
2153 {
2154 PLUN_LIST LunList;
2155 PAHCI_PORT_EXTENSION PortExtension;
2156
2157 AhciDebugPrint("DeviceReportLuns()\n");
2158
2159 UNREFERENCED_PARAMETER(Cdb);
2160
2161 PortExtension = &AdapterExtension->PortExtension[Srb->PathId];
2162
2163 NT_ASSERT(Srb->DataTransferLength >= sizeof(LUN_LIST));
2164 NT_ASSERT(Cdb->CDB10.OperationCode == SCSIOP_REPORT_LUNS);
2165
2166 if (PortExtension->DeviceParams.DeviceType == AHCI_DEVICE_TYPE_ATAPI)
2167 {
2168 return AhciATAPICommand(AdapterExtension, Srb, Cdb);
2169 }
2170
2171 LunList = (PLUN_LIST)Srb->DataBuffer;
2172
2173 NT_ASSERT(LunList != NULL);
2174
2175 AhciZeroMemory((PCHAR)LunList, sizeof(LUN_LIST));
2176
2177 LunList->LunListLength[3] = 8;
2178
2179 Srb->ScsiStatus = SCSISTAT_GOOD;
2180 Srb->DataTransferLength = sizeof(LUN_LIST);
2181
2182 return SRB_STATUS_SUCCESS;
2183 }// -- DeviceReportLuns();
2184
2185 /**
2186 * @name DeviceInquiryRequest
2187 * @implemented
2188 *
2189 * Tells wheather given port is implemented or not
2190 *
2191 * @param AdapterExtension
2192 * @param Srb
2193 * @param Cdb
2194 *
2195 * @return
2196 * return STOR status for DeviceInquiryRequest
2197 *
2198 * @remark
2199 * http://www.seagate.com/staticfiles/support/disc/manuals/Interface%20manuals/100293068c.pdf
2200 */
2201 UCHAR
2202 DeviceInquiryRequest (
2203 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
2204 __in PSCSI_REQUEST_BLOCK Srb,
2205 __in PCDB Cdb
2206 )
2207 {
2208 PVOID DataBuffer;
2209 PAHCI_SRB_EXTENSION SrbExtension;
2210 PAHCI_PORT_EXTENSION PortExtension;
2211 PVPD_SUPPORTED_PAGES_PAGE VpdOutputBuffer;
2212 ULONG DataBufferLength, RequiredDataBufferLength;
2213
2214 AhciDebugPrint("DeviceInquiryRequest()\n");
2215
2216 NT_ASSERT(Cdb->CDB10.OperationCode == SCSIOP_INQUIRY);
2217 NT_ASSERT(IsPortValid(AdapterExtension, Srb->PathId));
2218
2219 SrbExtension = GetSrbExtension(Srb);
2220 PortExtension = &AdapterExtension->PortExtension[Srb->PathId];
2221
2222 if (PortExtension->DeviceParams.DeviceType == AHCI_DEVICE_TYPE_ATAPI)
2223 {
2224 return AhciATAPICommand(AdapterExtension, Srb, Cdb);
2225 }
2226
2227 if (Srb->Lun != 0)
2228 {
2229 return SRB_STATUS_SELECTION_TIMEOUT;
2230 }
2231 else if (Cdb->CDB6INQUIRY3.EnableVitalProductData == 0)
2232 {
2233 // 3.6.1
2234 // If the EVPD bit is set to zero, the device server shall return the standard INQUIRY data
2235 AhciDebugPrint("\tEVPD Inquired\n");
2236 NT_ASSERT(SrbExtension != NULL);
2237
2238 SrbExtension->AtaFunction = ATA_FUNCTION_ATA_IDENTIFY;
2239 SrbExtension->Flags |= ATA_FLAGS_DATA_IN;
2240 SrbExtension->CompletionRoutine = InquiryCompletion;
2241 SrbExtension->CommandReg = IDE_COMMAND_NOT_VALID;
2242
2243 // TODO: Should use AhciZeroMemory
2244 SrbExtension->FeaturesLow = 0;
2245 SrbExtension->LBA0 = 0;
2246 SrbExtension->LBA1 = 0;
2247 SrbExtension->LBA2 = 0;
2248 SrbExtension->Device = 0xA0;
2249 SrbExtension->LBA3 = 0;
2250 SrbExtension->LBA4 = 0;
2251 SrbExtension->LBA5 = 0;
2252 SrbExtension->FeaturesHigh = 0;
2253 SrbExtension->SectorCountLow = 0;
2254 SrbExtension->SectorCountHigh = 0;
2255
2256 SrbExtension->Sgl.NumberOfElements = 1;
2257 SrbExtension->Sgl.List[0].PhysicalAddress.LowPart = PortExtension->IdentifyDeviceDataPhysicalAddress.LowPart;
2258 SrbExtension->Sgl.List[0].PhysicalAddress.HighPart = PortExtension->IdentifyDeviceDataPhysicalAddress.HighPart;
2259 SrbExtension->Sgl.List[0].Length = sizeof(IDENTIFY_DEVICE_DATA);
2260
2261 SrbExtension->pSgl = &SrbExtension->Sgl;
2262 return SRB_STATUS_PENDING;
2263 }
2264 else
2265 {
2266 AhciDebugPrint("\tVPD Inquired\n");
2267
2268 DataBuffer = Srb->DataBuffer;
2269 DataBufferLength = Srb->DataTransferLength;
2270 RequiredDataBufferLength = DataBufferLength; // make the compiler happy :p
2271
2272 if (DataBuffer == NULL)
2273 {
2274 return SRB_STATUS_INVALID_REQUEST;
2275 }
2276
2277 AhciZeroMemory(DataBuffer, DataBufferLength);
2278
2279 switch(Cdb->CDB6INQUIRY3.PageCode)
2280 {
2281 case VPD_SUPPORTED_PAGES:
2282 {
2283 AhciDebugPrint("\tVPD_SUPPORTED_PAGES\n");
2284 RequiredDataBufferLength = sizeof(VPD_SUPPORTED_PAGES_PAGE) + 1;
2285
2286 if (DataBufferLength < RequiredDataBufferLength)
2287 {
2288 AhciDebugPrint("\tDataBufferLength: %d Required: %d\n", DataBufferLength, RequiredDataBufferLength);
2289 return SRB_STATUS_INVALID_REQUEST;
2290 }
2291
2292 VpdOutputBuffer = (PVPD_SUPPORTED_PAGES_PAGE)DataBuffer;
2293
2294 VpdOutputBuffer->DeviceType = PortExtension->DeviceParams.AccessType;
2295 VpdOutputBuffer->DeviceTypeQualifier = 0;
2296 VpdOutputBuffer->PageCode = VPD_SUPPORTED_PAGES;
2297 VpdOutputBuffer->PageLength = 1;
2298 VpdOutputBuffer->SupportedPageList[0] = VPD_SUPPORTED_PAGES;
2299 //VpdOutputBuffer->SupportedPageList[1] = VPD_SERIAL_NUMBER;
2300 //VpdOutputBuffer->SupportedPageList[2] = VPD_DEVICE_IDENTIFIERS;
2301
2302 NT_ASSERT(VpdOutputBuffer->DeviceType == DIRECT_ACCESS_DEVICE);
2303 }
2304 break;
2305 case VPD_SERIAL_NUMBER:
2306 {
2307 AhciDebugPrint("\tVPD_SERIAL_NUMBER\n");
2308 }
2309 break;
2310 case VPD_DEVICE_IDENTIFIERS:
2311 {
2312 AhciDebugPrint("\tVPD_DEVICE_IDENTIFIERS\n");
2313 }
2314 break;
2315 default:
2316 AhciDebugPrint("\tPageCode: %x\n", Cdb->CDB6INQUIRY3.PageCode);
2317 return SRB_STATUS_INVALID_REQUEST;
2318 }
2319
2320 Srb->DataTransferLength = RequiredDataBufferLength;
2321 return SRB_STATUS_SUCCESS;
2322 }
2323 }// -- DeviceInquiryRequest();
2324
2325 /**
2326 * @name AhciAdapterReset
2327 * @implemented
2328 *
2329 * 10.4.3 HBA Reset
2330 * If the HBA becomes unusable for multiple ports, and a software reset or port reset does not correct the
2331 * problem, software may reset the entire HBA by setting GHC.HR to ‘1’. When software sets the GHC.HR
2332 * bit to ‘1’, the HBA shall perform an internal reset action. The bit shall be cleared to ‘0’ by the HBA when
2333 * the reset is complete. A software write of ‘0’ to GHC.HR shall have no effect. To perform the HBA reset,
2334 * software sets GHC.HR to ‘1’ and may poll until this bit is read to be ‘0’, at which point software knows that
2335 * the HBA reset has completed.
2336 * If the HBA has not cleared GHC.HR to ‘0’ within 1 second of software setting GHC.HR to ‘1’, the HBA is in
2337 * a hung or locked state.
2338 *
2339 * @param AdapterExtension
2340 *
2341 * @return
2342 * TRUE in case AHCI Controller RESTARTED successfully. i.e GHC.HR == 0
2343 */
2344 BOOLEAN
2345 AhciAdapterReset (
2346 __in PAHCI_ADAPTER_EXTENSION AdapterExtension
2347 )
2348 {
2349 ULONG ticks;
2350 AHCI_GHC ghc;
2351 PAHCI_MEMORY_REGISTERS abar = NULL;
2352
2353 AhciDebugPrint("AhciAdapterReset()\n");
2354
2355 abar = AdapterExtension->ABAR_Address;
2356 if (abar == NULL) // basic sanity
2357 {
2358 return FALSE;
2359 }
2360
2361 // HR -- Very first bit (lowest significant)
2362 ghc.HR = 1;
2363 StorPortWriteRegisterUlong(AdapterExtension, &abar->GHC, ghc.Status);
2364
2365 for (ticks = 0; ticks < 50; ++ticks)
2366 {
2367 ghc.Status = StorPortReadRegisterUlong(AdapterExtension, &abar->GHC);
2368 if (ghc.HR == 0)
2369 {
2370 break;
2371 }
2372 StorPortStallExecution(20000);
2373 }
2374
2375 if (ticks == 50)// 1 second
2376 {
2377 AhciDebugPrint("\tDevice Timeout\n");
2378 return FALSE;
2379 }
2380
2381 return TRUE;
2382 }// -- AhciAdapterReset();
2383
2384 /**
2385 * @name AhciZeroMemory
2386 * @implemented
2387 *
2388 * Clear buffer by filling zeros
2389 *
2390 * @param Buffer
2391 * @param BufferSize
2392 */
2393 __inline
2394 VOID
2395 AhciZeroMemory (
2396 __out PCHAR Buffer,
2397 __in ULONG BufferSize
2398 )
2399 {
2400 ULONG i;
2401 for (i = 0; i < BufferSize; i++)
2402 {
2403 Buffer[i] = 0;
2404 }
2405
2406 return;
2407 }// -- AhciZeroMemory();
2408
2409 /**
2410 * @name IsPortValid
2411 * @implemented
2412 *
2413 * Tells wheather given port is implemented or not
2414 *
2415 * @param AdapterExtension
2416 * @param PathId
2417 *
2418 * @return
2419 * return TRUE if provided port is valid (implemented) or not
2420 */
2421 __inline
2422 BOOLEAN
2423 IsPortValid (
2424 __in PAHCI_ADAPTER_EXTENSION AdapterExtension,
2425 __in ULONG pathId
2426 )
2427 {
2428 NT_ASSERT(pathId < MAXIMUM_AHCI_PORT_COUNT);
2429
2430 if (pathId >= AdapterExtension->PortCount)
2431 {
2432 return FALSE;
2433 }
2434
2435 return AdapterExtension->PortExtension[pathId].DeviceParams.IsActive;
2436 }// -- IsPortValid()
2437
2438 /**
2439 * @name AddQueue
2440 * @implemented
2441 *
2442 * Add Srb to Queue
2443 *
2444 * @param Queue
2445 * @param Srb
2446 *
2447 * @return
2448 * return TRUE if Srb is successfully added to Queue
2449 *
2450 */
2451 __inline
2452 BOOLEAN
2453 AddQueue (
2454 __inout PAHCI_QUEUE Queue,
2455 __in PVOID Srb
2456 )
2457 {
2458 NT_ASSERT(Queue->Head < MAXIMUM_QUEUE_BUFFER_SIZE);
2459 NT_ASSERT(Queue->Tail < MAXIMUM_QUEUE_BUFFER_SIZE);
2460
2461 if (Queue->Tail == ((Queue->Head + 1) % MAXIMUM_QUEUE_BUFFER_SIZE))
2462 return FALSE;
2463
2464 Queue->Buffer[Queue->Head++] = Srb;
2465 Queue->Head %= MAXIMUM_QUEUE_BUFFER_SIZE;
2466
2467 return TRUE;
2468 }// -- AddQueue();
2469
2470 /**
2471 * @name RemoveQueue
2472 * @implemented
2473 *
2474 * Remove and return Srb from Queue
2475 *
2476 * @param Queue
2477 *
2478 * @return
2479 * return Srb
2480 *
2481 */
2482 __inline
2483 PVOID
2484 RemoveQueue (
2485 __inout PAHCI_QUEUE Queue
2486 )
2487 {
2488 PVOID Srb;
2489
2490 NT_ASSERT(Queue->Head < MAXIMUM_QUEUE_BUFFER_SIZE);
2491 NT_ASSERT(Queue->Tail < MAXIMUM_QUEUE_BUFFER_SIZE);
2492
2493 if (Queue->Head == Queue->Tail)
2494 return NULL;
2495
2496 Srb = Queue->Buffer[Queue->Tail++];
2497 Queue->Tail %= MAXIMUM_QUEUE_BUFFER_SIZE;
2498
2499 return Srb;
2500 }// -- RemoveQueue();
2501
2502 /**
2503 * @name GetSrbExtension
2504 * @implemented
2505 *
2506 * GetSrbExtension from Srb make sure It is properly aligned
2507 *
2508 * @param Srb
2509 *
2510 * @return
2511 * return SrbExtension
2512 *
2513 */
2514 __inline
2515 PAHCI_SRB_EXTENSION
2516 GetSrbExtension (
2517 __in PSCSI_REQUEST_BLOCK Srb
2518 )
2519 {
2520 ULONG Offset;
2521 ULONG_PTR SrbExtension;
2522
2523 SrbExtension = (ULONG_PTR)Srb->SrbExtension;
2524 Offset = SrbExtension % 128;
2525
2526 // CommandTable should be 128 byte aligned
2527 if (Offset != 0)
2528 Offset = 128 - Offset;
2529
2530 return (PAHCI_SRB_EXTENSION)(SrbExtension + Offset);
2531 }// -- PAHCI_SRB_EXTENSION();
2532
2533 /**
2534 * @name AhciGetLba
2535 * @implemented
2536 *
2537 * Find the logical address of demand block from Cdb
2538 *
2539 * @param Srb
2540 *
2541 * @return
2542 * return Logical Address of the block
2543 *
2544 */
2545 __inline
2546 ULONG64
2547 AhciGetLba (
2548 __in PCDB Cdb,
2549 __in ULONG CdbLength
2550 )
2551 {
2552 ULONG64 lba = 0;
2553
2554 NT_ASSERT(Cdb != NULL);
2555 NT_ASSERT(CdbLength != 0);
2556
2557 if (CdbLength == 0x10)
2558 {
2559 REVERSE_BYTES_QUAD(&lba, Cdb->CDB16.LogicalBlock);
2560 }
2561 else
2562 {
2563 lba |= Cdb->CDB10.LogicalBlockByte3 << 0;
2564 lba |= Cdb->CDB10.LogicalBlockByte2 << 8;
2565 lba |= Cdb->CDB10.LogicalBlockByte1 << 16;
2566 lba |= Cdb->CDB10.LogicalBlockByte0 << 24;
2567 }
2568
2569 return lba;
2570 }// -- AhciGetLba();