VirtualBox

source: vbox/trunk/src/VBox/Devices/Storage/DevAHCI.cpp@ 76553

Last change on this file since 76553 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 237.9 KB
Line 
1/* $Id: DevAHCI.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * DevAHCI - AHCI controller device (disk and cdrom).
4 *
5 * Implements the AHCI standard 1.1
6 */
7
8/*
9 * Copyright (C) 2006-2019 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 */
19
20/** @page pg_dev_ahci AHCI - Advanced Host Controller Interface Emulation.
21 *
22 * This component implements an AHCI serial ATA controller. The device is split
23 * into two parts. The first part implements the register interface for the
24 * guest and the second one does the data transfer.
25 *
26 * The guest can access the controller in two ways. The first one is the native
27 * way implementing the registers described in the AHCI specification and is
28 * the preferred one. The second implements the I/O ports used for booting from
29 * the hard disk and for guests which don't have an AHCI SATA driver.
30 *
31 * The data is transfered using the extended media interface, asynchronously if
32 * it is supported by the driver below otherwise it weill be done synchronous.
33 * Either way a thread is used to process new requests from the guest.
34 */
35
36
37/*********************************************************************************************************************************
38* Header Files *
39*********************************************************************************************************************************/
40#define LOG_GROUP LOG_GROUP_DEV_AHCI
41#include <VBox/vmm/pdmdev.h>
42#include <VBox/vmm/pdmstorageifs.h>
43#include <VBox/vmm/pdmqueue.h>
44#include <VBox/vmm/pdmthread.h>
45#include <VBox/vmm/pdmcritsect.h>
46#include <VBox/sup.h>
47#include <VBox/scsi.h>
48#include <VBox/ata.h>
49#include <iprt/assert.h>
50#include <iprt/asm.h>
51#include <iprt/string.h>
52#include <iprt/list.h>
53#ifdef IN_RING3
54# include <iprt/param.h>
55# include <iprt/thread.h>
56# include <iprt/semaphore.h>
57# include <iprt/alloc.h>
58# include <iprt/uuid.h>
59# include <iprt/time.h>
60#endif
61#include "VBoxDD.h"
62
63#if defined(VBOX_WITH_DTRACE) \
64 && defined(IN_RING3) \
65 && !defined(VBOX_DEVICE_STRUCT_TESTCASE)
66# include "dtrace/VBoxDD.h"
67#else
68# define VBOXDD_AHCI_REQ_SUBMIT(a,b,c,d) do { } while (0)
69# define VBOXDD_AHCI_REQ_COMPLETED(a,b,c,d) do { } while (0)
70#endif
71
72/** Maximum number of ports available.
73 * Spec defines 32 but we have one allocated for command completion coalescing
74 * and another for a reserved future feature.
75 */
76#define AHCI_MAX_NR_PORTS_IMPL 30
77/** Maximum number of command slots available. */
78#define AHCI_NR_COMMAND_SLOTS 32
79
80/** The current saved state version. */
81#define AHCI_SAVED_STATE_VERSION 9
82/** The saved state version before the ATAPI emulation was removed and the generic SCSI driver was used. */
83#define AHCI_SAVED_STATE_VERSION_PRE_ATAPI_REMOVE 8
84/** The saved state version before changing the port reset logic in an incompatible way. */
85#define AHCI_SAVED_STATE_VERSION_PRE_PORT_RESET_CHANGES 7
86/** Saved state version before the per port hotplug port was added. */
87#define AHCI_SAVED_STATE_VERSION_PRE_HOTPLUG_FLAG 6
88/** Saved state version before legacy ATA emulation was dropped. */
89#define AHCI_SAVED_STATE_VERSION_IDE_EMULATION 5
90/** Saved state version before ATAPI support was added. */
91#define AHCI_SAVED_STATE_VERSION_PRE_ATAPI 3
92/** The saved state version use in VirtualBox 3.0 and earlier.
93 * This was before the config was added and ahciIOTasks was dropped. */
94#define AHCI_SAVED_STATE_VERSION_VBOX_30 2
95/* for Older ATA state Read handling */
96#define ATA_CTL_SAVED_STATE_VERSION 3
97#define ATA_CTL_SAVED_STATE_VERSION_WITHOUT_FULL_SENSE 1
98#define ATA_CTL_SAVED_STATE_VERSION_WITHOUT_EVENT_STATUS 2
99
100/** The maximum number of release log entries per device. */
101#define MAX_LOG_REL_ERRORS 1024
102
103/**
104 * Maximum number of sectors to transfer in a READ/WRITE MULTIPLE request.
105 * Set to 1 to disable multi-sector read support. According to the ATA
106 * specification this must be a power of 2 and it must fit in an 8 bit
107 * value. Thus the only valid values are 1, 2, 4, 8, 16, 32, 64 and 128.
108 */
109#define ATA_MAX_MULT_SECTORS 128
110
111/**
112 * Fastest PIO mode supported by the drive.
113 */
114#define ATA_PIO_MODE_MAX 4
115/**
116 * Fastest MDMA mode supported by the drive.
117 */
118#define ATA_MDMA_MODE_MAX 2
119/**
120 * Fastest UDMA mode supported by the drive.
121 */
122#define ATA_UDMA_MODE_MAX 6
123
124/**
125 * Length of the configurable VPD data (without termination)
126 */
127#define AHCI_SERIAL_NUMBER_LENGTH 20
128#define AHCI_FIRMWARE_REVISION_LENGTH 8
129#define AHCI_MODEL_NUMBER_LENGTH 40
130#define AHCI_ATAPI_INQUIRY_VENDOR_ID_LENGTH 8
131#define AHCI_ATAPI_INQUIRY_PRODUCT_ID_LENGTH 16
132#define AHCI_ATAPI_INQUIRY_REVISION_LENGTH 4
133
134/** ATAPI sense info size. */
135#define ATAPI_SENSE_SIZE 64
136
137/**
138 * Command Header.
139 */
140#pragma pack(1)
141typedef struct
142{
143 /** Description Information. */
144 uint32_t u32DescInf;
145 /** Command status. */
146 uint32_t u32PRDBC;
147 /** Command Table Base Address. */
148 uint32_t u32CmdTblAddr;
149 /** Command Table Base Address - upper 32-bits. */
150 uint32_t u32CmdTblAddrUp;
151 /** Reserved */
152 uint32_t u32Reserved[4];
153} CmdHdr;
154#pragma pack()
155AssertCompileSize(CmdHdr, 32);
156
157/* Defines for the command header. */
158#define AHCI_CMDHDR_PRDTL_MASK 0xffff0000
159#define AHCI_CMDHDR_PRDTL_ENTRIES(x) ((x & AHCI_CMDHDR_PRDTL_MASK) >> 16)
160#define AHCI_CMDHDR_C RT_BIT(10)
161#define AHCI_CMDHDR_B RT_BIT(9)
162#define AHCI_CMDHDR_R RT_BIT(8)
163#define AHCI_CMDHDR_P RT_BIT(7)
164#define AHCI_CMDHDR_W RT_BIT(6)
165#define AHCI_CMDHDR_A RT_BIT(5)
166#define AHCI_CMDHDR_CFL_MASK 0x1f
167
168#define AHCI_CMDHDR_PRDT_OFFSET 0x80
169#define AHCI_CMDHDR_ACMD_OFFSET 0x40
170
171/* Defines for the command FIS. */
172/* Defines that are used in the first double word. */
173#define AHCI_CMDFIS_TYPE 0 /* The first byte. */
174# define AHCI_CMDFIS_TYPE_H2D 0x27 /* Register - Host to Device FIS. */
175# define AHCI_CMDFIS_TYPE_H2D_SIZE 20 /* Five double words. */
176# define AHCI_CMDFIS_TYPE_D2H 0x34 /* Register - Device to Host FIS. */
177# define AHCI_CMDFIS_TYPE_D2H_SIZE 20 /* Five double words. */
178# define AHCI_CMDFIS_TYPE_SETDEVBITS 0xa1 /* Set Device Bits - Device to Host FIS. */
179# define AHCI_CMDFIS_TYPE_SETDEVBITS_SIZE 8 /* Two double words. */
180# define AHCI_CMDFIS_TYPE_DMAACTD2H 0x39 /* DMA Activate - Device to Host FIS. */
181# define AHCI_CMDFIS_TYPE_DMAACTD2H_SIZE 4 /* One double word. */
182# define AHCI_CMDFIS_TYPE_DMASETUP 0x41 /* DMA Setup - Bidirectional FIS. */
183# define AHCI_CMDFIS_TYPE_DMASETUP_SIZE 28 /* Seven double words. */
184# define AHCI_CMDFIS_TYPE_PIOSETUP 0x5f /* PIO Setup - Device to Host FIS. */
185# define AHCI_CMDFIS_TYPE_PIOSETUP_SIZE 20 /* Five double words. */
186# define AHCI_CMDFIS_TYPE_DATA 0x46 /* Data - Bidirectional FIS. */
187
188#define AHCI_CMDFIS_BITS 1 /* Interrupt and Update bit. */
189#define AHCI_CMDFIS_C RT_BIT(7) /* Host to device. */
190#define AHCI_CMDFIS_I RT_BIT(6) /* Device to Host. */
191#define AHCI_CMDFIS_D RT_BIT(5)
192
193#define AHCI_CMDFIS_CMD 2
194#define AHCI_CMDFIS_FET 3
195
196#define AHCI_CMDFIS_SECTN 4
197#define AHCI_CMDFIS_CYLL 5
198#define AHCI_CMDFIS_CYLH 6
199#define AHCI_CMDFIS_HEAD 7
200
201#define AHCI_CMDFIS_SECTNEXP 8
202#define AHCI_CMDFIS_CYLLEXP 9
203#define AHCI_CMDFIS_CYLHEXP 10
204#define AHCI_CMDFIS_FETEXP 11
205
206#define AHCI_CMDFIS_SECTC 12
207#define AHCI_CMDFIS_SECTCEXP 13
208#define AHCI_CMDFIS_CTL 15
209# define AHCI_CMDFIS_CTL_SRST RT_BIT(2) /* Reset device. */
210# define AHCI_CMDFIS_CTL_NIEN RT_BIT(1) /* Assert or clear interrupt. */
211
212/* For D2H FIS */
213#define AHCI_CMDFIS_STS 2
214#define AHCI_CMDFIS_ERR 3
215
216/** Pointer to a task state. */
217typedef struct AHCIREQ *PAHCIREQ;
218
219/** Task encountered a buffer overflow. */
220#define AHCI_REQ_OVERFLOW RT_BIT_32(0)
221/** Request is a PIO data command, if this flag is not set it either is
222 * a command which does not transfer data or a DMA command based on the transfer size. */
223#define AHCI_REQ_PIO_DATA RT_BIT_32(1)
224/** The request has the SACT register set. */
225#define AHCI_REQ_CLEAR_SACT RT_BIT_32(2)
226/** Flag whether the request is queued. */
227#define AHCI_REQ_IS_QUEUED RT_BIT_32(3)
228/** Flag whether the request is stored on the stack. */
229#define AHCI_REQ_IS_ON_STACK RT_BIT_32(4)
230/** Flag whether this request transfers data from the device to the HBA or
231 * the other way around .*/
232#define AHCI_REQ_XFER_2_HOST RT_BIT_32(5)
233
234/**
235 * A task state.
236 */
237typedef struct AHCIREQ
238{
239 /** The I/O request handle from the driver below associated with this request. */
240 PDMMEDIAEXIOREQ hIoReq;
241 /** Tag of the task. */
242 uint32_t uTag;
243 /** The command Fis for this task. */
244 uint8_t cmdFis[AHCI_CMDFIS_TYPE_H2D_SIZE];
245 /** The ATAPI command data. */
246 uint8_t aATAPICmd[ATAPI_PACKET_SIZE];
247 /** Size of one sector for the ATAPI transfer. */
248 uint32_t cbATAPISector;
249 /** Physical address of the command header. - GC */
250 RTGCPHYS GCPhysCmdHdrAddr;
251 /** Physical address of the PRDT */
252 RTGCPHYS GCPhysPrdtl;
253 /** Number of entries in the PRDTL. */
254 unsigned cPrdtlEntries;
255 /** Data direction. */
256 PDMMEDIAEXIOREQTYPE enmType;
257 /** Start offset. */
258 uint64_t uOffset;
259 /** Number of bytes to transfer. */
260 size_t cbTransfer;
261 /** Flags for this task. */
262 uint32_t fFlags;
263 /** SCSI status code. */
264 uint8_t u8ScsiSts;
265 /** Flag when the buffer is mapped. */
266 bool fMapped;
267 /** Page lock when the buffer is mapped. */
268 PGMPAGEMAPLOCK PgLck;
269} AHCIREQ;
270
271/**
272 * Notifier queue item.
273 */
274typedef struct DEVPORTNOTIFIERQUEUEITEM
275{
276 /** The core part owned by the queue manager. */
277 PDMQUEUEITEMCORE Core;
278 /** The port to process. */
279 uint8_t iPort;
280} DEVPORTNOTIFIERQUEUEITEM, *PDEVPORTNOTIFIERQUEUEITEM;
281
282
283/**
284 * @implements PDMIBASE
285 * @implements PDMIMEDIAPORT
286 * @implements PDMIMEDIAEXPORT
287 */
288typedef struct AHCIPort
289{
290 /** Pointer to the device instance - HC ptr */
291 PPDMDEVINSR3 pDevInsR3;
292 /** Pointer to the device instance - R0 ptr */
293 PPDMDEVINSR0 pDevInsR0;
294 /** Pointer to the device instance - RC ptr. */
295 PPDMDEVINSRC pDevInsRC;
296
297#if HC_ARCH_BITS == 64
298 uint32_t Alignment0;
299#endif
300
301 /** Pointer to the parent AHCI structure - R3 ptr. */
302 R3PTRTYPE(struct AHCI *) pAhciR3;
303 /** Pointer to the parent AHCI structure - R0 ptr. */
304 R0PTRTYPE(struct AHCI *) pAhciR0;
305 /** Pointer to the parent AHCI structure - RC ptr. */
306 RCPTRTYPE(struct AHCI *) pAhciRC;
307
308 /** Command List Base Address. */
309 uint32_t regCLB;
310 /** Command List Base Address upper bits. */
311 uint32_t regCLBU;
312 /** FIS Base Address. */
313 uint32_t regFB;
314 /** FIS Base Address upper bits. */
315 uint32_t regFBU;
316 /** Interrupt Status. */
317 volatile uint32_t regIS;
318 /** Interrupt Enable. */
319 uint32_t regIE;
320 /** Command. */
321 uint32_t regCMD;
322 /** Task File Data. */
323 uint32_t regTFD;
324 /** Signature */
325 uint32_t regSIG;
326 /** Serial ATA Status. */
327 uint32_t regSSTS;
328 /** Serial ATA Control. */
329 uint32_t regSCTL;
330 /** Serial ATA Error. */
331 uint32_t regSERR;
332 /** Serial ATA Active. */
333 volatile uint32_t regSACT;
334 /** Command Issue. */
335 uint32_t regCI;
336
337 /** Current number of active tasks. */
338 volatile uint32_t cTasksActive;
339 /** Command List Base Address */
340 volatile RTGCPHYS GCPhysAddrClb;
341 /** FIS Base Address */
342 volatile RTGCPHYS GCPhysAddrFb;
343
344 /** Device is powered on. */
345 bool fPoweredOn;
346 /** Device has spun up. */
347 bool fSpunUp;
348 /** First D2H FIS was sent. */
349 bool fFirstD2HFisSent;
350 /** Attached device is a CD/DVD drive. */
351 bool fATAPI;
352 /** Flag whether this port is in a reset state. */
353 volatile bool fPortReset;
354 /** Flag whether TRIM is supported. */
355 bool fTrimEnabled;
356 /** Flag if we are in a device reset. */
357 bool fResetDevice;
358 /** Flag whether this port is hot plug capable. */
359 bool fHotpluggable;
360 /** Flag whether the port is in redo task mode. */
361 volatile bool fRedo;
362 /** Flag whether the worker thread is sleeping. */
363 volatile bool fWrkThreadSleeping;
364
365 bool afAlignment[4];
366
367 /** Number of total sectors. */
368 uint64_t cTotalSectors;
369 /** Size of one sector. */
370 uint32_t cbSector;
371 /** Currently configured number of sectors in a multi-sector transfer. */
372 uint32_t cMultSectors;
373 /** Currently active transfer mode (MDMA/UDMA) and speed. */
374 uint8_t uATATransferMode;
375 /** ATAPI sense data. */
376 uint8_t abATAPISense[ATAPI_SENSE_SIZE];
377 /** Exponent of logical sectors in a physical sector, number of logical sectors is 2^exp. */
378 uint8_t cLogSectorsPerPhysicalExp;
379 /** The LUN. */
380 RTUINT iLUN;
381
382 /** Bitmap for finished tasks (R3 -> Guest). */
383 volatile uint32_t u32TasksFinished;
384 /** Bitmap for finished queued tasks (R3 -> Guest). */
385 volatile uint32_t u32QueuedTasksFinished;
386 /** Bitmap for new queued tasks (Guest -> R3). */
387 volatile uint32_t u32TasksNew;
388 /** Bitmap of tasks which must be redone because of a non fatal error. */
389 volatile uint32_t u32TasksRedo;
390
391 /** Current command slot processed.
392 * Accessed by the guest by reading the CMD register.
393 * Holds the command slot of the command processed at the moment. */
394 volatile uint32_t u32CurrentCommandSlot;
395
396#if HC_ARCH_BITS == 64
397 uint32_t u32Alignment2;
398#endif
399
400 /** Device specific settings (R3 only stuff). */
401 /** Pointer to the attached driver's base interface. */
402 R3PTRTYPE(PPDMIBASE) pDrvBase;
403 /** Pointer to the attached driver's block interface. */
404 R3PTRTYPE(PPDMIMEDIA) pDrvMedia;
405 /** Pointer to the attached driver's extended interface. */
406 R3PTRTYPE(PPDMIMEDIAEX) pDrvMediaEx;
407 /** The base interface. */
408 PDMIBASE IBase;
409 /** The block port interface. */
410 PDMIMEDIAPORT IPort;
411 /** The extended media port interface. */
412 PDMIMEDIAEXPORT IMediaExPort;
413 /** Physical geometry of this image. */
414 PDMMEDIAGEOMETRY PCHSGeometry;
415 /** The status LED state for this drive. */
416 PDMLED Led;
417
418 uint32_t u32Alignment3;
419
420 /** Async IO Thread. */
421 R3PTRTYPE(PPDMTHREAD) pAsyncIOThread;
422 /** First task throwing an error. */
423 R3PTRTYPE(volatile PAHCIREQ) pTaskErr;
424
425 /** The event semaphore the processing thread waits on. */
426 SUPSEMEVENT hEvtProcess;
427
428 /** The serial numnber to use for IDENTIFY DEVICE commands. */
429 char szSerialNumber[AHCI_SERIAL_NUMBER_LENGTH+1]; /** < one extra byte for termination */
430 /** The firmware revision to use for IDENTIFY DEVICE commands. */
431 char szFirmwareRevision[AHCI_FIRMWARE_REVISION_LENGTH+1]; /** < one extra byte for termination */
432 /** The model number to use for IDENTIFY DEVICE commands. */
433 char szModelNumber[AHCI_MODEL_NUMBER_LENGTH+1]; /** < one extra byte for termination */
434 /** The vendor identification string for SCSI INQUIRY commands. */
435 char szInquiryVendorId[AHCI_ATAPI_INQUIRY_VENDOR_ID_LENGTH+1];
436 /** The product identification string for SCSI INQUIRY commands. */
437 char szInquiryProductId[AHCI_ATAPI_INQUIRY_PRODUCT_ID_LENGTH+1];
438 /** The revision string for SCSI INQUIRY commands. */
439 char szInquiryRevision[AHCI_ATAPI_INQUIRY_REVISION_LENGTH+1];
440 /** Error counter */
441 uint32_t cErrors;
442
443 uint32_t u32Alignment5;
444
445} AHCIPort;
446/** Pointer to the state of an AHCI port. */
447typedef AHCIPort *PAHCIPort;
448
449AssertCompileSizeAlignment(AHCIPort, 8);
450
451/**
452 * Main AHCI device state.
453 *
454 * @implements PDMILEDPORTS
455 */
456typedef struct AHCI
457{
458 /** The PCI device structure. */
459 PDMPCIDEV dev;
460 /** Pointer to the device instance - R3 ptr */
461 PPDMDEVINSR3 pDevInsR3;
462 /** Pointer to the device instance - R0 ptr */
463 PPDMDEVINSR0 pDevInsR0;
464 /** Pointer to the device instance - RC ptr. */
465 PPDMDEVINSRC pDevInsRC;
466
467#if HC_ARCH_BITS == 64
468 uint32_t Alignment0;
469#endif
470
471 /** Status LUN: The base interface. */
472 PDMIBASE IBase;
473 /** Status LUN: Leds interface. */
474 PDMILEDPORTS ILeds;
475 /** Status LUN: Partner of ILeds. */
476 R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
477 /** Status LUN: Media Notifys. */
478 R3PTRTYPE(PPDMIMEDIANOTIFY) pMediaNotify;
479
480#if HC_ARCH_BITS == 32
481 uint32_t Alignment1;
482#endif
483
484 /** Base address of the MMIO region. */
485 RTGCPHYS MMIOBase;
486 /** Base address of the I/O port region for Idx/Data. */
487 RTIOPORT IOPortBase;
488
489 /** Global Host Control register of the HBA */
490
491 /** HBA Capabilities - Readonly */
492 uint32_t regHbaCap;
493 /** HBA Control */
494 uint32_t regHbaCtrl;
495 /** Interrupt Status */
496 uint32_t regHbaIs;
497 /** Ports Implemented - Readonly */
498 uint32_t regHbaPi;
499 /** AHCI Version - Readonly */
500 uint32_t regHbaVs;
501 /** Command completion coalescing control */
502 uint32_t regHbaCccCtl;
503 /** Command completion coalescing ports */
504 uint32_t regHbaCccPorts;
505
506 /** Index register for BIOS access. */
507 uint32_t regIdx;
508
509#if HC_ARCH_BITS == 64
510 uint32_t Alignment3;
511#endif
512
513 /** Countdown timer for command completion coalescing - R3 ptr */
514 PTMTIMERR3 pHbaCccTimerR3;
515 /** Countdown timer for command completion coalescing - R0 ptr */
516 PTMTIMERR0 pHbaCccTimerR0;
517 /** Countdown timer for command completion coalescing - RC ptr */
518 PTMTIMERRC pHbaCccTimerRC;
519
520#if HC_ARCH_BITS == 64
521 uint32_t Alignment4;
522#endif
523
524 /** Queue to send tasks to R3. - HC ptr */
525 R3PTRTYPE(PPDMQUEUE) pNotifierQueueR3;
526 /** Queue to send tasks to R3. - HC ptr */
527 R0PTRTYPE(PPDMQUEUE) pNotifierQueueR0;
528 /** Queue to send tasks to R3. - RC ptr */
529 RCPTRTYPE(PPDMQUEUE) pNotifierQueueRC;
530
531#if HC_ARCH_BITS == 64
532 uint32_t Alignment5;
533#endif
534
535
536 /** Which port number is used to mark an CCC interrupt */
537 uint8_t uCccPortNr;
538
539#if HC_ARCH_BITS == 64
540 uint32_t Alignment6;
541#endif
542
543 /** Timeout value */
544 uint64_t uCccTimeout;
545 /** Number of completions used to assert an interrupt */
546 uint32_t uCccNr;
547 /** Current number of completed commands */
548 uint32_t uCccCurrentNr;
549
550 /** Register structure per port */
551 AHCIPort ahciPort[AHCI_MAX_NR_PORTS_IMPL];
552
553 /** The critical section. */
554 PDMCRITSECT lock;
555
556 /** Bitmask of ports which asserted an interrupt. */
557 volatile uint32_t u32PortsInterrupted;
558 /** Number of I/O threads currently active - used for async controller reset handling. */
559 volatile uint32_t cThreadsActive;
560 /** Device is in a reset state. */
561 bool fReset;
562 /** Supports 64bit addressing */
563 bool f64BitAddr;
564 /** GC enabled. */
565 bool fGCEnabled;
566 /** R0 enabled. */
567 bool fR0Enabled;
568 /** Indicates that PDMDevHlpAsyncNotificationCompleted should be called when
569 * a port is entering the idle state. */
570 bool volatile fSignalIdle;
571 /** Flag whether the controller has BIOS access enabled. */
572 bool fBootable;
573 /** Flag whether the legacy port reset method should be used to make it work with saved states. */
574 bool fLegacyPortResetMethod;
575 /** Enable tiger (10.4.x) SSTS hack or not. */
576 bool fTigerHack;
577
578 /** Number of usable ports on this controller. */
579 uint32_t cPortsImpl;
580 /** Number of usable command slots for each port. */
581 uint32_t cCmdSlotsAvail;
582
583 /** Flag whether we have written the first 4bytes in an 8byte MMIO write successfully. */
584 volatile bool f8ByteMMIO4BytesWrittenSuccessfully;
585
586#if HC_ARCH_BITS == 64
587 uint32_t Alignment7;
588#endif
589
590 /** The support driver session handle. */
591 R3R0PTRTYPE(PSUPDRVSESSION) pSupDrvSession;
592} AHCI;
593/** Pointer to the state of an AHCI device. */
594typedef AHCI *PAHCI;
595
596AssertCompileMemberAlignment(AHCI, ahciPort, 8);
597
598/**
599 * Scatter gather list entry.
600 */
601typedef struct
602{
603 /** Data Base Address. */
604 uint32_t u32DBA;
605 /** Data Base Address - Upper 32-bits. */
606 uint32_t u32DBAUp;
607 /** Reserved */
608 uint32_t u32Reserved;
609 /** Description information. */
610 uint32_t u32DescInf;
611} SGLEntry;
612AssertCompileSize(SGLEntry, 16);
613
614#ifdef IN_RING3
615/**
616 * Memory buffer callback.
617 *
618 * @returns nothing.
619 * @param pThis The NVME controller instance.
620 * @param GCPhys The guest physical address of the memory buffer.
621 * @param pSgBuf The pointer to the host R3 S/G buffer.
622 * @param cbCopy How many bytes to copy between the two buffers.
623 * @param pcbSkip Initially contains the amount of bytes to skip
624 * starting from the guest physical address before
625 * accessing the S/G buffer and start copying data.
626 * On return this contains the remaining amount if
627 * cbCopy < *pcbSkip or 0 otherwise.
628 */
629typedef DECLCALLBACK(void) AHCIR3MEMCOPYCALLBACK(PAHCI pThis, RTGCPHYS GCPhys, PRTSGBUF pSgBuf, size_t cbCopy,
630 size_t *pcbSkip);
631/** Pointer to a memory copy buffer callback. */
632typedef AHCIR3MEMCOPYCALLBACK *PAHCIR3MEMCOPYCALLBACK;
633#endif
634
635/** Defines for a scatter gather list entry. */
636#define SGLENTRY_DBA_READONLY ~(RT_BIT(0))
637#define SGLENTRY_DESCINF_I RT_BIT(31)
638#define SGLENTRY_DESCINF_DBC 0x3fffff
639#define SGLENTRY_DESCINF_READONLY 0x803fffff
640
641/* Defines for the global host control registers for the HBA. */
642
643#define AHCI_HBA_GLOBAL_SIZE 0x100
644
645/* Defines for the HBA Capabilities - Readonly */
646#define AHCI_HBA_CAP_S64A RT_BIT(31)
647#define AHCI_HBA_CAP_SNCQ RT_BIT(30)
648#define AHCI_HBA_CAP_SIS RT_BIT(28)
649#define AHCI_HBA_CAP_SSS RT_BIT(27)
650#define AHCI_HBA_CAP_SALP RT_BIT(26)
651#define AHCI_HBA_CAP_SAL RT_BIT(25)
652#define AHCI_HBA_CAP_SCLO RT_BIT(24)
653#define AHCI_HBA_CAP_ISS (RT_BIT(23) | RT_BIT(22) | RT_BIT(21) | RT_BIT(20))
654# define AHCI_HBA_CAP_ISS_SHIFT(x) (((x) << 20) & AHCI_HBA_CAP_ISS)
655# define AHCI_HBA_CAP_ISS_GEN1 RT_BIT(0)
656# define AHCI_HBA_CAP_ISS_GEN2 RT_BIT(1)
657#define AHCI_HBA_CAP_SNZO RT_BIT(19)
658#define AHCI_HBA_CAP_SAM RT_BIT(18)
659#define AHCI_HBA_CAP_SPM RT_BIT(17)
660#define AHCI_HBA_CAP_PMD RT_BIT(15)
661#define AHCI_HBA_CAP_SSC RT_BIT(14)
662#define AHCI_HBA_CAP_PSC RT_BIT(13)
663#define AHCI_HBA_CAP_NCS (RT_BIT(12) | RT_BIT(11) | RT_BIT(10) | RT_BIT(9) | RT_BIT(8))
664#define AHCI_HBA_CAP_NCS_SET(x) (((x-1) << 8) & AHCI_HBA_CAP_NCS) /* 0's based */
665#define AHCI_HBA_CAP_CCCS RT_BIT(7)
666#define AHCI_HBA_CAP_NP (RT_BIT(4) | RT_BIT(3) | RT_BIT(2) | RT_BIT(1) | RT_BIT(0))
667#define AHCI_HBA_CAP_NP_SET(x) ((x-1) & AHCI_HBA_CAP_NP) /* 0's based */
668
669/* Defines for the HBA Control register - Read/Write */
670#define AHCI_HBA_CTRL_AE RT_BIT(31)
671#define AHCI_HBA_CTRL_IE RT_BIT(1)
672#define AHCI_HBA_CTRL_HR RT_BIT(0)
673#define AHCI_HBA_CTRL_RW_MASK (RT_BIT(0) | RT_BIT(1)) /* Mask for the used bits */
674
675/* Defines for the HBA Version register - Readonly (We support AHCI 1.0) */
676#define AHCI_HBA_VS_MJR (1 << 16)
677#define AHCI_HBA_VS_MNR 0x100
678
679/* Defines for the command completion coalescing control register */
680#define AHCI_HBA_CCC_CTL_TV 0xffff0000
681#define AHCI_HBA_CCC_CTL_TV_SET(x) (x << 16)
682#define AHCI_HBA_CCC_CTL_TV_GET(x) ((x & AHCI_HBA_CCC_CTL_TV) >> 16)
683
684#define AHCI_HBA_CCC_CTL_CC 0xff00
685#define AHCI_HBA_CCC_CTL_CC_SET(x) (x << 8)
686#define AHCI_HBA_CCC_CTL_CC_GET(x) ((x & AHCI_HBA_CCC_CTL_CC) >> 8)
687
688#define AHCI_HBA_CCC_CTL_INT 0xf8
689#define AHCI_HBA_CCC_CTL_INT_SET(x) (x << 3)
690#define AHCI_HBA_CCC_CTL_INT_GET(x) ((x & AHCI_HBA_CCC_CTL_INT) >> 3)
691
692#define AHCI_HBA_CCC_CTL_EN RT_BIT(0)
693
694/* Defines for the port registers. */
695
696#define AHCI_PORT_REGISTER_SIZE 0x80
697
698#define AHCI_PORT_CLB_RESERVED 0xfffffc00 /* For masking out the reserved bits. */
699
700#define AHCI_PORT_FB_RESERVED 0xffffff00 /* For masking out the reserved bits. */
701
702#define AHCI_PORT_IS_CPDS RT_BIT(31)
703#define AHCI_PORT_IS_TFES RT_BIT(30)
704#define AHCI_PORT_IS_HBFS RT_BIT(29)
705#define AHCI_PORT_IS_HBDS RT_BIT(28)
706#define AHCI_PORT_IS_IFS RT_BIT(27)
707#define AHCI_PORT_IS_INFS RT_BIT(26)
708#define AHCI_PORT_IS_OFS RT_BIT(24)
709#define AHCI_PORT_IS_IPMS RT_BIT(23)
710#define AHCI_PORT_IS_PRCS RT_BIT(22)
711#define AHCI_PORT_IS_DIS RT_BIT(7)
712#define AHCI_PORT_IS_PCS RT_BIT(6)
713#define AHCI_PORT_IS_DPS RT_BIT(5)
714#define AHCI_PORT_IS_UFS RT_BIT(4)
715#define AHCI_PORT_IS_SDBS RT_BIT(3)
716#define AHCI_PORT_IS_DSS RT_BIT(2)
717#define AHCI_PORT_IS_PSS RT_BIT(1)
718#define AHCI_PORT_IS_DHRS RT_BIT(0)
719#define AHCI_PORT_IS_READONLY 0xfd8000af /* Readonly mask including reserved bits. */
720
721#define AHCI_PORT_IE_CPDE RT_BIT(31)
722#define AHCI_PORT_IE_TFEE RT_BIT(30)
723#define AHCI_PORT_IE_HBFE RT_BIT(29)
724#define AHCI_PORT_IE_HBDE RT_BIT(28)
725#define AHCI_PORT_IE_IFE RT_BIT(27)
726#define AHCI_PORT_IE_INFE RT_BIT(26)
727#define AHCI_PORT_IE_OFE RT_BIT(24)
728#define AHCI_PORT_IE_IPME RT_BIT(23)
729#define AHCI_PORT_IE_PRCE RT_BIT(22)
730#define AHCI_PORT_IE_DIE RT_BIT(7) /* Not supported for now, readonly. */
731#define AHCI_PORT_IE_PCE RT_BIT(6)
732#define AHCI_PORT_IE_DPE RT_BIT(5)
733#define AHCI_PORT_IE_UFE RT_BIT(4)
734#define AHCI_PORT_IE_SDBE RT_BIT(3)
735#define AHCI_PORT_IE_DSE RT_BIT(2)
736#define AHCI_PORT_IE_PSE RT_BIT(1)
737#define AHCI_PORT_IE_DHRE RT_BIT(0)
738#define AHCI_PORT_IE_READONLY (0xfdc000ff) /* Readonly mask including reserved bits. */
739
740#define AHCI_PORT_CMD_ICC (RT_BIT(28) | RT_BIT(29) | RT_BIT(30) | RT_BIT(31))
741#define AHCI_PORT_CMD_ICC_SHIFT(x) ((x) << 28)
742# define AHCI_PORT_CMD_ICC_IDLE 0x0
743# define AHCI_PORT_CMD_ICC_ACTIVE 0x1
744# define AHCI_PORT_CMD_ICC_PARTIAL 0x2
745# define AHCI_PORT_CMD_ICC_SLUMBER 0x6
746#define AHCI_PORT_CMD_ASP RT_BIT(27) /* Not supported - Readonly */
747#define AHCI_PORT_CMD_ALPE RT_BIT(26) /* Not supported - Readonly */
748#define AHCI_PORT_CMD_DLAE RT_BIT(25)
749#define AHCI_PORT_CMD_ATAPI RT_BIT(24)
750#define AHCI_PORT_CMD_CPD RT_BIT(20)
751#define AHCI_PORT_CMD_ISP RT_BIT(19) /* Readonly */
752#define AHCI_PORT_CMD_HPCP RT_BIT(18)
753#define AHCI_PORT_CMD_PMA RT_BIT(17) /* Not supported - Readonly */
754#define AHCI_PORT_CMD_CPS RT_BIT(16)
755#define AHCI_PORT_CMD_CR RT_BIT(15) /* Readonly */
756#define AHCI_PORT_CMD_FR RT_BIT(14) /* Readonly */
757#define AHCI_PORT_CMD_ISS RT_BIT(13) /* Readonly */
758#define AHCI_PORT_CMD_CCS (RT_BIT(8) | RT_BIT(9) | RT_BIT(10) | RT_BIT(11) | RT_BIT(12))
759#define AHCI_PORT_CMD_CCS_SHIFT(x) (x << 8) /* Readonly */
760#define AHCI_PORT_CMD_FRE RT_BIT(4)
761#define AHCI_PORT_CMD_CLO RT_BIT(3)
762#define AHCI_PORT_CMD_POD RT_BIT(2)
763#define AHCI_PORT_CMD_SUD RT_BIT(1)
764#define AHCI_PORT_CMD_ST RT_BIT(0)
765#define AHCI_PORT_CMD_READONLY (0xff02001f & ~(AHCI_PORT_CMD_ASP | AHCI_PORT_CMD_ALPE | AHCI_PORT_CMD_PMA))
766
767#define AHCI_PORT_SCTL_IPM (RT_BIT(11) | RT_BIT(10) | RT_BIT(9) | RT_BIT(8))
768#define AHCI_PORT_SCTL_IPM_GET(x) ((x & AHCI_PORT_SCTL_IPM) >> 8)
769#define AHCI_PORT_SCTL_SPD (RT_BIT(7) | RT_BIT(6) | RT_BIT(5) | RT_BIT(4))
770#define AHCI_PORT_SCTL_SPD_GET(x) ((x & AHCI_PORT_SCTL_SPD) >> 4)
771#define AHCI_PORT_SCTL_DET (RT_BIT(3) | RT_BIT(2) | RT_BIT(1) | RT_BIT(0))
772#define AHCI_PORT_SCTL_DET_GET(x) (x & AHCI_PORT_SCTL_DET)
773#define AHCI_PORT_SCTL_DET_NINIT 0
774#define AHCI_PORT_SCTL_DET_INIT 1
775#define AHCI_PORT_SCTL_DET_OFFLINE 4
776#define AHCI_PORT_SCTL_READONLY 0xfff
777
778#define AHCI_PORT_SSTS_IPM (RT_BIT(11) | RT_BIT(10) | RT_BIT(9) | RT_BIT(8))
779#define AHCI_PORT_SSTS_IPM_GET(x) ((x & AHCI_PORT_SCTL_IPM) >> 8)
780#define AHCI_PORT_SSTS_SPD (RT_BIT(7) | RT_BIT(6) | RT_BIT(5) | RT_BIT(4))
781#define AHCI_PORT_SSTS_SPD_GET(x) ((x & AHCI_PORT_SCTL_SPD) >> 4)
782#define AHCI_PORT_SSTS_DET (RT_BIT(3) | RT_BIT(2) | RT_BIT(1) | RT_BIT(0))
783#define AHCI_PORT_SSTS_DET_GET(x) (x & AHCI_PORT_SCTL_DET)
784
785#define AHCI_PORT_TFD_BSY RT_BIT(7)
786#define AHCI_PORT_TFD_DRQ RT_BIT(3)
787#define AHCI_PORT_TFD_ERR RT_BIT(0)
788
789#define AHCI_PORT_SERR_X RT_BIT(26)
790#define AHCI_PORT_SERR_W RT_BIT(18)
791#define AHCI_PORT_SERR_N RT_BIT(16)
792
793/* Signatures for attached storage devices. */
794#define AHCI_PORT_SIG_DISK 0x00000101
795#define AHCI_PORT_SIG_ATAPI 0xeb140101
796
797/*
798 * The AHCI spec defines an area of memory where the HBA posts received FIS's from the device.
799 * regFB points to the base of this area.
800 * Every FIS type has an offset where it is posted in this area.
801 */
802#define AHCI_RECFIS_DSFIS_OFFSET 0x00 /* DMA Setup FIS */
803#define AHCI_RECFIS_PSFIS_OFFSET 0x20 /* PIO Setup FIS */
804#define AHCI_RECFIS_RFIS_OFFSET 0x40 /* D2H Register FIS */
805#define AHCI_RECFIS_SDBFIS_OFFSET 0x58 /* Set Device Bits FIS */
806#define AHCI_RECFIS_UFIS_OFFSET 0x60 /* Unknown FIS type */
807
808/** Mask to get the LBA value from a LBA range. */
809#define AHCI_RANGE_LBA_MASK UINT64_C(0xffffffffffff)
810/** Mas to get the length value from a LBA range. */
811#define AHCI_RANGE_LENGTH_MASK UINT64_C(0xffff000000000000)
812/** Returns the length of the range in sectors. */
813#define AHCI_RANGE_LENGTH_GET(val) (((val) & AHCI_RANGE_LENGTH_MASK) >> 48)
814
815/**
816 * AHCI register operator.
817 */
818typedef struct ahci_opreg
819{
820 const char *pszName;
821 int (*pfnRead )(PAHCI pAhci, uint32_t iReg, uint32_t *pu32Value);
822 int (*pfnWrite)(PAHCI pAhci, uint32_t iReg, uint32_t u32Value);
823} AHCIOPREG;
824
825/**
826 * AHCI port register operator.
827 */
828typedef struct pAhciPort_opreg
829{
830 const char *pszName;
831 int (*pfnRead )(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value);
832 int (*pfnWrite)(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value);
833} AHCIPORTOPREG;
834
835#ifndef VBOX_DEVICE_STRUCT_TESTCASE
836RT_C_DECLS_BEGIN
837#ifdef IN_RING3
838static void ahciHBAReset(PAHCI pThis);
839static int ahciPostFisIntoMemory(PAHCIPort pAhciPort, unsigned uFisType, uint8_t *cmdFis);
840static void ahciPostFirstD2HFisIntoMemory(PAHCIPort pAhciPort);
841static size_t ahciR3CopyBufferToPrdtl(PAHCI pThis, PAHCIREQ pAhciReq, const void *pvSrc,
842 size_t cbSrc, size_t cbSkip);
843static bool ahciCancelActiveTasks(PAHCIPort pAhciPort);
844#endif
845RT_C_DECLS_END
846
847#define PCIDEV_2_PAHCI(pPciDev) ( (PAHCI)(pPciDev) )
848#define PDMIBASE_2_PAHCIPORT(pInterface) ( (PAHCIPort)((uintptr_t)(pInterface) - RT_UOFFSETOF(AHCIPort, IBase)) )
849#define PDMIMEDIAPORT_2_PAHCIPORT(pInterface) ( (PAHCIPort)((uintptr_t)(pInterface) - RT_UOFFSETOF(AHCIPort, IPort)) )
850#define PDMIBASE_2_PAHCI(pInterface) ( (PAHCI)((uintptr_t)(pInterface) - RT_UOFFSETOF(AHCI, IBase)) )
851#define PDMILEDPORTS_2_PAHCI(pInterface) ( (PAHCI)((uintptr_t)(pInterface) - RT_UOFFSETOF(AHCI, ILeds)) )
852
853#define AHCI_RTGCPHYS_FROM_U32(Hi, Lo) ( (RTGCPHYS)RT_MAKE_U64(Lo, Hi) )
854
855#ifdef IN_RING3
856
857# ifdef LOG_USE_C99
858# define ahciLog(a) \
859 Log(("R3 P%u: %M", pAhciPort->iLUN, _LogRelRemoveParentheseis a))
860# else
861# define ahciLog(a) \
862 do { Log(("R3 P%u: ", pAhciPort->iLUN)); Log(a); } while(0)
863# endif
864
865#elif defined(IN_RING0)
866
867# ifdef LOG_USE_C99
868# define ahciLog(a) \
869 Log(("R0 P%u: %M", pAhciPort->iLUN, _LogRelRemoveParentheseis a))
870# else
871# define ahciLog(a) \
872 do { Log(("R0 P%u: ", pAhciPort->iLUN)); Log(a); } while(0)
873# endif
874
875#elif defined(IN_RC)
876
877# ifdef LOG_USE_C99
878# define ahciLog(a) \
879 Log(("GC P%u: %M", pAhciPort->iLUN, _LogRelRemoveParentheseis a))
880# else
881# define ahciLog(a) \
882 do { Log(("GC P%u: ", pAhciPort->iLUN)); Log(a); } while(0)
883# endif
884
885#endif
886
887/**
888 * Update PCI IRQ levels
889 */
890static void ahciHbaClearInterrupt(PAHCI pAhci)
891{
892 Log(("%s: Clearing interrupt\n", __FUNCTION__));
893 PDMDevHlpPCISetIrq(pAhci->CTX_SUFF(pDevIns), 0, 0);
894}
895
896/**
897 * Updates the IRQ level and sets port bit in the global interrupt status register of the HBA.
898 */
899static int ahciHbaSetInterrupt(PAHCI pAhci, uint8_t iPort, int rcBusy)
900{
901 Log(("P%u: %s: Setting interrupt\n", iPort, __FUNCTION__));
902
903 int rc = PDMCritSectEnter(&pAhci->lock, rcBusy);
904 if (rc != VINF_SUCCESS)
905 return rc;
906
907 if (pAhci->regHbaCtrl & AHCI_HBA_CTRL_IE)
908 {
909 if ((pAhci->regHbaCccCtl & AHCI_HBA_CCC_CTL_EN) && (pAhci->regHbaCccPorts & (1 << iPort)))
910 {
911 pAhci->uCccCurrentNr++;
912 if (pAhci->uCccCurrentNr >= pAhci->uCccNr)
913 {
914 /* Reset command completion coalescing state. */
915 TMTimerSetMillies(pAhci->CTX_SUFF(pHbaCccTimer), pAhci->uCccTimeout);
916 pAhci->uCccCurrentNr = 0;
917
918 pAhci->u32PortsInterrupted |= (1 << pAhci->uCccPortNr);
919 if (!(pAhci->u32PortsInterrupted & ~(1 << pAhci->uCccPortNr)))
920 {
921 Log(("P%u: %s: Fire interrupt\n", iPort, __FUNCTION__));
922 PDMDevHlpPCISetIrq(pAhci->CTX_SUFF(pDevIns), 0, 1);
923 }
924 }
925 }
926 else
927 {
928 /* If only the bit of the actual port is set assert an interrupt
929 * because the interrupt status register was already read by the guest
930 * and we need to send a new notification.
931 * Otherwise an interrupt is still pending.
932 */
933 ASMAtomicOrU32((volatile uint32_t *)&pAhci->u32PortsInterrupted, (1 << iPort));
934 if (!(pAhci->u32PortsInterrupted & ~(1 << iPort)))
935 {
936 Log(("P%u: %s: Fire interrupt\n", iPort, __FUNCTION__));
937 PDMDevHlpPCISetIrq(pAhci->CTX_SUFF(pDevIns), 0, 1);
938 }
939 }
940 }
941
942 PDMCritSectLeave(&pAhci->lock);
943 return VINF_SUCCESS;
944}
945
946#ifdef IN_RING3
947
948/*
949 * Assert irq when an CCC timeout occurs
950 */
951static DECLCALLBACK(void) ahciCccTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
952{
953 RT_NOREF(pDevIns, pTimer);
954 PAHCI pAhci = (PAHCI)pvUser;
955
956 int rc = ahciHbaSetInterrupt(pAhci, pAhci->uCccPortNr, VERR_IGNORED);
957 AssertRC(rc);
958}
959
960/**
961 * Finishes the port reset of the given port.
962 *
963 * @returns nothing.
964 * @param pAhciPort The port to finish the reset on.
965 */
966static void ahciPortResetFinish(PAHCIPort pAhciPort)
967{
968 ahciLog(("%s: Initiated.\n", __FUNCTION__));
969
970 /* Cancel all tasks first. */
971 bool fAllTasksCanceled = ahciCancelActiveTasks(pAhciPort);
972 Assert(fAllTasksCanceled); NOREF(fAllTasksCanceled);
973
974 /* Signature for SATA device. */
975 if (pAhciPort->fATAPI)
976 pAhciPort->regSIG = AHCI_PORT_SIG_ATAPI;
977 else
978 pAhciPort->regSIG = AHCI_PORT_SIG_DISK;
979
980 /* We received a COMINIT from the device. Tell the guest. */
981 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_PCS);
982 pAhciPort->regSERR |= AHCI_PORT_SERR_X;
983 pAhciPort->regTFD |= ATA_STAT_BUSY;
984
985 if ((pAhciPort->regCMD & AHCI_PORT_CMD_FRE) && (!pAhciPort->fFirstD2HFisSent))
986 {
987 ahciPostFirstD2HFisIntoMemory(pAhciPort);
988 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_DHRS);
989
990 if (pAhciPort->regIE & AHCI_PORT_IE_DHRE)
991 {
992 int rc = ahciHbaSetInterrupt(pAhciPort->CTX_SUFF(pAhci), pAhciPort->iLUN, VERR_IGNORED);
993 AssertRC(rc);
994 }
995 }
996
997 pAhciPort->regSSTS = (0x01 << 8) | /* Interface is active. */
998 (0x03 << 0); /* Device detected and communication established. */
999
1000 /*
1001 * Use the maximum allowed speed.
1002 * (Not that it changes anything really)
1003 */
1004 switch (AHCI_PORT_SCTL_SPD_GET(pAhciPort->regSCTL))
1005 {
1006 case 0x01:
1007 pAhciPort->regSSTS |= (0x01 << 4); /* Generation 1 (1.5GBps) speed. */
1008 break;
1009 case 0x02:
1010 case 0x00:
1011 default:
1012 pAhciPort->regSSTS |= (0x02 << 4); /* Generation 2 (3.0GBps) speed. */
1013 break;
1014 }
1015
1016 ASMAtomicXchgBool(&pAhciPort->fPortReset, false);
1017}
1018
1019#endif /* IN_RING3 */
1020
1021/**
1022 * Kicks the I/O thread from RC or R0.
1023 *
1024 * @returns nothing.
1025 * @param pAhci The AHCI controller instance.
1026 * @param pAhciPort The port to kick.
1027 */
1028static void ahciIoThreadKick(PAHCI pAhci, PAHCIPort pAhciPort)
1029{
1030#ifdef IN_RC
1031 PDEVPORTNOTIFIERQUEUEITEM pItem = (PDEVPORTNOTIFIERQUEUEITEM)PDMQueueAlloc(pAhci->CTX_SUFF(pNotifierQueue));
1032 AssertMsg(VALID_PTR(pItem), ("Allocating item for queue failed\n"));
1033
1034 if (pItem)
1035 {
1036 pItem->iPort = pAhciPort->iLUN;
1037 PDMQueueInsert(pAhci->CTX_SUFF(pNotifierQueue), (PPDMQUEUEITEMCORE)pItem);
1038 }
1039#else
1040 LogFlowFunc(("Signal event semaphore\n"));
1041 int rc = SUPSemEventSignal(pAhci->pSupDrvSession, pAhciPort->hEvtProcess);
1042 AssertRC(rc);
1043#endif
1044}
1045
1046static int PortCmdIssue_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1047{
1048 RT_NOREF1(iReg);
1049 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1050
1051 /* Update the CI register first. */
1052 uint32_t uCIValue = ASMAtomicXchgU32(&pAhciPort->u32TasksFinished, 0);
1053 pAhciPort->regCI &= ~uCIValue;
1054
1055 if ( (pAhciPort->regCMD & AHCI_PORT_CMD_CR)
1056 && u32Value > 0)
1057 {
1058 /*
1059 * Clear all tasks which are already marked as busy. The guest
1060 * shouldn't write already busy tasks actually.
1061 */
1062 u32Value &= ~pAhciPort->regCI;
1063
1064 ASMAtomicOrU32(&pAhciPort->u32TasksNew, u32Value);
1065
1066 /* Send a notification to R3 if u32TasksNew was 0 before our write. */
1067 if (ASMAtomicReadBool(&pAhciPort->fWrkThreadSleeping))
1068 ahciIoThreadKick(pAhci, pAhciPort);
1069 else
1070 ahciLog(("%s: Worker thread busy, no need to kick.\n", __FUNCTION__));
1071 }
1072 else
1073 ahciLog(("%s: Nothing to do (CMD=%08x).\n", __FUNCTION__, pAhciPort->regCMD));
1074
1075 pAhciPort->regCI |= u32Value;
1076
1077 return VINF_SUCCESS;
1078}
1079
1080static int PortCmdIssue_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1081{
1082 RT_NOREF2(pAhci, iReg);
1083
1084 uint32_t uCIValue = ASMAtomicXchgU32(&pAhciPort->u32TasksFinished, 0);
1085 ahciLog(("%s: read regCI=%#010x uCIValue=%#010x\n", __FUNCTION__, pAhciPort->regCI, uCIValue));
1086
1087 pAhciPort->regCI &= ~uCIValue;
1088 *pu32Value = pAhciPort->regCI;
1089
1090 return VINF_SUCCESS;
1091}
1092
1093static int PortSActive_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1094{
1095 RT_NOREF2(pAhci, iReg);
1096 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1097
1098 pAhciPort->regSACT |= u32Value;
1099
1100 return VINF_SUCCESS;
1101}
1102
1103static int PortSActive_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1104{
1105 RT_NOREF2(pAhci, iReg);
1106
1107 uint32_t u32TasksFinished = ASMAtomicXchgU32(&pAhciPort->u32QueuedTasksFinished, 0);
1108 pAhciPort->regSACT &= ~u32TasksFinished;
1109
1110 ahciLog(("%s: read regSACT=%#010x regCI=%#010x u32TasksFinished=%#010x\n",
1111 __FUNCTION__, pAhciPort->regSACT, pAhciPort->regCI, u32TasksFinished));
1112
1113 *pu32Value = pAhciPort->regSACT;
1114
1115 return VINF_SUCCESS;
1116}
1117
1118static int PortSError_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1119{
1120 RT_NOREF2(pAhci, iReg);
1121 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1122
1123 if ( (u32Value & AHCI_PORT_SERR_X)
1124 && (pAhciPort->regSERR & AHCI_PORT_SERR_X))
1125 {
1126 ASMAtomicAndU32(&pAhciPort->regIS, ~AHCI_PORT_IS_PCS);
1127 pAhciPort->regTFD |= ATA_STAT_ERR;
1128 pAhciPort->regTFD &= ~(ATA_STAT_DRQ | ATA_STAT_BUSY);
1129 }
1130
1131 if ( (u32Value & AHCI_PORT_SERR_N)
1132 && (pAhciPort->regSERR & AHCI_PORT_SERR_N))
1133 ASMAtomicAndU32(&pAhciPort->regIS, ~AHCI_PORT_IS_PRCS);
1134
1135 pAhciPort->regSERR &= ~u32Value;
1136
1137 return VINF_SUCCESS;
1138}
1139
1140static int PortSError_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1141{
1142 RT_NOREF2(pAhci, iReg);
1143 ahciLog(("%s: read regSERR=%#010x\n", __FUNCTION__, pAhciPort->regSERR));
1144 *pu32Value = pAhciPort->regSERR;
1145 return VINF_SUCCESS;
1146}
1147
1148static int PortSControl_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1149{
1150 RT_NOREF2(pAhci, iReg);
1151 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1152 ahciLog(("%s: IPM=%d SPD=%d DET=%d\n", __FUNCTION__,
1153 AHCI_PORT_SCTL_IPM_GET(u32Value), AHCI_PORT_SCTL_SPD_GET(u32Value), AHCI_PORT_SCTL_DET_GET(u32Value)));
1154
1155#ifndef IN_RING3
1156 RT_NOREF2(pAhciPort, u32Value);
1157 return VINF_IOM_R3_MMIO_WRITE;
1158#else
1159 if ((u32Value & AHCI_PORT_SCTL_DET) == AHCI_PORT_SCTL_DET_INIT)
1160 {
1161 if (!ASMAtomicXchgBool(&pAhciPort->fPortReset, true))
1162 LogRel(("AHCI#%u: Port %d reset\n", pAhci->CTX_SUFF(pDevIns)->iInstance,
1163 pAhciPort->iLUN));
1164
1165 pAhciPort->regSSTS = 0;
1166 pAhciPort->regSIG = UINT32_MAX;
1167 pAhciPort->regTFD = 0x7f;
1168 pAhciPort->fFirstD2HFisSent = false;
1169 pAhciPort->regSCTL = u32Value;
1170 }
1171 else if ( (u32Value & AHCI_PORT_SCTL_DET) == AHCI_PORT_SCTL_DET_NINIT
1172 && (pAhciPort->regSCTL & AHCI_PORT_SCTL_DET) == AHCI_PORT_SCTL_DET_INIT
1173 && pAhciPort->pDrvBase)
1174 {
1175 /* Do the port reset here, so the guest sees the new status immediately. */
1176 if (pAhci->fLegacyPortResetMethod)
1177 {
1178 ahciPortResetFinish(pAhciPort);
1179 pAhciPort->regSCTL = u32Value; /* Update after finishing the reset, so the I/O thread doesn't get a chance to do the reset. */
1180 }
1181 else
1182 {
1183 if (!pAhci->fTigerHack)
1184 pAhciPort->regSSTS = 0x1; /* Indicate device presence detected but communication not established. */
1185 else
1186 pAhciPort->regSSTS = 0x0; /* Indicate no device detected after COMRESET. [tiger hack] */
1187 pAhciPort->regSCTL = u32Value; /* Update before kicking the I/O thread. */
1188
1189 /* Kick the thread to finish the reset. */
1190 ahciIoThreadKick(pAhci, pAhciPort);
1191 }
1192 }
1193 else /* Just update the value if there is no device attached. */
1194 pAhciPort->regSCTL = u32Value;
1195
1196 return VINF_SUCCESS;
1197#endif
1198}
1199
1200static int PortSControl_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1201{
1202 RT_NOREF2(pAhci, iReg);
1203 ahciLog(("%s: read regSCTL=%#010x\n", __FUNCTION__, pAhciPort->regSCTL));
1204 ahciLog(("%s: IPM=%d SPD=%d DET=%d\n", __FUNCTION__,
1205 AHCI_PORT_SCTL_IPM_GET(pAhciPort->regSCTL), AHCI_PORT_SCTL_SPD_GET(pAhciPort->regSCTL),
1206 AHCI_PORT_SCTL_DET_GET(pAhciPort->regSCTL)));
1207
1208 *pu32Value = pAhciPort->regSCTL;
1209 return VINF_SUCCESS;
1210}
1211
1212static int PortSStatus_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1213{
1214 RT_NOREF2(pAhci, iReg);
1215 ahciLog(("%s: read regSSTS=%#010x\n", __FUNCTION__, pAhciPort->regSSTS));
1216 ahciLog(("%s: IPM=%d SPD=%d DET=%d\n", __FUNCTION__,
1217 AHCI_PORT_SSTS_IPM_GET(pAhciPort->regSSTS), AHCI_PORT_SSTS_SPD_GET(pAhciPort->regSSTS),
1218 AHCI_PORT_SSTS_DET_GET(pAhciPort->regSSTS)));
1219
1220 *pu32Value = pAhciPort->regSSTS;
1221 return VINF_SUCCESS;
1222}
1223
1224static int PortSignature_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1225{
1226 RT_NOREF2(pAhci, iReg);
1227 ahciLog(("%s: read regSIG=%#010x\n", __FUNCTION__, pAhciPort->regSIG));
1228 *pu32Value = pAhciPort->regSIG;
1229 return VINF_SUCCESS;
1230}
1231
1232static int PortTaskFileData_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1233{
1234 RT_NOREF2(pAhci, iReg);
1235 ahciLog(("%s: read regTFD=%#010x\n", __FUNCTION__, pAhciPort->regTFD));
1236 ahciLog(("%s: ERR=%x BSY=%d DRQ=%d ERR=%d\n", __FUNCTION__,
1237 (pAhciPort->regTFD >> 8), (pAhciPort->regTFD & AHCI_PORT_TFD_BSY) >> 7,
1238 (pAhciPort->regTFD & AHCI_PORT_TFD_DRQ) >> 3, (pAhciPort->regTFD & AHCI_PORT_TFD_ERR)));
1239 *pu32Value = pAhciPort->regTFD;
1240 return VINF_SUCCESS;
1241}
1242
1243/**
1244 * Read from the port command register.
1245 */
1246static int PortCmd_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1247{
1248 RT_NOREF2(pAhci, iReg);
1249 ahciLog(("%s: read regCMD=%#010x\n", __FUNCTION__, pAhciPort->regCMD | AHCI_PORT_CMD_CCS_SHIFT(pAhciPort->u32CurrentCommandSlot)));
1250 ahciLog(("%s: ICC=%d ASP=%d ALPE=%d DLAE=%d ATAPI=%d CPD=%d ISP=%d HPCP=%d PMA=%d CPS=%d CR=%d FR=%d ISS=%d CCS=%d FRE=%d CLO=%d POD=%d SUD=%d ST=%d\n",
1251 __FUNCTION__, (pAhciPort->regCMD & AHCI_PORT_CMD_ICC) >> 28, (pAhciPort->regCMD & AHCI_PORT_CMD_ASP) >> 27,
1252 (pAhciPort->regCMD & AHCI_PORT_CMD_ALPE) >> 26, (pAhciPort->regCMD & AHCI_PORT_CMD_DLAE) >> 25,
1253 (pAhciPort->regCMD & AHCI_PORT_CMD_ATAPI) >> 24, (pAhciPort->regCMD & AHCI_PORT_CMD_CPD) >> 20,
1254 (pAhciPort->regCMD & AHCI_PORT_CMD_ISP) >> 19, (pAhciPort->regCMD & AHCI_PORT_CMD_HPCP) >> 18,
1255 (pAhciPort->regCMD & AHCI_PORT_CMD_PMA) >> 17, (pAhciPort->regCMD & AHCI_PORT_CMD_CPS) >> 16,
1256 (pAhciPort->regCMD & AHCI_PORT_CMD_CR) >> 15, (pAhciPort->regCMD & AHCI_PORT_CMD_FR) >> 14,
1257 (pAhciPort->regCMD & AHCI_PORT_CMD_ISS) >> 13, pAhciPort->u32CurrentCommandSlot,
1258 (pAhciPort->regCMD & AHCI_PORT_CMD_FRE) >> 4, (pAhciPort->regCMD & AHCI_PORT_CMD_CLO) >> 3,
1259 (pAhciPort->regCMD & AHCI_PORT_CMD_POD) >> 2, (pAhciPort->regCMD & AHCI_PORT_CMD_SUD) >> 1,
1260 (pAhciPort->regCMD & AHCI_PORT_CMD_ST)));
1261 *pu32Value = pAhciPort->regCMD | AHCI_PORT_CMD_CCS_SHIFT(pAhciPort->u32CurrentCommandSlot);
1262 return VINF_SUCCESS;
1263}
1264
1265/**
1266 * Write to the port command register.
1267 * This is the register where all the data transfer is started
1268 */
1269static int PortCmd_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1270{
1271 RT_NOREF1(iReg);
1272 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1273 ahciLog(("%s: ICC=%d ASP=%d ALPE=%d DLAE=%d ATAPI=%d CPD=%d ISP=%d HPCP=%d PMA=%d CPS=%d CR=%d FR=%d ISS=%d CCS=%d FRE=%d CLO=%d POD=%d SUD=%d ST=%d\n",
1274 __FUNCTION__, (u32Value & AHCI_PORT_CMD_ICC) >> 28, (u32Value & AHCI_PORT_CMD_ASP) >> 27,
1275 (u32Value & AHCI_PORT_CMD_ALPE) >> 26, (u32Value & AHCI_PORT_CMD_DLAE) >> 25,
1276 (u32Value & AHCI_PORT_CMD_ATAPI) >> 24, (u32Value & AHCI_PORT_CMD_CPD) >> 20,
1277 (u32Value & AHCI_PORT_CMD_ISP) >> 19, (u32Value & AHCI_PORT_CMD_HPCP) >> 18,
1278 (u32Value & AHCI_PORT_CMD_PMA) >> 17, (u32Value & AHCI_PORT_CMD_CPS) >> 16,
1279 (u32Value & AHCI_PORT_CMD_CR) >> 15, (u32Value & AHCI_PORT_CMD_FR) >> 14,
1280 (u32Value & AHCI_PORT_CMD_ISS) >> 13, (u32Value & AHCI_PORT_CMD_CCS) >> 8,
1281 (u32Value & AHCI_PORT_CMD_FRE) >> 4, (u32Value & AHCI_PORT_CMD_CLO) >> 3,
1282 (u32Value & AHCI_PORT_CMD_POD) >> 2, (u32Value & AHCI_PORT_CMD_SUD) >> 1,
1283 (u32Value & AHCI_PORT_CMD_ST)));
1284
1285 /* The PxCMD.CCS bits are R/O and maintained separately. */
1286 u32Value &= ~AHCI_PORT_CMD_CCS;
1287
1288 if (pAhciPort->fPoweredOn && pAhciPort->fSpunUp)
1289 {
1290 if (u32Value & AHCI_PORT_CMD_CLO)
1291 {
1292 ahciLog(("%s: Command list override requested\n", __FUNCTION__));
1293 u32Value &= ~(AHCI_PORT_TFD_BSY | AHCI_PORT_TFD_DRQ);
1294 /* Clear the CLO bit. */
1295 u32Value &= ~(AHCI_PORT_CMD_CLO);
1296 }
1297
1298 if (u32Value & AHCI_PORT_CMD_ST)
1299 {
1300 /*
1301 * Set engine state to running if there is a device attached and
1302 * IS.PCS is clear.
1303 */
1304 if ( pAhciPort->pDrvBase
1305 && !(pAhciPort->regIS & AHCI_PORT_IS_PCS))
1306 {
1307 ahciLog(("%s: Engine starts\n", __FUNCTION__));
1308 u32Value |= AHCI_PORT_CMD_CR;
1309
1310 /* If there is something in CI, kick the I/O thread. */
1311 if ( pAhciPort->regCI > 0
1312 && ASMAtomicReadBool(&pAhciPort->fWrkThreadSleeping))
1313 {
1314 ASMAtomicOrU32(&pAhciPort->u32TasksNew, pAhciPort->regCI);
1315#ifdef IN_RC
1316 PDEVPORTNOTIFIERQUEUEITEM pItem = (PDEVPORTNOTIFIERQUEUEITEM)PDMQueueAlloc(pAhci->CTX_SUFF(pNotifierQueue));
1317 AssertMsg(VALID_PTR(pItem), ("Allocating item for queue failed\n"));
1318
1319 pItem->iPort = pAhciPort->iLUN;
1320 PDMQueueInsert(pAhci->CTX_SUFF(pNotifierQueue), (PPDMQUEUEITEMCORE)pItem);
1321#else
1322 LogFlowFunc(("Signal event semaphore\n"));
1323 int rc = SUPSemEventSignal(pAhci->pSupDrvSession, pAhciPort->hEvtProcess);
1324 AssertRC(rc);
1325#endif
1326 }
1327 }
1328 else
1329 {
1330 if (!pAhciPort->pDrvBase)
1331 ahciLog(("%s: No pDrvBase, clearing PxCMD.CR!\n", __FUNCTION__));
1332 else
1333 ahciLog(("%s: PxIS.PCS set (PxIS=%#010x), clearing PxCMD.CR!\n", __FUNCTION__, pAhciPort->regIS));
1334
1335 u32Value &= ~AHCI_PORT_CMD_CR;
1336 }
1337 }
1338 else
1339 {
1340 ahciLog(("%s: Engine stops\n", __FUNCTION__));
1341 /* Clear command issue register. */
1342 pAhciPort->regCI = 0;
1343 pAhciPort->regSACT = 0;
1344 /* Clear current command slot. */
1345 pAhciPort->u32CurrentCommandSlot = 0;
1346 u32Value &= ~AHCI_PORT_CMD_CR;
1347 }
1348 }
1349 else if (pAhciPort->pDrvBase)
1350 {
1351 if ((u32Value & AHCI_PORT_CMD_POD) && (pAhciPort->regCMD & AHCI_PORT_CMD_CPS) && !pAhciPort->fPoweredOn)
1352 {
1353 ahciLog(("%s: Power on the device\n", __FUNCTION__));
1354 pAhciPort->fPoweredOn = true;
1355
1356 /*
1357 * Set states in the Port Signature and SStatus registers.
1358 */
1359 if (pAhciPort->fATAPI)
1360 pAhciPort->regSIG = AHCI_PORT_SIG_ATAPI;
1361 else
1362 pAhciPort->regSIG = AHCI_PORT_SIG_DISK;
1363 pAhciPort->regSSTS = (0x01 << 8) | /* Interface is active. */
1364 (0x02 << 4) | /* Generation 2 (3.0GBps) speed. */
1365 (0x03 << 0); /* Device detected and communication established. */
1366
1367 if (pAhciPort->regCMD & AHCI_PORT_CMD_FRE)
1368 {
1369#ifndef IN_RING3
1370 return VINF_IOM_R3_MMIO_WRITE;
1371#else
1372 ahciPostFirstD2HFisIntoMemory(pAhciPort);
1373 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_DHRS);
1374
1375 if (pAhciPort->regIE & AHCI_PORT_IE_DHRE)
1376 {
1377 int rc = ahciHbaSetInterrupt(pAhciPort->CTX_SUFF(pAhci), pAhciPort->iLUN, VERR_IGNORED);
1378 AssertRC(rc);
1379 }
1380#endif
1381 }
1382 }
1383
1384 if ((u32Value & AHCI_PORT_CMD_SUD) && pAhciPort->fPoweredOn && !pAhciPort->fSpunUp)
1385 {
1386 ahciLog(("%s: Spin up the device\n", __FUNCTION__));
1387 pAhciPort->fSpunUp = true;
1388 }
1389 }
1390 else
1391 ahciLog(("%s: No pDrvBase, no fPoweredOn + fSpunUp, doing nothing!\n", __FUNCTION__));
1392
1393 if (u32Value & AHCI_PORT_CMD_FRE)
1394 {
1395 ahciLog(("%s: FIS receive enabled\n", __FUNCTION__));
1396
1397 u32Value |= AHCI_PORT_CMD_FR;
1398
1399 /* Send the first D2H FIS only if it wasn't already sent. */
1400 if ( !pAhciPort->fFirstD2HFisSent
1401 && pAhciPort->pDrvBase)
1402 {
1403#ifndef IN_RING3
1404 return VINF_IOM_R3_MMIO_WRITE;
1405#else
1406 ahciPostFirstD2HFisIntoMemory(pAhciPort);
1407 pAhciPort->fFirstD2HFisSent = true;
1408#endif
1409 }
1410 }
1411 else if (!(u32Value & AHCI_PORT_CMD_FRE))
1412 {
1413 ahciLog(("%s: FIS receive disabled\n", __FUNCTION__));
1414 u32Value &= ~AHCI_PORT_CMD_FR;
1415 }
1416
1417 pAhciPort->regCMD = u32Value;
1418
1419 return VINF_SUCCESS;
1420}
1421
1422/**
1423 * Read from the port interrupt enable register.
1424 */
1425static int PortIntrEnable_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1426{
1427 RT_NOREF2(pAhci, iReg);
1428 ahciLog(("%s: read regIE=%#010x\n", __FUNCTION__, pAhciPort->regIE));
1429 ahciLog(("%s: CPDE=%d TFEE=%d HBFE=%d HBDE=%d IFE=%d INFE=%d OFE=%d IPME=%d PRCE=%d DIE=%d PCE=%d DPE=%d UFE=%d SDBE=%d DSE=%d PSE=%d DHRE=%d\n",
1430 __FUNCTION__, (pAhciPort->regIE & AHCI_PORT_IE_CPDE) >> 31, (pAhciPort->regIE & AHCI_PORT_IE_TFEE) >> 30,
1431 (pAhciPort->regIE & AHCI_PORT_IE_HBFE) >> 29, (pAhciPort->regIE & AHCI_PORT_IE_HBDE) >> 28,
1432 (pAhciPort->regIE & AHCI_PORT_IE_IFE) >> 27, (pAhciPort->regIE & AHCI_PORT_IE_INFE) >> 26,
1433 (pAhciPort->regIE & AHCI_PORT_IE_OFE) >> 24, (pAhciPort->regIE & AHCI_PORT_IE_IPME) >> 23,
1434 (pAhciPort->regIE & AHCI_PORT_IE_PRCE) >> 22, (pAhciPort->regIE & AHCI_PORT_IE_DIE) >> 7,
1435 (pAhciPort->regIE & AHCI_PORT_IE_PCE) >> 6, (pAhciPort->regIE & AHCI_PORT_IE_DPE) >> 5,
1436 (pAhciPort->regIE & AHCI_PORT_IE_UFE) >> 4, (pAhciPort->regIE & AHCI_PORT_IE_SDBE) >> 3,
1437 (pAhciPort->regIE & AHCI_PORT_IE_DSE) >> 2, (pAhciPort->regIE & AHCI_PORT_IE_PSE) >> 1,
1438 (pAhciPort->regIE & AHCI_PORT_IE_DHRE)));
1439 *pu32Value = pAhciPort->regIE;
1440 return VINF_SUCCESS;
1441}
1442
1443/**
1444 * Write to the port interrupt enable register.
1445 */
1446static int PortIntrEnable_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1447{
1448 RT_NOREF1(iReg);
1449 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1450 ahciLog(("%s: CPDE=%d TFEE=%d HBFE=%d HBDE=%d IFE=%d INFE=%d OFE=%d IPME=%d PRCE=%d DIE=%d PCE=%d DPE=%d UFE=%d SDBE=%d DSE=%d PSE=%d DHRE=%d\n",
1451 __FUNCTION__, (u32Value & AHCI_PORT_IE_CPDE) >> 31, (u32Value & AHCI_PORT_IE_TFEE) >> 30,
1452 (u32Value & AHCI_PORT_IE_HBFE) >> 29, (u32Value & AHCI_PORT_IE_HBDE) >> 28,
1453 (u32Value & AHCI_PORT_IE_IFE) >> 27, (u32Value & AHCI_PORT_IE_INFE) >> 26,
1454 (u32Value & AHCI_PORT_IE_OFE) >> 24, (u32Value & AHCI_PORT_IE_IPME) >> 23,
1455 (u32Value & AHCI_PORT_IE_PRCE) >> 22, (u32Value & AHCI_PORT_IE_DIE) >> 7,
1456 (u32Value & AHCI_PORT_IE_PCE) >> 6, (u32Value & AHCI_PORT_IE_DPE) >> 5,
1457 (u32Value & AHCI_PORT_IE_UFE) >> 4, (u32Value & AHCI_PORT_IE_SDBE) >> 3,
1458 (u32Value & AHCI_PORT_IE_DSE) >> 2, (u32Value & AHCI_PORT_IE_PSE) >> 1,
1459 (u32Value & AHCI_PORT_IE_DHRE)));
1460
1461 u32Value &= AHCI_PORT_IE_READONLY;
1462
1463 /* Check if some a interrupt status bit changed*/
1464 uint32_t u32IntrStatus = ASMAtomicReadU32(&pAhciPort->regIS);
1465
1466 int rc = VINF_SUCCESS;
1467 if (u32Value & u32IntrStatus)
1468 rc = ahciHbaSetInterrupt(pAhci, pAhciPort->iLUN, VINF_IOM_R3_MMIO_WRITE);
1469
1470 if (rc == VINF_SUCCESS)
1471 pAhciPort->regIE = u32Value;
1472
1473 return rc;
1474}
1475
1476/**
1477 * Read from the port interrupt status register.
1478 */
1479static int PortIntrSts_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1480{
1481 RT_NOREF2(pAhci, iReg);
1482 ahciLog(("%s: read regIS=%#010x\n", __FUNCTION__, pAhciPort->regIS));
1483 ahciLog(("%s: CPDS=%d TFES=%d HBFS=%d HBDS=%d IFS=%d INFS=%d OFS=%d IPMS=%d PRCS=%d DIS=%d PCS=%d DPS=%d UFS=%d SDBS=%d DSS=%d PSS=%d DHRS=%d\n",
1484 __FUNCTION__, (pAhciPort->regIS & AHCI_PORT_IS_CPDS) >> 31, (pAhciPort->regIS & AHCI_PORT_IS_TFES) >> 30,
1485 (pAhciPort->regIS & AHCI_PORT_IS_HBFS) >> 29, (pAhciPort->regIS & AHCI_PORT_IS_HBDS) >> 28,
1486 (pAhciPort->regIS & AHCI_PORT_IS_IFS) >> 27, (pAhciPort->regIS & AHCI_PORT_IS_INFS) >> 26,
1487 (pAhciPort->regIS & AHCI_PORT_IS_OFS) >> 24, (pAhciPort->regIS & AHCI_PORT_IS_IPMS) >> 23,
1488 (pAhciPort->regIS & AHCI_PORT_IS_PRCS) >> 22, (pAhciPort->regIS & AHCI_PORT_IS_DIS) >> 7,
1489 (pAhciPort->regIS & AHCI_PORT_IS_PCS) >> 6, (pAhciPort->regIS & AHCI_PORT_IS_DPS) >> 5,
1490 (pAhciPort->regIS & AHCI_PORT_IS_UFS) >> 4, (pAhciPort->regIS & AHCI_PORT_IS_SDBS) >> 3,
1491 (pAhciPort->regIS & AHCI_PORT_IS_DSS) >> 2, (pAhciPort->regIS & AHCI_PORT_IS_PSS) >> 1,
1492 (pAhciPort->regIS & AHCI_PORT_IS_DHRS)));
1493 *pu32Value = pAhciPort->regIS;
1494 return VINF_SUCCESS;
1495}
1496
1497/**
1498 * Write to the port interrupt status register.
1499 */
1500static int PortIntrSts_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1501{
1502 RT_NOREF2(pAhci, iReg);
1503 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1504 ASMAtomicAndU32(&pAhciPort->regIS, ~(u32Value & AHCI_PORT_IS_READONLY));
1505
1506 return VINF_SUCCESS;
1507}
1508
1509/**
1510 * Read from the port FIS base address upper 32bit register.
1511 */
1512static int PortFisAddrUp_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1513{
1514 RT_NOREF2(pAhci, iReg);
1515 ahciLog(("%s: read regFBU=%#010x\n", __FUNCTION__, pAhciPort->regFBU));
1516 *pu32Value = pAhciPort->regFBU;
1517 return VINF_SUCCESS;
1518}
1519
1520/**
1521 * Write to the port FIS base address upper 32bit register.
1522 */
1523static int PortFisAddrUp_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1524{
1525 RT_NOREF2(pAhci, iReg);
1526 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1527
1528 pAhciPort->regFBU = u32Value;
1529 pAhciPort->GCPhysAddrFb = AHCI_RTGCPHYS_FROM_U32(pAhciPort->regFBU, pAhciPort->regFB);
1530
1531 return VINF_SUCCESS;
1532}
1533
1534/**
1535 * Read from the port FIS base address register.
1536 */
1537static int PortFisAddr_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1538{
1539 RT_NOREF2(pAhci, iReg);
1540 ahciLog(("%s: read regFB=%#010x\n", __FUNCTION__, pAhciPort->regFB));
1541 *pu32Value = pAhciPort->regFB;
1542 return VINF_SUCCESS;
1543}
1544
1545/**
1546 * Write to the port FIS base address register.
1547 */
1548static int PortFisAddr_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1549{
1550 RT_NOREF2(pAhci, iReg);
1551 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1552
1553 Assert(!(u32Value & ~AHCI_PORT_FB_RESERVED));
1554
1555 pAhciPort->regFB = (u32Value & AHCI_PORT_FB_RESERVED);
1556 pAhciPort->GCPhysAddrFb = AHCI_RTGCPHYS_FROM_U32(pAhciPort->regFBU, pAhciPort->regFB);
1557
1558 return VINF_SUCCESS;
1559}
1560
1561/**
1562 * Write to the port command list base address upper 32bit register.
1563 */
1564static int PortCmdLstAddrUp_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1565{
1566 RT_NOREF2(pAhci, iReg);
1567 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1568
1569 pAhciPort->regCLBU = u32Value;
1570 pAhciPort->GCPhysAddrClb = AHCI_RTGCPHYS_FROM_U32(pAhciPort->regCLBU, pAhciPort->regCLB);
1571
1572 return VINF_SUCCESS;
1573}
1574
1575/**
1576 * Read from the port command list base address upper 32bit register.
1577 */
1578static int PortCmdLstAddrUp_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1579{
1580 RT_NOREF2(pAhci, iReg);
1581 ahciLog(("%s: read regCLBU=%#010x\n", __FUNCTION__, pAhciPort->regCLBU));
1582 *pu32Value = pAhciPort->regCLBU;
1583 return VINF_SUCCESS;
1584}
1585
1586/**
1587 * Read from the port command list base address register.
1588 */
1589static int PortCmdLstAddr_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1590{
1591 RT_NOREF2(pAhci, iReg);
1592 ahciLog(("%s: read regCLB=%#010x\n", __FUNCTION__, pAhciPort->regCLB));
1593 *pu32Value = pAhciPort->regCLB;
1594 return VINF_SUCCESS;
1595}
1596
1597/**
1598 * Write to the port command list base address register.
1599 */
1600static int PortCmdLstAddr_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1601{
1602 RT_NOREF2(pAhci, iReg);
1603 ahciLog(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1604
1605 Assert(!(u32Value & ~AHCI_PORT_CLB_RESERVED));
1606
1607 pAhciPort->regCLB = (u32Value & AHCI_PORT_CLB_RESERVED);
1608 pAhciPort->GCPhysAddrClb = AHCI_RTGCPHYS_FROM_U32(pAhciPort->regCLBU, pAhciPort->regCLB);
1609
1610 return VINF_SUCCESS;
1611}
1612
1613/**
1614 * Read from the global Version register.
1615 */
1616static int HbaVersion_r(PAHCI pAhci, uint32_t iReg, uint32_t *pu32Value)
1617{
1618 RT_NOREF1(iReg);
1619 Log(("%s: read regHbaVs=%#010x\n", __FUNCTION__, pAhci->regHbaVs));
1620 *pu32Value = pAhci->regHbaVs;
1621 return VINF_SUCCESS;
1622}
1623
1624/**
1625 * Read from the global Ports implemented register.
1626 */
1627static int HbaPortsImplemented_r(PAHCI pAhci, uint32_t iReg, uint32_t *pu32Value)
1628{
1629 RT_NOREF1(iReg);
1630 Log(("%s: read regHbaPi=%#010x\n", __FUNCTION__, pAhci->regHbaPi));
1631 *pu32Value = pAhci->regHbaPi;
1632 return VINF_SUCCESS;
1633}
1634
1635/**
1636 * Write to the global interrupt status register.
1637 */
1638static int HbaInterruptStatus_w(PAHCI pAhci, uint32_t iReg, uint32_t u32Value)
1639{
1640 RT_NOREF1(iReg);
1641 Log(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1642
1643 int rc = PDMCritSectEnter(&pAhci->lock, VINF_IOM_R3_MMIO_WRITE);
1644 if (rc != VINF_SUCCESS)
1645 return rc;
1646
1647 pAhci->regHbaIs &= ~(u32Value);
1648
1649 /*
1650 * Update interrupt status register and check for ports who
1651 * set the interrupt inbetween.
1652 */
1653 bool fClear = true;
1654 pAhci->regHbaIs |= ASMAtomicXchgU32(&pAhci->u32PortsInterrupted, 0);
1655 if (!pAhci->regHbaIs)
1656 {
1657 unsigned i = 0;
1658
1659 /* Check if the cleared ports have a interrupt status bit set. */
1660 while ((u32Value > 0) && (i < AHCI_MAX_NR_PORTS_IMPL))
1661 {
1662 if (u32Value & 0x01)
1663 {
1664 PAHCIPort pAhciPort = &pAhci->ahciPort[i];
1665
1666 if (pAhciPort->regIE & pAhciPort->regIS)
1667 {
1668 Log(("%s: Interrupt status of port %u set -> Set interrupt again\n", __FUNCTION__, i));
1669 ASMAtomicOrU32(&pAhci->u32PortsInterrupted, 1 << i);
1670 fClear = false;
1671 break;
1672 }
1673 }
1674 u32Value >>= 1;
1675 i++;
1676 }
1677 }
1678 else
1679 fClear = false;
1680
1681 if (fClear)
1682 ahciHbaClearInterrupt(pAhci);
1683 else
1684 {
1685 Log(("%s: Not clearing interrupt: u32PortsInterrupted=%#010x\n", __FUNCTION__, pAhci->u32PortsInterrupted));
1686 /*
1687 * We need to set the interrupt again because the I/O APIC does not set it again even if the
1688 * line is still high.
1689 * We need to clear it first because the PCI bus only calls the interrupt controller if the state changes.
1690 */
1691 PDMDevHlpPCISetIrq(pAhci->CTX_SUFF(pDevIns), 0, 0);
1692 PDMDevHlpPCISetIrq(pAhci->CTX_SUFF(pDevIns), 0, 1);
1693 }
1694
1695 PDMCritSectLeave(&pAhci->lock);
1696 return VINF_SUCCESS;
1697}
1698
1699/**
1700 * Read from the global interrupt status register.
1701 */
1702static int HbaInterruptStatus_r(PAHCI pAhci, uint32_t iReg, uint32_t *pu32Value)
1703{
1704 RT_NOREF1(iReg);
1705
1706 int rc = PDMCritSectEnter(&pAhci->lock, VINF_IOM_R3_MMIO_READ);
1707 if (rc != VINF_SUCCESS)
1708 return rc;
1709
1710 uint32_t u32PortsInterrupted = ASMAtomicXchgU32(&pAhci->u32PortsInterrupted, 0);
1711
1712 PDMCritSectLeave(&pAhci->lock);
1713 Log(("%s: read regHbaIs=%#010x u32PortsInterrupted=%#010x\n", __FUNCTION__, pAhci->regHbaIs, u32PortsInterrupted));
1714
1715 pAhci->regHbaIs |= u32PortsInterrupted;
1716
1717#ifdef LOG_ENABLED
1718 Log(("%s:", __FUNCTION__));
1719 unsigned i;
1720 for (i = 0; i < pAhci->cPortsImpl; i++)
1721 {
1722 if ((pAhci->regHbaIs >> i) & 0x01)
1723 Log((" P%d", i));
1724 }
1725 Log(("\n"));
1726#endif
1727
1728 *pu32Value = pAhci->regHbaIs;
1729
1730 return VINF_SUCCESS;
1731}
1732
1733/**
1734 * Write to the global control register.
1735 */
1736static int HbaControl_w(PAHCI pAhci, uint32_t iReg, uint32_t u32Value)
1737{
1738 RT_NOREF1(iReg);
1739 Log(("%s: write u32Value=%#010x\n"
1740 "%s: AE=%d IE=%d HR=%d\n",
1741 __FUNCTION__, u32Value,
1742 __FUNCTION__, (u32Value & AHCI_HBA_CTRL_AE) >> 31, (u32Value & AHCI_HBA_CTRL_IE) >> 1,
1743 (u32Value & AHCI_HBA_CTRL_HR)));
1744
1745#ifndef IN_RING3
1746 RT_NOREF2(pAhci, u32Value);
1747 return VINF_IOM_R3_MMIO_WRITE;
1748#else
1749 /*
1750 * Increase the active thread counter because we might set the host controller
1751 * reset bit.
1752 */
1753 ASMAtomicIncU32(&pAhci->cThreadsActive);
1754 ASMAtomicWriteU32(&pAhci->regHbaCtrl, (u32Value & AHCI_HBA_CTRL_RW_MASK) | AHCI_HBA_CTRL_AE);
1755
1756 /*
1757 * Do the HBA reset if requested and there is no other active thread at the moment,
1758 * the work is deferred to the last active thread otherwise.
1759 */
1760 uint32_t cThreadsActive = ASMAtomicDecU32(&pAhci->cThreadsActive);
1761 if ( (u32Value & AHCI_HBA_CTRL_HR)
1762 && !cThreadsActive)
1763 ahciHBAReset(pAhci);
1764
1765 return VINF_SUCCESS;
1766#endif
1767}
1768
1769/**
1770 * Read the global control register.
1771 */
1772static int HbaControl_r(PAHCI pAhci, uint32_t iReg, uint32_t *pu32Value)
1773{
1774 RT_NOREF1(iReg);
1775 Log(("%s: read regHbaCtrl=%#010x\n"
1776 "%s: AE=%d IE=%d HR=%d\n",
1777 __FUNCTION__, pAhci->regHbaCtrl,
1778 __FUNCTION__, (pAhci->regHbaCtrl & AHCI_HBA_CTRL_AE) >> 31, (pAhci->regHbaCtrl & AHCI_HBA_CTRL_IE) >> 1,
1779 (pAhci->regHbaCtrl & AHCI_HBA_CTRL_HR)));
1780 *pu32Value = pAhci->regHbaCtrl;
1781 return VINF_SUCCESS;
1782}
1783
1784/**
1785 * Read the global capabilities register.
1786 */
1787static int HbaCapabilities_r(PAHCI pAhci, uint32_t iReg, uint32_t *pu32Value)
1788{
1789 RT_NOREF1(iReg);
1790 Log(("%s: read regHbaCap=%#010x\n"
1791 "%s: S64A=%d SNCQ=%d SIS=%d SSS=%d SALP=%d SAL=%d SCLO=%d ISS=%d SNZO=%d SAM=%d SPM=%d PMD=%d SSC=%d PSC=%d NCS=%d NP=%d\n",
1792 __FUNCTION__, pAhci->regHbaCap,
1793 __FUNCTION__, (pAhci->regHbaCap & AHCI_HBA_CAP_S64A) >> 31, (pAhci->regHbaCap & AHCI_HBA_CAP_SNCQ) >> 30,
1794 (pAhci->regHbaCap & AHCI_HBA_CAP_SIS) >> 28, (pAhci->regHbaCap & AHCI_HBA_CAP_SSS) >> 27,
1795 (pAhci->regHbaCap & AHCI_HBA_CAP_SALP) >> 26, (pAhci->regHbaCap & AHCI_HBA_CAP_SAL) >> 25,
1796 (pAhci->regHbaCap & AHCI_HBA_CAP_SCLO) >> 24, (pAhci->regHbaCap & AHCI_HBA_CAP_ISS) >> 20,
1797 (pAhci->regHbaCap & AHCI_HBA_CAP_SNZO) >> 19, (pAhci->regHbaCap & AHCI_HBA_CAP_SAM) >> 18,
1798 (pAhci->regHbaCap & AHCI_HBA_CAP_SPM) >> 17, (pAhci->regHbaCap & AHCI_HBA_CAP_PMD) >> 15,
1799 (pAhci->regHbaCap & AHCI_HBA_CAP_SSC) >> 14, (pAhci->regHbaCap & AHCI_HBA_CAP_PSC) >> 13,
1800 (pAhci->regHbaCap & AHCI_HBA_CAP_NCS) >> 8, (pAhci->regHbaCap & AHCI_HBA_CAP_NP)));
1801 *pu32Value = pAhci->regHbaCap;
1802 return VINF_SUCCESS;
1803}
1804
1805/**
1806 * Write to the global command completion coalescing control register.
1807 */
1808static int HbaCccCtl_w(PAHCI pAhci, uint32_t iReg, uint32_t u32Value)
1809{
1810 RT_NOREF1(iReg);
1811 Log(("%s: write u32Value=%#010x\n"
1812 "%s: TV=%d CC=%d INT=%d EN=%d\n",
1813 __FUNCTION__, u32Value,
1814 __FUNCTION__, AHCI_HBA_CCC_CTL_TV_GET(u32Value), AHCI_HBA_CCC_CTL_CC_GET(u32Value),
1815 AHCI_HBA_CCC_CTL_INT_GET(u32Value), (u32Value & AHCI_HBA_CCC_CTL_EN)));
1816
1817 pAhci->regHbaCccCtl = u32Value;
1818 pAhci->uCccTimeout = AHCI_HBA_CCC_CTL_TV_GET(u32Value);
1819 pAhci->uCccPortNr = AHCI_HBA_CCC_CTL_INT_GET(u32Value);
1820 pAhci->uCccNr = AHCI_HBA_CCC_CTL_CC_GET(u32Value);
1821
1822 if (u32Value & AHCI_HBA_CCC_CTL_EN)
1823 TMTimerSetMillies(pAhci->CTX_SUFF(pHbaCccTimer), pAhci->uCccTimeout); /* Arm the timer */
1824 else
1825 TMTimerStop(pAhci->CTX_SUFF(pHbaCccTimer));
1826
1827 return VINF_SUCCESS;
1828}
1829
1830/**
1831 * Read the global command completion coalescing control register.
1832 */
1833static int HbaCccCtl_r(PAHCI pAhci, uint32_t iReg, uint32_t *pu32Value)
1834{
1835 RT_NOREF1(iReg);
1836 Log(("%s: read regHbaCccCtl=%#010x\n"
1837 "%s: TV=%d CC=%d INT=%d EN=%d\n",
1838 __FUNCTION__, pAhci->regHbaCccCtl,
1839 __FUNCTION__, AHCI_HBA_CCC_CTL_TV_GET(pAhci->regHbaCccCtl), AHCI_HBA_CCC_CTL_CC_GET(pAhci->regHbaCccCtl),
1840 AHCI_HBA_CCC_CTL_INT_GET(pAhci->regHbaCccCtl), (pAhci->regHbaCccCtl & AHCI_HBA_CCC_CTL_EN)));
1841 *pu32Value = pAhci->regHbaCccCtl;
1842 return VINF_SUCCESS;
1843}
1844
1845/**
1846 * Write to the global command completion coalescing ports register.
1847 */
1848static int HbaCccPorts_w(PAHCI pAhci, uint32_t iReg, uint32_t u32Value)
1849{
1850 RT_NOREF1(iReg);
1851 Log(("%s: write u32Value=%#010x\n", __FUNCTION__, u32Value));
1852
1853 pAhci->regHbaCccPorts = u32Value;
1854
1855 return VINF_SUCCESS;
1856}
1857
1858/**
1859 * Read the global command completion coalescing ports register.
1860 */
1861static int HbaCccPorts_r(PAHCI pAhci, uint32_t iReg, uint32_t *pu32Value)
1862{
1863 RT_NOREF1(iReg);
1864 Log(("%s: read regHbaCccPorts=%#010x\n", __FUNCTION__, pAhci->regHbaCccPorts));
1865
1866#ifdef LOG_ENABLED
1867 Log(("%s:", __FUNCTION__));
1868 unsigned i;
1869 for (i = 0; i < pAhci->cPortsImpl; i++)
1870 {
1871 if ((pAhci->regHbaCccPorts >> i) & 0x01)
1872 Log((" P%d", i));
1873 }
1874 Log(("\n"));
1875#endif
1876
1877 *pu32Value = pAhci->regHbaCccPorts;
1878 return VINF_SUCCESS;
1879}
1880
1881/**
1882 * Invalid write to global register
1883 */
1884static int HbaInvalid_w(PAHCI pAhci, uint32_t iReg, uint32_t u32Value)
1885{
1886 RT_NOREF3(pAhci, iReg, u32Value);
1887 Log(("%s: Write denied!!! iReg=%u u32Value=%#010x\n", __FUNCTION__, iReg, u32Value));
1888 return VINF_SUCCESS;
1889}
1890
1891/**
1892 * Invalid Port write.
1893 */
1894static int PortInvalid_w(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t u32Value)
1895{
1896 RT_NOREF4(pAhci, pAhciPort, iReg, u32Value);
1897 ahciLog(("%s: Write denied!!! iReg=%u u32Value=%#010x\n", __FUNCTION__, iReg, u32Value));
1898 return VINF_SUCCESS;
1899}
1900
1901/**
1902 * Invalid Port read.
1903 */
1904static int PortInvalid_r(PAHCI pAhci, PAHCIPort pAhciPort, uint32_t iReg, uint32_t *pu32Value)
1905{
1906 RT_NOREF4(pAhci, pAhciPort, iReg, pu32Value);
1907 ahciLog(("%s: Read denied!!! iReg=%u\n", __FUNCTION__, iReg));
1908 return VINF_SUCCESS;
1909}
1910
1911/**
1912 * Register descriptor table for global HBA registers
1913 */
1914static const AHCIOPREG g_aOpRegs[] =
1915{
1916 {"HbaCapabilites", HbaCapabilities_r, HbaInvalid_w}, /* Readonly */
1917 {"HbaControl" , HbaControl_r, HbaControl_w},
1918 {"HbaInterruptStatus", HbaInterruptStatus_r, HbaInterruptStatus_w},
1919 {"HbaPortsImplemented", HbaPortsImplemented_r, HbaInvalid_w}, /* Readonly */
1920 {"HbaVersion", HbaVersion_r, HbaInvalid_w}, /* ReadOnly */
1921 {"HbaCccCtl", HbaCccCtl_r, HbaCccCtl_w},
1922 {"HbaCccPorts", HbaCccPorts_r, HbaCccPorts_w},
1923};
1924
1925/**
1926 * Register descriptor table for port registers
1927 */
1928static const AHCIPORTOPREG g_aPortOpRegs[] =
1929{
1930 {"PortCmdLstAddr", PortCmdLstAddr_r, PortCmdLstAddr_w},
1931 {"PortCmdLstAddrUp", PortCmdLstAddrUp_r, PortCmdLstAddrUp_w},
1932 {"PortFisAddr", PortFisAddr_r, PortFisAddr_w},
1933 {"PortFisAddrUp", PortFisAddrUp_r, PortFisAddrUp_w},
1934 {"PortIntrSts", PortIntrSts_r, PortIntrSts_w},
1935 {"PortIntrEnable", PortIntrEnable_r, PortIntrEnable_w},
1936 {"PortCmd", PortCmd_r, PortCmd_w},
1937 {"PortReserved1", PortInvalid_r, PortInvalid_w}, /* Not used. */
1938 {"PortTaskFileData", PortTaskFileData_r, PortInvalid_w}, /* Readonly */
1939 {"PortSignature", PortSignature_r, PortInvalid_w}, /* Readonly */
1940 {"PortSStatus", PortSStatus_r, PortInvalid_w}, /* Readonly */
1941 {"PortSControl", PortSControl_r, PortSControl_w},
1942 {"PortSError", PortSError_r, PortSError_w},
1943 {"PortSActive", PortSActive_r, PortSActive_w},
1944 {"PortCmdIssue", PortCmdIssue_r, PortCmdIssue_w},
1945 {"PortReserved2", PortInvalid_r, PortInvalid_w}, /* Not used. */
1946};
1947
1948#ifdef IN_RING3
1949/**
1950 * Reset initiated by system software for one port.
1951 *
1952 * @param pAhciPort The port to reset.
1953 */
1954static void ahciPortSwReset(PAHCIPort pAhciPort)
1955{
1956 bool fAllTasksCanceled;
1957
1958 /* Cancel all tasks first. */
1959 fAllTasksCanceled = ahciCancelActiveTasks(pAhciPort);
1960 Assert(fAllTasksCanceled);
1961
1962 Assert(pAhciPort->cTasksActive == 0);
1963
1964 pAhciPort->regIS = 0;
1965 pAhciPort->regIE = 0;
1966 pAhciPort->regCMD = AHCI_PORT_CMD_CPD | /* Cold presence detection */
1967 AHCI_PORT_CMD_SUD | /* Device has spun up. */
1968 AHCI_PORT_CMD_POD; /* Port is powered on. */
1969
1970 /* Hotplugging supported?. */
1971 if (pAhciPort->fHotpluggable)
1972 pAhciPort->regCMD |= AHCI_PORT_CMD_HPCP;
1973
1974 pAhciPort->regTFD = (1 << 8) | ATA_STAT_SEEK | ATA_STAT_WRERR;
1975 pAhciPort->regSIG = UINT32_MAX;
1976 pAhciPort->regSSTS = 0;
1977 pAhciPort->regSCTL = 0;
1978 pAhciPort->regSERR = 0;
1979 pAhciPort->regSACT = 0;
1980 pAhciPort->regCI = 0;
1981
1982 pAhciPort->fResetDevice = false;
1983 pAhciPort->fPoweredOn = true;
1984 pAhciPort->fSpunUp = true;
1985 pAhciPort->cMultSectors = ATA_MAX_MULT_SECTORS;
1986 pAhciPort->uATATransferMode = ATA_MODE_UDMA | 6;
1987
1988 pAhciPort->u32TasksNew = 0;
1989 pAhciPort->u32TasksRedo = 0;
1990 pAhciPort->u32TasksFinished = 0;
1991 pAhciPort->u32QueuedTasksFinished = 0;
1992 pAhciPort->u32CurrentCommandSlot = 0;
1993
1994 if (pAhciPort->pDrvBase)
1995 {
1996 pAhciPort->regCMD |= AHCI_PORT_CMD_CPS; /* Indicate that there is a device on that port */
1997
1998 if (pAhciPort->fPoweredOn)
1999 {
2000 /*
2001 * Set states in the Port Signature and SStatus registers.
2002 */
2003 if (pAhciPort->fATAPI)
2004 pAhciPort->regSIG = AHCI_PORT_SIG_ATAPI;
2005 else
2006 pAhciPort->regSIG = AHCI_PORT_SIG_DISK;
2007 pAhciPort->regSSTS = (0x01 << 8) | /* Interface is active. */
2008 (0x02 << 4) | /* Generation 2 (3.0GBps) speed. */
2009 (0x03 << 0); /* Device detected and communication established. */
2010 }
2011 }
2012}
2013
2014/**
2015 * Hardware reset used for machine power on and reset.
2016 *
2017 * @param pAhciPort The port to reset.
2018 */
2019static void ahciPortHwReset(PAHCIPort pAhciPort)
2020{
2021 /* Reset the address registers. */
2022 pAhciPort->regCLB = 0;
2023 pAhciPort->regCLBU = 0;
2024 pAhciPort->regFB = 0;
2025 pAhciPort->regFBU = 0;
2026
2027 /* Reset calculated addresses. */
2028 pAhciPort->GCPhysAddrClb = 0;
2029 pAhciPort->GCPhysAddrFb = 0;
2030}
2031
2032/**
2033 * Create implemented ports bitmap.
2034 *
2035 * @returns 32bit bitmask with a bit set for every implemented port.
2036 * @param cPorts Number of ports.
2037 */
2038static uint32_t ahciGetPortsImplemented(unsigned cPorts)
2039{
2040 uint32_t uPortsImplemented = 0;
2041
2042 for (unsigned i = 0; i < cPorts; i++)
2043 uPortsImplemented |= (1 << i);
2044
2045 return uPortsImplemented;
2046}
2047
2048/**
2049 * Reset the entire HBA.
2050 *
2051 * @param pThis The HBA state.
2052 */
2053static void ahciHBAReset(PAHCI pThis)
2054{
2055 unsigned i;
2056 int rc = VINF_SUCCESS;
2057
2058 LogRel(("AHCI#%u: Reset the HBA\n", pThis->CTX_SUFF(pDevIns)->iInstance));
2059
2060 /* Stop the CCC timer. */
2061 if (pThis->regHbaCccCtl & AHCI_HBA_CCC_CTL_EN)
2062 {
2063 rc = TMTimerStop(pThis->CTX_SUFF(pHbaCccTimer));
2064 if (RT_FAILURE(rc))
2065 AssertMsgFailed(("%s: Failed to stop timer!\n", __FUNCTION__));
2066 }
2067
2068 /* Reset every port */
2069 for (i = 0; i < pThis->cPortsImpl; i++)
2070 {
2071 PAHCIPort pAhciPort = &pThis->ahciPort[i];
2072
2073 pAhciPort->iLUN = i;
2074 ahciPortSwReset(pAhciPort);
2075 }
2076
2077 /* Init Global registers */
2078 pThis->regHbaCap = AHCI_HBA_CAP_ISS_SHIFT(AHCI_HBA_CAP_ISS_GEN2) |
2079 AHCI_HBA_CAP_S64A | /* 64bit addressing supported */
2080 AHCI_HBA_CAP_SAM | /* AHCI mode only */
2081 AHCI_HBA_CAP_SNCQ | /* Support native command queuing */
2082 AHCI_HBA_CAP_SSS | /* Staggered spin up */
2083 AHCI_HBA_CAP_CCCS | /* Support command completion coalescing */
2084 AHCI_HBA_CAP_NCS_SET(pThis->cCmdSlotsAvail) | /* Number of command slots we support */
2085 AHCI_HBA_CAP_NP_SET(pThis->cPortsImpl); /* Number of supported ports */
2086 pThis->regHbaCtrl = AHCI_HBA_CTRL_AE;
2087 pThis->regHbaPi = ahciGetPortsImplemented(pThis->cPortsImpl);
2088 pThis->regHbaVs = AHCI_HBA_VS_MJR | AHCI_HBA_VS_MNR;
2089 pThis->regHbaCccCtl = 0;
2090 pThis->regHbaCccPorts = 0;
2091 pThis->uCccTimeout = 0;
2092 pThis->uCccPortNr = 0;
2093 pThis->uCccNr = 0;
2094
2095 /* Clear pending interrupts. */
2096 pThis->regHbaIs = 0;
2097 pThis->u32PortsInterrupted = 0;
2098 ahciHbaClearInterrupt(pThis);
2099
2100 pThis->f64BitAddr = false;
2101 pThis->u32PortsInterrupted = 0;
2102 pThis->f8ByteMMIO4BytesWrittenSuccessfully = false;
2103 /* Clear the HBA Reset bit */
2104 pThis->regHbaCtrl &= ~AHCI_HBA_CTRL_HR;
2105}
2106#endif
2107
2108/**
2109 * Reads from a AHCI controller register.
2110 *
2111 * @returns VBox status code.
2112 *
2113 * @param pAhci The AHCI instance.
2114 * @param uReg The register to write.
2115 * @param pv Where to store the result.
2116 * @param cb Number of bytes read.
2117 */
2118static int ahciRegisterRead(PAHCI pAhci, uint32_t uReg, void *pv, unsigned cb)
2119{
2120 int rc = VINF_SUCCESS;
2121 uint32_t iReg;
2122
2123 /*
2124 * If the access offset is smaller than AHCI_HBA_GLOBAL_SIZE the guest accesses the global registers.
2125 * Otherwise it accesses the registers of a port.
2126 */
2127 if (uReg < AHCI_HBA_GLOBAL_SIZE)
2128 {
2129 iReg = uReg >> 2;
2130 Log3(("%s: Trying to read from global register %u\n", __FUNCTION__, iReg));
2131 if (iReg < RT_ELEMENTS(g_aOpRegs))
2132 {
2133 const AHCIOPREG *pReg = &g_aOpRegs[iReg];
2134 rc = pReg->pfnRead(pAhci, iReg, (uint32_t *)pv);
2135 }
2136 else
2137 {
2138 Log3(("%s: Trying to read global register %u/%u!!!\n", __FUNCTION__, iReg, RT_ELEMENTS(g_aOpRegs)));
2139 *(uint32_t *)pv = 0;
2140 }
2141 }
2142 else
2143 {
2144 uint32_t iRegOffset;
2145 uint32_t iPort;
2146
2147 /* Calculate accessed port. */
2148 uReg -= AHCI_HBA_GLOBAL_SIZE;
2149 iPort = uReg / AHCI_PORT_REGISTER_SIZE;
2150 iRegOffset = (uReg % AHCI_PORT_REGISTER_SIZE);
2151 iReg = iRegOffset >> 2;
2152
2153 Log3(("%s: Trying to read from port %u and register %u\n", __FUNCTION__, iPort, iReg));
2154
2155 if (RT_LIKELY( iPort < pAhci->cPortsImpl
2156 && iReg < RT_ELEMENTS(g_aPortOpRegs)))
2157 {
2158 const AHCIPORTOPREG *pPortReg = &g_aPortOpRegs[iReg];
2159 rc = pPortReg->pfnRead(pAhci, &pAhci->ahciPort[iPort], iReg, (uint32_t *)pv);
2160 }
2161 else
2162 {
2163 Log3(("%s: Trying to read port %u register %u/%u!!!\n", __FUNCTION__, iPort, iReg, RT_ELEMENTS(g_aPortOpRegs)));
2164 rc = VINF_IOM_MMIO_UNUSED_00;
2165 }
2166
2167 /*
2168 * Windows Vista tries to read one byte from some registers instead of four.
2169 * Correct the value according to the read size.
2170 */
2171 if (RT_SUCCESS(rc) && cb != sizeof(uint32_t))
2172 {
2173 switch (cb)
2174 {
2175 case 1:
2176 {
2177 uint8_t uNewValue;
2178 uint8_t *p = (uint8_t *)pv;
2179
2180 iRegOffset &= 3;
2181 Log3(("%s: iRegOffset=%u\n", __FUNCTION__, iRegOffset));
2182 uNewValue = p[iRegOffset];
2183 /* Clear old value */
2184 *(uint32_t *)pv = 0;
2185 *(uint8_t *)pv = uNewValue;
2186 break;
2187 }
2188 default:
2189 AssertMsgFailed(("%s: unsupported access width cb=%d iPort=%x iRegOffset=%x iReg=%x!!!\n",
2190 __FUNCTION__, cb, iPort, iRegOffset, iReg));
2191 }
2192 }
2193 }
2194
2195 return rc;
2196}
2197
2198/**
2199 * Writes a value to one of the AHCI controller registers.
2200 *
2201 * @returns VBox status code.
2202 *
2203 * @param pAhci The AHCI instance.
2204 * @param offReg The offset of the register to write to.
2205 * @param u32Value The value to write.
2206 */
2207static int ahciRegisterWrite(PAHCI pAhci, uint32_t offReg, uint32_t u32Value)
2208{
2209 int rc;
2210 uint32_t iReg;
2211
2212 /*
2213 * If the access offset is smaller than 100h the guest accesses the global registers.
2214 * Otherwise it accesses the registers of a port.
2215 */
2216 if (offReg < AHCI_HBA_GLOBAL_SIZE)
2217 {
2218 Log3(("Write global HBA register\n"));
2219 iReg = offReg >> 2;
2220 if (iReg < RT_ELEMENTS(g_aOpRegs))
2221 {
2222 const AHCIOPREG *pReg = &g_aOpRegs[iReg];
2223 rc = pReg->pfnWrite(pAhci, iReg, u32Value);
2224 }
2225 else
2226 {
2227 Log3(("%s: Trying to write global register %u/%u!!!\n", __FUNCTION__, iReg, RT_ELEMENTS(g_aOpRegs)));
2228 rc = VINF_SUCCESS;
2229 }
2230 }
2231 else
2232 {
2233 uint32_t iPort;
2234 Log3(("Write Port register\n"));
2235 /* Calculate accessed port. */
2236 offReg -= AHCI_HBA_GLOBAL_SIZE;
2237 iPort = offReg / AHCI_PORT_REGISTER_SIZE;
2238 iReg = (offReg % AHCI_PORT_REGISTER_SIZE) >> 2;
2239 Log3(("%s: Trying to write to port %u and register %u\n", __FUNCTION__, iPort, iReg));
2240 if (RT_LIKELY( iPort < pAhci->cPortsImpl
2241 && iReg < RT_ELEMENTS(g_aPortOpRegs)))
2242 {
2243 const AHCIPORTOPREG *pPortReg = &g_aPortOpRegs[iReg];
2244 rc = pPortReg->pfnWrite(pAhci, &pAhci->ahciPort[iPort], iReg, u32Value);
2245 }
2246 else
2247 {
2248 Log3(("%s: Trying to write port %u register %u/%u!!!\n", __FUNCTION__, iPort, iReg, RT_ELEMENTS(g_aPortOpRegs)));
2249 rc = VINF_SUCCESS;
2250 }
2251 }
2252
2253 return rc;
2254}
2255
2256/**
2257 * Memory mapped I/O Handler for read operations.
2258 *
2259 * @returns VBox status code.
2260 *
2261 * @param pDevIns The device instance.
2262 * @param pvUser User argument.
2263 * @param GCPhysAddr Physical address (in GC) where the read starts.
2264 * @param pv Where to store the result.
2265 * @param cb Number of bytes read.
2266 */
2267PDMBOTHCBDECL(int) ahciMMIORead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr, void *pv, unsigned cb)
2268{
2269 PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
2270 Log2(("#%d ahciMMIORead: pvUser=%p:{%.*Rhxs} cb=%d GCPhysAddr=%RGp\n", pDevIns->iInstance, pv, cb, pv, cb, GCPhysAddr));
2271 RT_NOREF1(pvUser);
2272
2273 int rc = ahciRegisterRead(pAhci, GCPhysAddr - pAhci->MMIOBase, pv, cb);
2274
2275 Log2(("#%d ahciMMIORead: return pvUser=%p:{%.*Rhxs} cb=%d GCPhysAddr=%RGp rc=%Rrc\n",
2276 pDevIns->iInstance, pv, cb, pv, cb, GCPhysAddr, rc));
2277 return rc;
2278}
2279
2280
2281/**
2282 * Memory mapped I/O Handler for write operations.
2283 *
2284 * @returns VBox status code.
2285 *
2286 * @param pDevIns The device instance.
2287 * @param pvUser User argument.
2288 * @param GCPhysAddr Physical address (in GC) where the read starts.
2289 * @param pv Where to fetch the result.
2290 * @param cb Number of bytes to write.
2291 */
2292PDMBOTHCBDECL(int) ahciMMIOWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr, void const *pv, unsigned cb)
2293{
2294 PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
2295 Assert(cb == 4 || cb == 8);
2296 Assert(!(GCPhysAddr & (cb - 1)));
2297
2298 /* Break up 64 bits writes into two dword writes. */
2299 /** @todo Eliminate this code once the IOM/EM starts taking care of these
2300 * situations. */
2301 if (cb == 8)
2302 {
2303 /*
2304 * Only write the first 4 bytes if they weren't already.
2305 * It is possible that the last write to the register caused a world
2306 * switch and we entered this function again.
2307 * Writing the first 4 bytes again could cause indeterminate behavior
2308 * which can cause errors in the guest.
2309 */
2310 int rc = VINF_SUCCESS;
2311 if (!pAhci->f8ByteMMIO4BytesWrittenSuccessfully)
2312 {
2313 rc = ahciMMIOWrite(pDevIns, pvUser, GCPhysAddr, pv, 4);
2314 if (rc != VINF_SUCCESS)
2315 return rc;
2316
2317 pAhci->f8ByteMMIO4BytesWrittenSuccessfully = true;
2318 }
2319
2320 rc = ahciMMIOWrite(pDevIns, pvUser, GCPhysAddr + 4, (uint8_t *)pv + 4, 4);
2321 /*
2322 * Reset flag again so that the first 4 bytes are written again on the next
2323 * 8byte MMIO access.
2324 */
2325 if (rc == VINF_SUCCESS)
2326 pAhci->f8ByteMMIO4BytesWrittenSuccessfully = false;
2327
2328 return rc;
2329 }
2330
2331 /* Do the access. */
2332 Log2(("#%d ahciMMIOWrite: pvUser=%p:{%.*Rhxs} cb=%d GCPhysAddr=%RGp\n", pDevIns->iInstance, pv, cb, pv, cb, GCPhysAddr));
2333 return ahciRegisterWrite(pAhci, GCPhysAddr - pAhci->MMIOBase, *(uint32_t const *)pv);
2334}
2335
2336PDMBOTHCBDECL(int) ahciLegacyFakeWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
2337{
2338 RT_NOREF5(pDevIns, pvUser, Port, u32, cb);
2339 AssertMsgFailed(("Should not happen\n"));
2340 return VINF_SUCCESS;
2341}
2342
2343PDMBOTHCBDECL(int) ahciLegacyFakeRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
2344{
2345 RT_NOREF5(pDevIns, pvUser, Port, pu32, cb);
2346 AssertMsgFailed(("Should not happen\n"));
2347 return VINF_SUCCESS;
2348}
2349
2350/**
2351 * I/O port handler for writes to the index/data register pair.
2352 *
2353 * @returns VBox status code.
2354 *
2355 * @param pDevIns The device instance.
2356 * @param pvUser User argument.
2357 * @param Port Port address where the write starts.
2358 * @param u32 Where to fetch the result.
2359 * @param cb Number of bytes to write.
2360 */
2361PDMBOTHCBDECL(int) ahciIdxDataWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
2362{
2363 PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
2364 int rc = VINF_SUCCESS;
2365 RT_NOREF2(pvUser, cb);
2366
2367 if (Port - pAhci->IOPortBase >= 8)
2368 {
2369 unsigned iReg = (Port - pAhci->IOPortBase - 8) / 4;
2370
2371 Assert(cb == 4);
2372
2373 if (iReg == 0)
2374 {
2375 /* Write the index register. */
2376 pAhci->regIdx = u32;
2377 }
2378 else
2379 {
2380 /** @todo range check? */
2381 Assert(iReg == 1);
2382 rc = ahciRegisterWrite(pAhci, pAhci->regIdx, u32);
2383 if (rc == VINF_IOM_R3_MMIO_WRITE)
2384 rc = VINF_IOM_R3_IOPORT_WRITE;
2385 }
2386 }
2387 /* else: ignore */
2388
2389 Log2(("#%d ahciIdxDataWrite: pu32=%p:{%.*Rhxs} cb=%d Port=%#x rc=%Rrc\n",
2390 pDevIns->iInstance, &u32, cb, &u32, cb, Port, rc));
2391 return rc;
2392}
2393
2394/**
2395 * I/O port handler for reads from the index/data register pair.
2396 *
2397 * @returns VBox status code.
2398 *
2399 * @param pDevIns The device instance.
2400 * @param pvUser User argument.
2401 * @param Port Port address where the read starts.
2402 * @param pu32 Where to fetch the result.
2403 * @param cb Number of bytes to write.
2404 */
2405PDMBOTHCBDECL(int) ahciIdxDataRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
2406{
2407 PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
2408 int rc = VINF_SUCCESS;
2409 RT_NOREF1(pvUser);
2410
2411 if (Port - pAhci->IOPortBase >= 8)
2412 {
2413 unsigned iReg = (Port - pAhci->IOPortBase - 8) / 4;
2414
2415 Assert(cb == 4);
2416
2417 if (iReg == 0)
2418 {
2419 /* Read the index register. */
2420 *pu32 = pAhci->regIdx;
2421 }
2422 else
2423 {
2424 Assert(iReg == 1);
2425 /** @todo range check? */
2426 rc = ahciRegisterRead(pAhci, pAhci->regIdx, pu32, cb);
2427 if (rc == VINF_IOM_R3_MMIO_READ)
2428 rc = VINF_IOM_R3_IOPORT_READ;
2429 else if (rc == VINF_IOM_MMIO_UNUSED_00)
2430 rc = VERR_IOM_IOPORT_UNUSED;
2431 }
2432 }
2433 else
2434 *pu32 = UINT32_C(0xffffffff);
2435
2436 Log2(("#%d ahciIdxDataRead: pu32=%p:{%.*Rhxs} cb=%d Port=%#x rc=%Rrc\n",
2437 pDevIns->iInstance, pu32, cb, pu32, cb, Port, rc));
2438 return rc;
2439}
2440
2441#ifdef IN_RING3
2442
2443/**
2444 * @callback_method_impl{FNPCIIOREGIONMAP}
2445 */
2446static DECLCALLBACK(int) ahciR3MMIOMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
2447 RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
2448{
2449 RT_NOREF(iRegion, enmType);
2450 PAHCI pThis = PCIDEV_2_PAHCI(pPciDev);
2451
2452 Log2(("%s: registering MMIO area at GCPhysAddr=%RGp cb=%RGp\n", __FUNCTION__, GCPhysAddress, cb));
2453
2454 Assert(enmType == PCI_ADDRESS_SPACE_MEM);
2455 Assert(cb >= 4352);
2456
2457 /* We use the assigned size here, because we currently only support page aligned MMIO ranges. */
2458 /** @todo change this to IOMMMIO_FLAGS_WRITE_ONLY_DWORD once EM/IOM starts
2459 * handling 2nd DWORD failures on split accesses correctly. */
2460 int rc = PDMDevHlpMMIORegister(pDevIns, GCPhysAddress, cb, NULL /*pvUser*/,
2461 IOMMMIO_FLAGS_READ_DWORD | IOMMMIO_FLAGS_WRITE_ONLY_DWORD_QWORD,
2462 ahciMMIOWrite, ahciMMIORead, "AHCI");
2463 if (RT_FAILURE(rc))
2464 return rc;
2465
2466 if (pThis->fR0Enabled)
2467 {
2468 rc = PDMDevHlpMMIORegisterR0(pDevIns, GCPhysAddress, cb, NIL_RTR0PTR /*pvUser*/, "ahciMMIOWrite", "ahciMMIORead");
2469 if (RT_FAILURE(rc))
2470 return rc;
2471 }
2472
2473 if (pThis->fGCEnabled)
2474 {
2475 rc = PDMDevHlpMMIORegisterRC(pDevIns, GCPhysAddress, cb, NIL_RTRCPTR /*pvUser*/, "ahciMMIOWrite", "ahciMMIORead");
2476 if (RT_FAILURE(rc))
2477 return rc;
2478 }
2479
2480 pThis->MMIOBase = GCPhysAddress;
2481 return rc;
2482}
2483
2484
2485/**
2486 * @callback_method_impl{FNPCIIOREGIONMAP,
2487 * Map the legacy I/O port ranges to make Solaris work with the
2488 * controller.}
2489 */
2490static DECLCALLBACK(int) ahciR3LegacyFakeIORangeMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
2491 RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
2492{
2493 RT_NOREF(iRegion, enmType);
2494 PAHCI pThis = PCIDEV_2_PAHCI(pPciDev);
2495 int rc = VINF_SUCCESS;
2496
2497 Log2(("%s: registering fake I/O area at GCPhysAddr=%RGp cb=%RGp\n", __FUNCTION__, GCPhysAddress, cb));
2498
2499 Assert(enmType == PCI_ADDRESS_SPACE_IO);
2500
2501 /* We use the assigned size here, because we currently only support page aligned MMIO ranges. */
2502 rc = PDMDevHlpIOPortRegister(pDevIns, (RTIOPORT)GCPhysAddress, cb, NULL,
2503 ahciLegacyFakeWrite, ahciLegacyFakeRead, NULL, NULL, "AHCI Fake");
2504 if (RT_FAILURE(rc))
2505 return rc;
2506
2507 if (pThis->fR0Enabled)
2508 {
2509 rc = PDMDevHlpIOPortRegisterR0(pDevIns, (RTIOPORT)GCPhysAddress, cb, 0,
2510 "ahciLegacyFakeWrite", "ahciLegacyFakeRead", NULL, NULL, "AHCI Fake");
2511 if (RT_FAILURE(rc))
2512 return rc;
2513 }
2514
2515 if (pThis->fGCEnabled)
2516 {
2517 rc = PDMDevHlpIOPortRegisterRC(pDevIns, (RTIOPORT)GCPhysAddress, cb, 0,
2518 "ahciLegacyFakeWrite", "ahciLegacyFakeRead", NULL, NULL, "AHCI Fake");
2519 if (RT_FAILURE(rc))
2520 return rc;
2521 }
2522
2523 return rc;
2524}
2525
2526/**
2527 * @callback_method_impl{FNPCIIOREGIONMAP,
2528 * Map the BMDMA I/O port range (used for the Index/Data pair register access)}
2529 */
2530static DECLCALLBACK(int) ahciR3IdxDataIORangeMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
2531 RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
2532{
2533 RT_NOREF(iRegion, enmType);
2534 PAHCI pThis = PCIDEV_2_PAHCI(pPciDev);
2535 int rc = VINF_SUCCESS;
2536
2537 Log2(("%s: registering fake I/O area at GCPhysAddr=%RGp cb=%RGp\n", __FUNCTION__, GCPhysAddress, cb));
2538
2539 Assert(enmType == PCI_ADDRESS_SPACE_IO);
2540
2541 /* We use the assigned size here, because we currently only support page aligned MMIO ranges. */
2542 rc = PDMDevHlpIOPortRegister(pDevIns, (RTIOPORT)GCPhysAddress, cb, NULL,
2543 ahciIdxDataWrite, ahciIdxDataRead, NULL, NULL, "AHCI IDX/DATA");
2544 if (RT_FAILURE(rc))
2545 return rc;
2546
2547 if (pThis->fR0Enabled)
2548 {
2549 rc = PDMDevHlpIOPortRegisterR0(pDevIns, (RTIOPORT)GCPhysAddress, cb, 0,
2550 "ahciIdxDataWrite", "ahciIdxDataRead", NULL, NULL, "AHCI IDX/DATA");
2551 if (RT_FAILURE(rc))
2552 return rc;
2553 }
2554
2555 if (pThis->fGCEnabled)
2556 {
2557 rc = PDMDevHlpIOPortRegisterRC(pDevIns, (RTIOPORT)GCPhysAddress, cb, 0,
2558 "ahciIdxDataWrite", "ahciIdxDataRead", NULL, NULL, "AHCI IDX/DATA");
2559 if (RT_FAILURE(rc))
2560 return rc;
2561 }
2562
2563 pThis->IOPortBase = (RTIOPORT)GCPhysAddress;
2564 return rc;
2565}
2566
2567/* -=-=-=-=-=- PAHCI::ILeds -=-=-=-=-=- */
2568
2569/**
2570 * Gets the pointer to the status LED of a unit.
2571 *
2572 * @returns VBox status code.
2573 * @param pInterface Pointer to the interface structure containing the called function pointer.
2574 * @param iLUN The unit which status LED we desire.
2575 * @param ppLed Where to store the LED pointer.
2576 */
2577static DECLCALLBACK(int) ahciR3Status_QueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
2578{
2579 PAHCI pAhci = PDMILEDPORTS_2_PAHCI(pInterface);
2580 if (iLUN < AHCI_MAX_NR_PORTS_IMPL)
2581 {
2582 *ppLed = &pAhci->ahciPort[iLUN].Led;
2583 Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
2584 return VINF_SUCCESS;
2585 }
2586 return VERR_PDM_LUN_NOT_FOUND;
2587}
2588
2589/**
2590 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
2591 */
2592static DECLCALLBACK(void *) ahciR3Status_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
2593{
2594 PAHCI pThis = PDMIBASE_2_PAHCI(pInterface);
2595 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
2596 PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->ILeds);
2597 return NULL;
2598}
2599
2600/**
2601 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
2602 */
2603static DECLCALLBACK(void *) ahciR3PortQueryInterface(PPDMIBASE pInterface, const char *pszIID)
2604{
2605 PAHCIPort pAhciPort = PDMIBASE_2_PAHCIPORT(pInterface);
2606 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pAhciPort->IBase);
2607 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAPORT, &pAhciPort->IPort);
2608 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAEXPORT, &pAhciPort->IMediaExPort);
2609 return NULL;
2610}
2611
2612/**
2613 * @interface_method_impl{PDMIMEDIAPORT,pfnQueryDeviceLocation}
2614 */
2615static DECLCALLBACK(int) ahciR3PortQueryDeviceLocation(PPDMIMEDIAPORT pInterface, const char **ppcszController,
2616 uint32_t *piInstance, uint32_t *piLUN)
2617{
2618 PAHCIPort pAhciPort = PDMIMEDIAPORT_2_PAHCIPORT(pInterface);
2619 PPDMDEVINS pDevIns = pAhciPort->CTX_SUFF(pDevIns);
2620
2621 AssertPtrReturn(ppcszController, VERR_INVALID_POINTER);
2622 AssertPtrReturn(piInstance, VERR_INVALID_POINTER);
2623 AssertPtrReturn(piLUN, VERR_INVALID_POINTER);
2624
2625 *ppcszController = pDevIns->pReg->szName;
2626 *piInstance = pDevIns->iInstance;
2627 *piLUN = pAhciPort->iLUN;
2628
2629 return VINF_SUCCESS;
2630}
2631
2632/**
2633 * @interface_method_impl{PDMIMEDIAPORT,pfnQueryScsiInqStrings}
2634 */
2635static DECLCALLBACK(int) ahciR3PortQueryScsiInqStrings(PPDMIMEDIAPORT pInterface, const char **ppszVendorId,
2636 const char **ppszProductId, const char **ppszRevision)
2637{
2638 PAHCIPort pAhciPort = PDMIMEDIAPORT_2_PAHCIPORT(pInterface);
2639
2640 if (ppszVendorId)
2641 *ppszVendorId = &pAhciPort->szInquiryVendorId[0];
2642 if (ppszProductId)
2643 *ppszProductId = &pAhciPort->szInquiryProductId[0];
2644 if (ppszRevision)
2645 *ppszRevision = &pAhciPort->szInquiryRevision[0];
2646 return VINF_SUCCESS;
2647}
2648
2649#ifdef LOG_ENABLED
2650
2651/**
2652 * Dump info about the FIS
2653 *
2654 * @returns nothing
2655 * @param pAhciPort The port the command FIS was read from.
2656 * @param cmdFis The FIS to print info from.
2657 */
2658static void ahciDumpFisInfo(PAHCIPort pAhciPort, uint8_t *cmdFis)
2659{
2660 ahciLog(("%s: *** Begin FIS info dump. ***\n", __FUNCTION__));
2661 /* Print FIS type. */
2662 switch (cmdFis[AHCI_CMDFIS_TYPE])
2663 {
2664 case AHCI_CMDFIS_TYPE_H2D:
2665 {
2666 ahciLog(("%s: Command Fis type: H2D\n", __FUNCTION__));
2667 ahciLog(("%s: Command Fis size: %d bytes\n", __FUNCTION__, AHCI_CMDFIS_TYPE_H2D_SIZE));
2668 if (cmdFis[AHCI_CMDFIS_BITS] & AHCI_CMDFIS_C)
2669 ahciLog(("%s: Command register update\n", __FUNCTION__));
2670 else
2671 ahciLog(("%s: Control register update\n", __FUNCTION__));
2672 ahciLog(("%s: CMD=%#04x \"%s\"\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_CMD], ATACmdText(cmdFis[AHCI_CMDFIS_CMD])));
2673 ahciLog(("%s: FEAT=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_FET]));
2674 ahciLog(("%s: SECTN=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_SECTN]));
2675 ahciLog(("%s: CYLL=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_CYLL]));
2676 ahciLog(("%s: CYLH=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_CYLH]));
2677 ahciLog(("%s: HEAD=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_HEAD]));
2678
2679 ahciLog(("%s: SECTNEXP=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_SECTNEXP]));
2680 ahciLog(("%s: CYLLEXP=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_CYLLEXP]));
2681 ahciLog(("%s: CYLHEXP=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_CYLHEXP]));
2682 ahciLog(("%s: FETEXP=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_FETEXP]));
2683
2684 ahciLog(("%s: SECTC=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_SECTC]));
2685 ahciLog(("%s: SECTCEXP=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_SECTCEXP]));
2686 ahciLog(("%s: CTL=%#04x\n", __FUNCTION__, cmdFis[AHCI_CMDFIS_CTL]));
2687 if (cmdFis[AHCI_CMDFIS_CTL] & AHCI_CMDFIS_CTL_SRST)
2688 ahciLog(("%s: Reset bit is set\n", __FUNCTION__));
2689 break;
2690 }
2691 case AHCI_CMDFIS_TYPE_D2H:
2692 {
2693 ahciLog(("%s: Command Fis type D2H\n", __FUNCTION__));
2694 ahciLog(("%s: Command Fis size: %d\n", __FUNCTION__, AHCI_CMDFIS_TYPE_D2H_SIZE));
2695 break;
2696 }
2697 case AHCI_CMDFIS_TYPE_SETDEVBITS:
2698 {
2699 ahciLog(("%s: Command Fis type Set Device Bits\n", __FUNCTION__));
2700 ahciLog(("%s: Command Fis size: %d\n", __FUNCTION__, AHCI_CMDFIS_TYPE_SETDEVBITS_SIZE));
2701 break;
2702 }
2703 case AHCI_CMDFIS_TYPE_DMAACTD2H:
2704 {
2705 ahciLog(("%s: Command Fis type DMA Activate H2D\n", __FUNCTION__));
2706 ahciLog(("%s: Command Fis size: %d\n", __FUNCTION__, AHCI_CMDFIS_TYPE_DMAACTD2H_SIZE));
2707 break;
2708 }
2709 case AHCI_CMDFIS_TYPE_DMASETUP:
2710 {
2711 ahciLog(("%s: Command Fis type DMA Setup\n", __FUNCTION__));
2712 ahciLog(("%s: Command Fis size: %d\n", __FUNCTION__, AHCI_CMDFIS_TYPE_DMASETUP_SIZE));
2713 break;
2714 }
2715 case AHCI_CMDFIS_TYPE_PIOSETUP:
2716 {
2717 ahciLog(("%s: Command Fis type PIO Setup\n", __FUNCTION__));
2718 ahciLog(("%s: Command Fis size: %d\n", __FUNCTION__, AHCI_CMDFIS_TYPE_PIOSETUP_SIZE));
2719 break;
2720 }
2721 case AHCI_CMDFIS_TYPE_DATA:
2722 {
2723 ahciLog(("%s: Command Fis type Data\n", __FUNCTION__));
2724 break;
2725 }
2726 default:
2727 ahciLog(("%s: ERROR Unknown command FIS type\n", __FUNCTION__));
2728 break;
2729 }
2730 ahciLog(("%s: *** End FIS info dump. ***\n", __FUNCTION__));
2731}
2732
2733/**
2734 * Dump info about the command header
2735 *
2736 * @returns nothing
2737 * @param pAhciPort Pointer to the port the command header was read from.
2738 * @param pCmdHdr The command header to print info from.
2739 */
2740static void ahciDumpCmdHdrInfo(PAHCIPort pAhciPort, CmdHdr *pCmdHdr)
2741{
2742 ahciLog(("%s: *** Begin command header info dump. ***\n", __FUNCTION__));
2743 ahciLog(("%s: Number of Scatter/Gatther List entries: %u\n", __FUNCTION__, AHCI_CMDHDR_PRDTL_ENTRIES(pCmdHdr->u32DescInf)));
2744 if (pCmdHdr->u32DescInf & AHCI_CMDHDR_C)
2745 ahciLog(("%s: Clear busy upon R_OK\n", __FUNCTION__));
2746 if (pCmdHdr->u32DescInf & AHCI_CMDHDR_B)
2747 ahciLog(("%s: BIST Fis\n", __FUNCTION__));
2748 if (pCmdHdr->u32DescInf & AHCI_CMDHDR_R)
2749 ahciLog(("%s: Device Reset Fis\n", __FUNCTION__));
2750 if (pCmdHdr->u32DescInf & AHCI_CMDHDR_P)
2751 ahciLog(("%s: Command prefetchable\n", __FUNCTION__));
2752 if (pCmdHdr->u32DescInf & AHCI_CMDHDR_W)
2753 ahciLog(("%s: Device write\n", __FUNCTION__));
2754 else
2755 ahciLog(("%s: Device read\n", __FUNCTION__));
2756 if (pCmdHdr->u32DescInf & AHCI_CMDHDR_A)
2757 ahciLog(("%s: ATAPI command\n", __FUNCTION__));
2758 else
2759 ahciLog(("%s: ATA command\n", __FUNCTION__));
2760
2761 ahciLog(("%s: Command FIS length %u DW\n", __FUNCTION__, (pCmdHdr->u32DescInf & AHCI_CMDHDR_CFL_MASK)));
2762 ahciLog(("%s: *** End command header info dump. ***\n", __FUNCTION__));
2763}
2764
2765#endif /* LOG_ENABLED */
2766
2767/**
2768 * Post the first D2H FIS from the device into guest memory.
2769 *
2770 * @returns nothing
2771 * @param pAhciPort Pointer to the port which "receives" the FIS.
2772 */
2773static void ahciPostFirstD2HFisIntoMemory(PAHCIPort pAhciPort)
2774{
2775 uint8_t d2hFis[AHCI_CMDFIS_TYPE_D2H_SIZE];
2776
2777 pAhciPort->fFirstD2HFisSent = true;
2778
2779 ahciLog(("%s: Sending First D2H FIS from FIFO\n", __FUNCTION__));
2780 memset(&d2hFis[0], 0, sizeof(d2hFis));
2781 d2hFis[AHCI_CMDFIS_TYPE] = AHCI_CMDFIS_TYPE_D2H;
2782 d2hFis[AHCI_CMDFIS_ERR] = 0x01;
2783
2784 d2hFis[AHCI_CMDFIS_STS] = 0x00;
2785
2786 /* Set the signature based on the device type. */
2787 if (pAhciPort->fATAPI)
2788 {
2789 d2hFis[AHCI_CMDFIS_CYLL] = 0x14;
2790 d2hFis[AHCI_CMDFIS_CYLH] = 0xeb;
2791 }
2792 else
2793 {
2794 d2hFis[AHCI_CMDFIS_CYLL] = 0x00;
2795 d2hFis[AHCI_CMDFIS_CYLH] = 0x00;
2796 }
2797
2798 d2hFis[AHCI_CMDFIS_HEAD] = 0x00;
2799 d2hFis[AHCI_CMDFIS_SECTN] = 0x01;
2800 d2hFis[AHCI_CMDFIS_SECTC] = 0x01;
2801
2802 pAhciPort->regTFD = (1 << 8) | ATA_STAT_SEEK | ATA_STAT_WRERR;
2803 if (!pAhciPort->fATAPI)
2804 pAhciPort->regTFD |= ATA_STAT_READY;
2805
2806 ahciPostFisIntoMemory(pAhciPort, AHCI_CMDFIS_TYPE_D2H, d2hFis);
2807}
2808
2809/**
2810 * Post the FIS in the memory area allocated by the guest and set interrupt if necessary.
2811 *
2812 * @returns VBox status code
2813 * @param pAhciPort The port which "receives" the FIS.
2814 * @param uFisType The type of the FIS.
2815 * @param pCmdFis Pointer to the FIS which is to be posted into memory.
2816 */
2817static int ahciPostFisIntoMemory(PAHCIPort pAhciPort, unsigned uFisType, uint8_t *pCmdFis)
2818{
2819 int rc = VINF_SUCCESS;
2820 RTGCPHYS GCPhysAddrRecFis = pAhciPort->GCPhysAddrFb;
2821 unsigned cbFis = 0;
2822
2823 ahciLog(("%s: pAhciPort=%p uFisType=%u pCmdFis=%p\n", __FUNCTION__, pAhciPort, uFisType, pCmdFis));
2824
2825 if (pAhciPort->regCMD & AHCI_PORT_CMD_FRE)
2826 {
2827 AssertMsg(GCPhysAddrRecFis, ("%s: GCPhysAddrRecFis is 0\n", __FUNCTION__));
2828
2829 /* Determine the offset and size of the FIS based on uFisType. */
2830 switch (uFisType)
2831 {
2832 case AHCI_CMDFIS_TYPE_D2H:
2833 {
2834 GCPhysAddrRecFis += AHCI_RECFIS_RFIS_OFFSET;
2835 cbFis = AHCI_CMDFIS_TYPE_D2H_SIZE;
2836 break;
2837 }
2838 case AHCI_CMDFIS_TYPE_SETDEVBITS:
2839 {
2840 GCPhysAddrRecFis += AHCI_RECFIS_SDBFIS_OFFSET;
2841 cbFis = AHCI_CMDFIS_TYPE_SETDEVBITS_SIZE;
2842 break;
2843 }
2844 case AHCI_CMDFIS_TYPE_DMASETUP:
2845 {
2846 GCPhysAddrRecFis += AHCI_RECFIS_DSFIS_OFFSET;
2847 cbFis = AHCI_CMDFIS_TYPE_DMASETUP_SIZE;
2848 break;
2849 }
2850 case AHCI_CMDFIS_TYPE_PIOSETUP:
2851 {
2852 GCPhysAddrRecFis += AHCI_RECFIS_PSFIS_OFFSET;
2853 cbFis = AHCI_CMDFIS_TYPE_PIOSETUP_SIZE;
2854 break;
2855 }
2856 default:
2857 /*
2858 * We should post the unknown FIS into memory too but this never happens because
2859 * we know which FIS types we generate. ;)
2860 */
2861 AssertMsgFailed(("%s: Unknown FIS type!\n", __FUNCTION__));
2862 }
2863
2864 /* Post the FIS into memory. */
2865 ahciLog(("%s: PDMDevHlpPCIPhysWrite GCPhysAddrRecFis=%RGp cbFis=%u\n", __FUNCTION__, GCPhysAddrRecFis, cbFis));
2866 PDMDevHlpPCIPhysWrite(pAhciPort->CTX_SUFF(pDevIns), GCPhysAddrRecFis, pCmdFis, cbFis);
2867 }
2868
2869 return rc;
2870}
2871
2872DECLINLINE(void) ahciReqSetStatus(PAHCIREQ pAhciReq, uint8_t u8Error, uint8_t u8Status)
2873{
2874 pAhciReq->cmdFis[AHCI_CMDFIS_ERR] = u8Error;
2875 pAhciReq->cmdFis[AHCI_CMDFIS_STS] = u8Status;
2876}
2877
2878static void ataPadString(uint8_t *pbDst, const char *pbSrc, uint32_t cbSize)
2879{
2880 for (uint32_t i = 0; i < cbSize; i++)
2881 {
2882 if (*pbSrc)
2883 pbDst[i ^ 1] = *pbSrc++;
2884 else
2885 pbDst[i ^ 1] = ' ';
2886 }
2887}
2888
2889static uint32_t ataChecksum(void* ptr, size_t count)
2890{
2891 uint8_t u8Sum = 0xa5, *p = (uint8_t*)ptr;
2892 size_t i;
2893
2894 for (i = 0; i < count; i++)
2895 {
2896 u8Sum += *p++;
2897 }
2898
2899 return (uint8_t)-(int32_t)u8Sum;
2900}
2901
2902static int ahciIdentifySS(PAHCIPort pAhciPort, void *pvBuf)
2903{
2904 uint16_t *p = (uint16_t *)pvBuf;
2905 memset(p, 0, 512);
2906 p[0] = RT_H2LE_U16(0x0040);
2907 p[1] = RT_H2LE_U16(RT_MIN(pAhciPort->PCHSGeometry.cCylinders, 16383));
2908 p[3] = RT_H2LE_U16(pAhciPort->PCHSGeometry.cHeads);
2909 /* Block size; obsolete, but required for the BIOS. */
2910 p[5] = RT_H2LE_U16(512);
2911 p[6] = RT_H2LE_U16(pAhciPort->PCHSGeometry.cSectors);
2912 ataPadString((uint8_t *)(p + 10), pAhciPort->szSerialNumber, AHCI_SERIAL_NUMBER_LENGTH); /* serial number */
2913 p[20] = RT_H2LE_U16(3); /* XXX: retired, cache type */
2914 p[21] = RT_H2LE_U16(512); /* XXX: retired, cache size in sectors */
2915 p[22] = RT_H2LE_U16(0); /* ECC bytes per sector */
2916 ataPadString((uint8_t *)(p + 23), pAhciPort->szFirmwareRevision, AHCI_FIRMWARE_REVISION_LENGTH); /* firmware version */
2917 ataPadString((uint8_t *)(p + 27), pAhciPort->szModelNumber, AHCI_MODEL_NUMBER_LENGTH); /* model */
2918#if ATA_MAX_MULT_SECTORS > 1
2919 p[47] = RT_H2LE_U16(0x8000 | ATA_MAX_MULT_SECTORS);
2920#endif
2921 p[48] = RT_H2LE_U16(1); /* dword I/O, used by the BIOS */
2922 p[49] = RT_H2LE_U16(1 << 11 | 1 << 9 | 1 << 8); /* DMA and LBA supported */
2923 p[50] = RT_H2LE_U16(1 << 14); /* No drive specific standby timer minimum */
2924 p[51] = RT_H2LE_U16(240); /* PIO transfer cycle */
2925 p[52] = RT_H2LE_U16(240); /* DMA transfer cycle */
2926 p[53] = RT_H2LE_U16(1 | 1 << 1 | 1 << 2); /* words 54-58,64-70,88 valid */
2927 p[54] = RT_H2LE_U16(RT_MIN(pAhciPort->PCHSGeometry.cCylinders, 16383));
2928 p[55] = RT_H2LE_U16(pAhciPort->PCHSGeometry.cHeads);
2929 p[56] = RT_H2LE_U16(pAhciPort->PCHSGeometry.cSectors);
2930 p[57] = RT_H2LE_U16(RT_MIN(pAhciPort->PCHSGeometry.cCylinders, 16383) * pAhciPort->PCHSGeometry.cHeads * pAhciPort->PCHSGeometry.cSectors);
2931 p[58] = RT_H2LE_U16(RT_MIN(pAhciPort->PCHSGeometry.cCylinders, 16383) * pAhciPort->PCHSGeometry.cHeads * pAhciPort->PCHSGeometry.cSectors >> 16);
2932 if (pAhciPort->cMultSectors)
2933 p[59] = RT_H2LE_U16(0x100 | pAhciPort->cMultSectors);
2934 if (pAhciPort->cTotalSectors <= (1 << 28) - 1)
2935 {
2936 p[60] = RT_H2LE_U16(pAhciPort->cTotalSectors);
2937 p[61] = RT_H2LE_U16(pAhciPort->cTotalSectors >> 16);
2938 }
2939 else
2940 {
2941 /* Report maximum number of sectors possible with LBA28 */
2942 p[60] = RT_H2LE_U16(((1 << 28) - 1) & 0xffff);
2943 p[61] = RT_H2LE_U16(((1 << 28) - 1) >> 16);
2944 }
2945 p[63] = RT_H2LE_U16(ATA_TRANSFER_ID(ATA_MODE_MDMA, ATA_MDMA_MODE_MAX, pAhciPort->uATATransferMode)); /* MDMA modes supported / mode enabled */
2946 p[64] = RT_H2LE_U16(ATA_PIO_MODE_MAX > 2 ? (1 << (ATA_PIO_MODE_MAX - 2)) - 1 : 0); /* PIO modes beyond PIO2 supported */
2947 p[65] = RT_H2LE_U16(120); /* minimum DMA multiword tx cycle time */
2948 p[66] = RT_H2LE_U16(120); /* recommended DMA multiword tx cycle time */
2949 p[67] = RT_H2LE_U16(120); /* minimum PIO cycle time without flow control */
2950 p[68] = RT_H2LE_U16(120); /* minimum PIO cycle time with IORDY flow control */
2951 if ( pAhciPort->fTrimEnabled
2952 || pAhciPort->cbSector != 512
2953 || pAhciPort->pDrvMedia->pfnIsNonRotational(pAhciPort->pDrvMedia))
2954 {
2955 p[80] = RT_H2LE_U16(0x1f0); /* support everything up to ATA/ATAPI-8 ACS */
2956 p[81] = RT_H2LE_U16(0x28); /* conforms to ATA/ATAPI-8 ACS */
2957 }
2958 else
2959 {
2960 p[80] = RT_H2LE_U16(0x7e); /* support everything up to ATA/ATAPI-6 */
2961 p[81] = RT_H2LE_U16(0x22); /* conforms to ATA/ATAPI-6 */
2962 }
2963 p[82] = RT_H2LE_U16(1 << 3 | 1 << 5 | 1 << 6); /* supports power management, write cache and look-ahead */
2964 p[83] = RT_H2LE_U16(1 << 14 | 1 << 10 | 1 << 12 | 1 << 13); /* supports LBA48, FLUSH CACHE and FLUSH CACHE EXT */
2965 p[84] = RT_H2LE_U16(1 << 14);
2966 p[85] = RT_H2LE_U16(1 << 3 | 1 << 5 | 1 << 6); /* enabled power management, write cache and look-ahead */
2967 p[86] = RT_H2LE_U16(1 << 10 | 1 << 12 | 1 << 13); /* enabled LBA48, FLUSH CACHE and FLUSH CACHE EXT */
2968 p[87] = RT_H2LE_U16(1 << 14);
2969 p[88] = RT_H2LE_U16(ATA_TRANSFER_ID(ATA_MODE_UDMA, ATA_UDMA_MODE_MAX, pAhciPort->uATATransferMode)); /* UDMA modes supported / mode enabled */
2970 p[93] = RT_H2LE_U16(0x00);
2971 p[100] = RT_H2LE_U16(pAhciPort->cTotalSectors);
2972 p[101] = RT_H2LE_U16(pAhciPort->cTotalSectors >> 16);
2973 p[102] = RT_H2LE_U16(pAhciPort->cTotalSectors >> 32);
2974 p[103] = RT_H2LE_U16(pAhciPort->cTotalSectors >> 48);
2975
2976 /* valid information, more than one logical sector per physical sector, 2^cLogSectorsPerPhysicalExp logical sectors per physical sector */
2977 if (pAhciPort->cLogSectorsPerPhysicalExp)
2978 p[106] = RT_H2LE_U16(RT_BIT(14) | RT_BIT(13) | pAhciPort->cLogSectorsPerPhysicalExp);
2979
2980 if (pAhciPort->cbSector != 512)
2981 {
2982 uint32_t cSectorSizeInWords = pAhciPort->cbSector / sizeof(uint16_t);
2983 /* Enable reporting of logical sector size. */
2984 p[106] |= RT_H2LE_U16(RT_BIT(12) | RT_BIT(14));
2985 p[117] = RT_H2LE_U16(cSectorSizeInWords);
2986 p[118] = RT_H2LE_U16(cSectorSizeInWords >> 16);
2987 }
2988
2989 if (pAhciPort->pDrvMedia->pfnIsNonRotational(pAhciPort->pDrvMedia))
2990 p[217] = RT_H2LE_U16(1); /* Non-rotational medium */
2991
2992 if (pAhciPort->fTrimEnabled) /** @todo Set bit 14 in word 69 too? (Deterministic read after TRIM). */
2993 p[169] = RT_H2LE_U16(1); /* DATA SET MANAGEMENT command supported. */
2994
2995 /* The following are SATA specific */
2996 p[75] = RT_H2LE_U16(pAhciPort->CTX_SUFF(pAhci)->cCmdSlotsAvail-1); /* Number of commands we support, 0's based */
2997 p[76] = RT_H2LE_U16((1 << 8) | (1 << 2)); /* Native command queuing and Serial ATA Gen2 (3.0 Gbps) speed supported */
2998
2999 uint32_t uCsum = ataChecksum(p, 510);
3000 p[255] = RT_H2LE_U16(0xa5 | (uCsum << 8)); /* Integrity word */
3001
3002 return VINF_SUCCESS;
3003}
3004
3005static int ahciR3AtapiIdentify(PAHCIREQ pAhciReq, PAHCIPort pAhciPort, size_t cbData, size_t *pcbData)
3006{
3007 uint16_t p[256];
3008
3009 memset(p, 0, 512);
3010 /* Removable CDROM, 50us response, 12 byte packets */
3011 p[0] = RT_H2LE_U16(2 << 14 | 5 << 8 | 1 << 7 | 2 << 5 | 0 << 0);
3012 ataPadString((uint8_t *)(p + 10), pAhciPort->szSerialNumber, AHCI_SERIAL_NUMBER_LENGTH); /* serial number */
3013 p[20] = RT_H2LE_U16(3); /* XXX: retired, cache type */
3014 p[21] = RT_H2LE_U16(512); /* XXX: retired, cache size in sectors */
3015 ataPadString((uint8_t *)(p + 23), pAhciPort->szFirmwareRevision, AHCI_FIRMWARE_REVISION_LENGTH); /* firmware version */
3016 ataPadString((uint8_t *)(p + 27), pAhciPort->szModelNumber, AHCI_MODEL_NUMBER_LENGTH); /* model */
3017 p[49] = RT_H2LE_U16(1 << 11 | 1 << 9 | 1 << 8); /* DMA and LBA supported */
3018 p[50] = RT_H2LE_U16(1 << 14); /* No drive specific standby timer minimum */
3019 p[51] = RT_H2LE_U16(240); /* PIO transfer cycle */
3020 p[52] = RT_H2LE_U16(240); /* DMA transfer cycle */
3021 p[53] = RT_H2LE_U16(1 << 1 | 1 << 2); /* words 64-70,88 are valid */
3022 p[63] = RT_H2LE_U16(ATA_TRANSFER_ID(ATA_MODE_MDMA, ATA_MDMA_MODE_MAX, pAhciPort->uATATransferMode)); /* MDMA modes supported / mode enabled */
3023 p[64] = RT_H2LE_U16(ATA_PIO_MODE_MAX > 2 ? (1 << (ATA_PIO_MODE_MAX - 2)) - 1 : 0); /* PIO modes beyond PIO2 supported */
3024 p[65] = RT_H2LE_U16(120); /* minimum DMA multiword tx cycle time */
3025 p[66] = RT_H2LE_U16(120); /* recommended DMA multiword tx cycle time */
3026 p[67] = RT_H2LE_U16(120); /* minimum PIO cycle time without flow control */
3027 p[68] = RT_H2LE_U16(120); /* minimum PIO cycle time with IORDY flow control */
3028 p[73] = RT_H2LE_U16(0x003e); /* ATAPI CDROM major */
3029 p[74] = RT_H2LE_U16(9); /* ATAPI CDROM minor */
3030 p[80] = RT_H2LE_U16(0x7e); /* support everything up to ATA/ATAPI-6 */
3031 p[81] = RT_H2LE_U16(0x22); /* conforms to ATA/ATAPI-6 */
3032 p[82] = RT_H2LE_U16(1 << 4 | 1 << 9); /* supports packet command set and DEVICE RESET */
3033 p[83] = RT_H2LE_U16(1 << 14);
3034 p[84] = RT_H2LE_U16(1 << 14);
3035 p[85] = RT_H2LE_U16(1 << 4 | 1 << 9); /* enabled packet command set and DEVICE RESET */
3036 p[86] = RT_H2LE_U16(0);
3037 p[87] = RT_H2LE_U16(1 << 14);
3038 p[88] = RT_H2LE_U16(ATA_TRANSFER_ID(ATA_MODE_UDMA, ATA_UDMA_MODE_MAX, pAhciPort->uATATransferMode)); /* UDMA modes supported / mode enabled */
3039 p[93] = RT_H2LE_U16((1 | 1 << 1) << ((pAhciPort->iLUN & 1) == 0 ? 0 : 8) | 1 << 13 | 1 << 14);
3040
3041 /* The following are SATA specific */
3042 p[75] = RT_H2LE_U16(31); /* We support 32 commands */
3043 p[76] = RT_H2LE_U16((1 << 8) | (1 << 2)); /* Native command queuing and Serial ATA Gen2 (3.0 Gbps) speed supported */
3044
3045 /* Copy the buffer in to the scatter gather list. */
3046 *pcbData = ahciR3CopyBufferToPrdtl(pAhciPort->CTX_SUFF(pAhci), pAhciReq, (void *)&p[0],
3047 RT_MIN(cbData, sizeof(p)), 0 /* cbSkip */);
3048 return VINF_SUCCESS;
3049}
3050
3051/**
3052 * Reset all values after a reset of the attached storage device.
3053 *
3054 * @returns nothing
3055 * @param pAhciPort The port the device is attached to.
3056 * @param pAhciReq The state to get the tag number from.
3057 */
3058static void ahciFinishStorageDeviceReset(PAHCIPort pAhciPort, PAHCIREQ pAhciReq)
3059{
3060 int rc;
3061
3062 /* Send a status good D2H FIS. */
3063 pAhciPort->fResetDevice = false;
3064 if (pAhciPort->regCMD & AHCI_PORT_CMD_FRE)
3065 ahciPostFirstD2HFisIntoMemory(pAhciPort);
3066
3067 /* As this is the first D2H FIS after the reset update the signature in the SIG register of the port. */
3068 if (pAhciPort->fATAPI)
3069 pAhciPort->regSIG = AHCI_PORT_SIG_ATAPI;
3070 else
3071 pAhciPort->regSIG = AHCI_PORT_SIG_DISK;
3072 ASMAtomicOrU32(&pAhciPort->u32TasksFinished, (1 << pAhciReq->uTag));
3073
3074 rc = ahciHbaSetInterrupt(pAhciPort->CTX_SUFF(pAhci), pAhciPort->iLUN, VERR_IGNORED);
3075 AssertRC(rc);
3076}
3077
3078/**
3079 * Initiates a device reset caused by ATA_DEVICE_RESET (ATAPI only).
3080 *
3081 * @returns nothing.
3082 * @param pAhciPort The device to reset.
3083 * @param pAhciReq The task state.
3084 */
3085static void ahciDeviceReset(PAHCIPort pAhciPort, PAHCIREQ pAhciReq)
3086{
3087 ASMAtomicWriteBool(&pAhciPort->fResetDevice, true);
3088
3089 /*
3090 * Because this ATAPI only and ATAPI can't have
3091 * more than one command active at a time the task counter should be 0
3092 * and it is possible to finish the reset now.
3093 */
3094 Assert(ASMAtomicReadU32(&pAhciPort->cTasksActive) == 0);
3095 ahciFinishStorageDeviceReset(pAhciPort, pAhciReq);
3096}
3097
3098/**
3099 * Create a PIO setup FIS and post it into the memory area of the guest.
3100 *
3101 * @returns nothing.
3102 * @param pAhciPort The port of the SATA controller.
3103 * @param cbTransfer Transfer size of the request.
3104 * @param pCmdFis Pointer to the command FIS from the guest.
3105 * @param fRead Flag whether this is a read request.
3106 * @param fInterrupt If an interrupt should be send to the guest.
3107 */
3108static void ahciSendPioSetupFis(PAHCIPort pAhciPort, size_t cbTransfer, uint8_t *pCmdFis,
3109 bool fRead, bool fInterrupt)
3110{
3111 uint8_t abPioSetupFis[20];
3112 bool fAssertIntr = false;
3113 PAHCI pAhci = pAhciPort->CTX_SUFF(pAhci);
3114
3115 ahciLog(("%s: building PIO setup Fis\n", __FUNCTION__));
3116
3117 AssertMsg( cbTransfer > 0
3118 && cbTransfer <= 65534,
3119 ("Can't send PIO setup FIS for requests with 0 bytes to transfer or greater than 65534\n"));
3120
3121 if (pAhciPort->regCMD & AHCI_PORT_CMD_FRE)
3122 {
3123 memset(&abPioSetupFis[0], 0, sizeof(abPioSetupFis));
3124 abPioSetupFis[AHCI_CMDFIS_TYPE] = AHCI_CMDFIS_TYPE_PIOSETUP;
3125 abPioSetupFis[AHCI_CMDFIS_BITS] = (fInterrupt ? AHCI_CMDFIS_I : 0);
3126 if (fRead)
3127 abPioSetupFis[AHCI_CMDFIS_BITS] |= AHCI_CMDFIS_D;
3128 abPioSetupFis[AHCI_CMDFIS_STS] = pCmdFis[AHCI_CMDFIS_STS];
3129 abPioSetupFis[AHCI_CMDFIS_ERR] = pCmdFis[AHCI_CMDFIS_ERR];
3130 abPioSetupFis[AHCI_CMDFIS_SECTN] = pCmdFis[AHCI_CMDFIS_SECTN];
3131 abPioSetupFis[AHCI_CMDFIS_CYLL] = pCmdFis[AHCI_CMDFIS_CYLL];
3132 abPioSetupFis[AHCI_CMDFIS_CYLH] = pCmdFis[AHCI_CMDFIS_CYLH];
3133 abPioSetupFis[AHCI_CMDFIS_HEAD] = pCmdFis[AHCI_CMDFIS_HEAD];
3134 abPioSetupFis[AHCI_CMDFIS_SECTNEXP] = pCmdFis[AHCI_CMDFIS_SECTNEXP];
3135 abPioSetupFis[AHCI_CMDFIS_CYLLEXP] = pCmdFis[AHCI_CMDFIS_CYLLEXP];
3136 abPioSetupFis[AHCI_CMDFIS_CYLHEXP] = pCmdFis[AHCI_CMDFIS_CYLHEXP];
3137 abPioSetupFis[AHCI_CMDFIS_SECTC] = pCmdFis[AHCI_CMDFIS_SECTC];
3138 abPioSetupFis[AHCI_CMDFIS_SECTCEXP] = pCmdFis[AHCI_CMDFIS_SECTCEXP];
3139
3140 /* Set transfer count. */
3141 abPioSetupFis[16] = (cbTransfer >> 8) & 0xff;
3142 abPioSetupFis[17] = cbTransfer & 0xff;
3143
3144 /* Update registers. */
3145 pAhciPort->regTFD = (pCmdFis[AHCI_CMDFIS_ERR] << 8) | pCmdFis[AHCI_CMDFIS_STS];
3146
3147 ahciPostFisIntoMemory(pAhciPort, AHCI_CMDFIS_TYPE_PIOSETUP, abPioSetupFis);
3148
3149 if (fInterrupt)
3150 {
3151 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_PSS);
3152 /* Check if we should assert an interrupt */
3153 if (pAhciPort->regIE & AHCI_PORT_IE_PSE)
3154 fAssertIntr = true;
3155 }
3156
3157 if (fAssertIntr)
3158 {
3159 int rc = ahciHbaSetInterrupt(pAhci, pAhciPort->iLUN, VERR_IGNORED);
3160 AssertRC(rc);
3161 }
3162 }
3163}
3164
3165/**
3166 * Build a D2H FIS and post into the memory area of the guest.
3167 *
3168 * @returns Nothing
3169 * @param pAhciPort The port of the SATA controller.
3170 * @param uTag The tag of the request.
3171 * @param pCmdFis Pointer to the command FIS from the guest.
3172 * @param fInterrupt If an interrupt should be send to the guest.
3173 */
3174static void ahciSendD2HFis(PAHCIPort pAhciPort, uint32_t uTag, uint8_t *pCmdFis, bool fInterrupt)
3175{
3176 uint8_t d2hFis[20];
3177 bool fAssertIntr = false;
3178 PAHCI pAhci = pAhciPort->CTX_SUFF(pAhci);
3179
3180 ahciLog(("%s: building D2H Fis\n", __FUNCTION__));
3181
3182 if (pAhciPort->regCMD & AHCI_PORT_CMD_FRE)
3183 {
3184 memset(&d2hFis[0], 0, sizeof(d2hFis));
3185 d2hFis[AHCI_CMDFIS_TYPE] = AHCI_CMDFIS_TYPE_D2H;
3186 d2hFis[AHCI_CMDFIS_BITS] = (fInterrupt ? AHCI_CMDFIS_I : 0);
3187 d2hFis[AHCI_CMDFIS_STS] = pCmdFis[AHCI_CMDFIS_STS];
3188 d2hFis[AHCI_CMDFIS_ERR] = pCmdFis[AHCI_CMDFIS_ERR];
3189 d2hFis[AHCI_CMDFIS_SECTN] = pCmdFis[AHCI_CMDFIS_SECTN];
3190 d2hFis[AHCI_CMDFIS_CYLL] = pCmdFis[AHCI_CMDFIS_CYLL];
3191 d2hFis[AHCI_CMDFIS_CYLH] = pCmdFis[AHCI_CMDFIS_CYLH];
3192 d2hFis[AHCI_CMDFIS_HEAD] = pCmdFis[AHCI_CMDFIS_HEAD];
3193 d2hFis[AHCI_CMDFIS_SECTNEXP] = pCmdFis[AHCI_CMDFIS_SECTNEXP];
3194 d2hFis[AHCI_CMDFIS_CYLLEXP] = pCmdFis[AHCI_CMDFIS_CYLLEXP];
3195 d2hFis[AHCI_CMDFIS_CYLHEXP] = pCmdFis[AHCI_CMDFIS_CYLHEXP];
3196 d2hFis[AHCI_CMDFIS_SECTC] = pCmdFis[AHCI_CMDFIS_SECTC];
3197 d2hFis[AHCI_CMDFIS_SECTCEXP] = pCmdFis[AHCI_CMDFIS_SECTCEXP];
3198
3199 /* Update registers. */
3200 pAhciPort->regTFD = (pCmdFis[AHCI_CMDFIS_ERR] << 8) | pCmdFis[AHCI_CMDFIS_STS];
3201
3202 ahciPostFisIntoMemory(pAhciPort, AHCI_CMDFIS_TYPE_D2H, d2hFis);
3203
3204 if (pCmdFis[AHCI_CMDFIS_STS] & ATA_STAT_ERR)
3205 {
3206 /* Error bit is set. */
3207 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_TFES);
3208 if (pAhciPort->regIE & AHCI_PORT_IE_TFEE)
3209 fAssertIntr = true;
3210 /*
3211 * Don't mark the command slot as completed because the guest
3212 * needs it to identify the failed command.
3213 */
3214 }
3215 else if (fInterrupt)
3216 {
3217 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_DHRS);
3218 /* Check if we should assert an interrupt */
3219 if (pAhciPort->regIE & AHCI_PORT_IE_DHRE)
3220 fAssertIntr = true;
3221
3222 /* Mark command as completed. */
3223 ASMAtomicOrU32(&pAhciPort->u32TasksFinished, RT_BIT_32(uTag));
3224 }
3225
3226 if (fAssertIntr)
3227 {
3228 int rc = ahciHbaSetInterrupt(pAhci, pAhciPort->iLUN, VERR_IGNORED);
3229 AssertRC(rc);
3230 }
3231 }
3232}
3233
3234/**
3235 * Build a SDB Fis and post it into the memory area of the guest.
3236 *
3237 * @returns Nothing
3238 * @param pAhciPort The port for which the SDB Fis is send.
3239 * @param uFinishedTasks Bitmask of finished tasks.
3240 * @param fInterrupt If an interrupt should be asserted.
3241 */
3242static void ahciSendSDBFis(PAHCIPort pAhciPort, uint32_t uFinishedTasks, bool fInterrupt)
3243{
3244 uint32_t sdbFis[2];
3245 bool fAssertIntr = false;
3246 PAHCI pAhci = pAhciPort->CTX_SUFF(pAhci);
3247 PAHCIREQ pTaskErr = ASMAtomicReadPtrT(&pAhciPort->pTaskErr, PAHCIREQ);
3248
3249 ahciLog(("%s: Building SDB FIS\n", __FUNCTION__));
3250
3251 if (pAhciPort->regCMD & AHCI_PORT_CMD_FRE)
3252 {
3253 memset(&sdbFis[0], 0, sizeof(sdbFis));
3254 sdbFis[0] = AHCI_CMDFIS_TYPE_SETDEVBITS;
3255 sdbFis[0] |= (fInterrupt ? (1 << 14) : 0);
3256 if (RT_UNLIKELY(pTaskErr))
3257 {
3258 sdbFis[0] = pTaskErr->cmdFis[AHCI_CMDFIS_ERR];
3259 sdbFis[0] |= (pTaskErr->cmdFis[AHCI_CMDFIS_STS] & 0x77) << 16; /* Some bits are marked as reserved and thus are masked out. */
3260
3261 /* Update registers. */
3262 pAhciPort->regTFD = (pTaskErr->cmdFis[AHCI_CMDFIS_ERR] << 8) | pTaskErr->cmdFis[AHCI_CMDFIS_STS];
3263 }
3264 else
3265 {
3266 sdbFis[0] = 0;
3267 sdbFis[0] |= (ATA_STAT_READY | ATA_STAT_SEEK) << 16;
3268 pAhciPort->regTFD = ATA_STAT_READY | ATA_STAT_SEEK;
3269 }
3270
3271 sdbFis[1] = pAhciPort->u32QueuedTasksFinished | uFinishedTasks;
3272
3273 ahciPostFisIntoMemory(pAhciPort, AHCI_CMDFIS_TYPE_SETDEVBITS, (uint8_t *)sdbFis);
3274
3275 if (RT_UNLIKELY(pTaskErr))
3276 {
3277 /* Error bit is set. */
3278 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_TFES);
3279 if (pAhciPort->regIE & AHCI_PORT_IE_TFEE)
3280 fAssertIntr = true;
3281 }
3282
3283 if (fInterrupt)
3284 {
3285 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_SDBS);
3286 /* Check if we should assert an interrupt */
3287 if (pAhciPort->regIE & AHCI_PORT_IE_SDBE)
3288 fAssertIntr = true;
3289 }
3290
3291 ASMAtomicOrU32(&pAhciPort->u32QueuedTasksFinished, uFinishedTasks);
3292
3293 if (fAssertIntr)
3294 {
3295 int rc = ahciHbaSetInterrupt(pAhci, pAhciPort->iLUN, VERR_IGNORED);
3296 AssertRC(rc);
3297 }
3298 }
3299}
3300
3301static uint32_t ahciGetNSectors(uint8_t *pCmdFis, bool fLBA48)
3302{
3303 /* 0 means either 256 (LBA28) or 65536 (LBA48) sectors. */
3304 if (fLBA48)
3305 {
3306 if (!pCmdFis[AHCI_CMDFIS_SECTC] && !pCmdFis[AHCI_CMDFIS_SECTCEXP])
3307 return 65536;
3308 else
3309 return pCmdFis[AHCI_CMDFIS_SECTCEXP] << 8 | pCmdFis[AHCI_CMDFIS_SECTC];
3310 }
3311 else
3312 {
3313 if (!pCmdFis[AHCI_CMDFIS_SECTC])
3314 return 256;
3315 else
3316 return pCmdFis[AHCI_CMDFIS_SECTC];
3317 }
3318}
3319
3320static uint64_t ahciGetSector(PAHCIPort pAhciPort, uint8_t *pCmdFis, bool fLBA48)
3321{
3322 uint64_t iLBA;
3323 if (pCmdFis[AHCI_CMDFIS_HEAD] & 0x40)
3324 {
3325 /* any LBA variant */
3326 if (fLBA48)
3327 {
3328 /* LBA48 */
3329 iLBA = ((uint64_t)pCmdFis[AHCI_CMDFIS_CYLHEXP] << 40) |
3330 ((uint64_t)pCmdFis[AHCI_CMDFIS_CYLLEXP] << 32) |
3331 ((uint64_t)pCmdFis[AHCI_CMDFIS_SECTNEXP] << 24) |
3332 ((uint64_t)pCmdFis[AHCI_CMDFIS_CYLH] << 16) |
3333 ((uint64_t)pCmdFis[AHCI_CMDFIS_CYLL] << 8) |
3334 pCmdFis[AHCI_CMDFIS_SECTN];
3335 }
3336 else
3337 {
3338 /* LBA */
3339 iLBA = ((pCmdFis[AHCI_CMDFIS_HEAD] & 0x0f) << 24) | (pCmdFis[AHCI_CMDFIS_CYLH] << 16) |
3340 (pCmdFis[AHCI_CMDFIS_CYLL] << 8) | pCmdFis[AHCI_CMDFIS_SECTN];
3341 }
3342 }
3343 else
3344 {
3345 /* CHS */
3346 iLBA = ((pCmdFis[AHCI_CMDFIS_CYLH] << 8) | pCmdFis[AHCI_CMDFIS_CYLL]) * pAhciPort->PCHSGeometry.cHeads * pAhciPort->PCHSGeometry.cSectors +
3347 (pCmdFis[AHCI_CMDFIS_HEAD] & 0x0f) * pAhciPort->PCHSGeometry.cSectors +
3348 (pCmdFis[AHCI_CMDFIS_SECTN] - 1);
3349 }
3350 return iLBA;
3351}
3352
3353static uint64_t ahciGetSectorQueued(uint8_t *pCmdFis)
3354{
3355 uint64_t uLBA;
3356
3357 uLBA = ((uint64_t)pCmdFis[AHCI_CMDFIS_CYLHEXP] << 40) |
3358 ((uint64_t)pCmdFis[AHCI_CMDFIS_CYLLEXP] << 32) |
3359 ((uint64_t)pCmdFis[AHCI_CMDFIS_SECTNEXP] << 24) |
3360 ((uint64_t)pCmdFis[AHCI_CMDFIS_CYLH] << 16) |
3361 ((uint64_t)pCmdFis[AHCI_CMDFIS_CYLL] << 8) |
3362 pCmdFis[AHCI_CMDFIS_SECTN];
3363
3364 return uLBA;
3365}
3366
3367DECLINLINE(uint32_t) ahciGetNSectorsQueued(uint8_t *pCmdFis)
3368{
3369 if (!pCmdFis[AHCI_CMDFIS_FETEXP] && !pCmdFis[AHCI_CMDFIS_FET])
3370 return 65536;
3371 else
3372 return pCmdFis[AHCI_CMDFIS_FETEXP] << 8 | pCmdFis[AHCI_CMDFIS_FET];
3373}
3374
3375/**
3376 * Copy from guest to host memory worker.
3377 *
3378 * @copydoc AHCIR3MEMCOPYCALLBACK
3379 */
3380static DECLCALLBACK(void) ahciR3CopyBufferFromGuestWorker(PAHCI pThis, RTGCPHYS GCPhys, PRTSGBUF pSgBuf,
3381 size_t cbCopy, size_t *pcbSkip)
3382{
3383 size_t cbSkipped = RT_MIN(cbCopy, *pcbSkip);
3384 cbCopy -= cbSkipped;
3385 GCPhys += cbSkipped;
3386 *pcbSkip -= cbSkipped;
3387
3388 while (cbCopy)
3389 {
3390 size_t cbSeg = cbCopy;
3391 void *pvSeg = RTSgBufGetNextSegment(pSgBuf, &cbSeg);
3392
3393 AssertPtr(pvSeg);
3394 PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhys, pvSeg, cbSeg);
3395 GCPhys += cbSeg;
3396 cbCopy -= cbSeg;
3397 }
3398}
3399
3400/**
3401 * Copy from host to guest memory worker.
3402 *
3403 * @copydoc AHCIR3MEMCOPYCALLBACK
3404 */
3405static DECLCALLBACK(void) ahciR3CopyBufferToGuestWorker(PAHCI pThis, RTGCPHYS GCPhys, PRTSGBUF pSgBuf,
3406 size_t cbCopy, size_t *pcbSkip)
3407{
3408 size_t cbSkipped = RT_MIN(cbCopy, *pcbSkip);
3409 cbCopy -= cbSkipped;
3410 GCPhys += cbSkipped;
3411 *pcbSkip -= cbSkipped;
3412
3413 while (cbCopy)
3414 {
3415 size_t cbSeg = cbCopy;
3416 void *pvSeg = RTSgBufGetNextSegment(pSgBuf, &cbSeg);
3417
3418 AssertPtr(pvSeg);
3419 PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhys, pvSeg, cbSeg);
3420 GCPhys += cbSeg;
3421 cbCopy -= cbSeg;
3422 }
3423}
3424
3425/**
3426 * Walks the PRDTL list copying data between the guest and host memory buffers.
3427 *
3428 * @returns Amount of bytes copied.
3429 * @param pThis The AHCI controller device instance.
3430 * @param pAhciReq AHCI request structure.
3431 * @param pfnCopyWorker The copy method to apply for each guest buffer.
3432 * @param pSgBuf The host S/G buffer.
3433 * @param cbSkip How many bytes to skip in advance before starting to copy.
3434 * @param cbCopy How many bytes to copy.
3435 */
3436static size_t ahciR3PrdtlWalk(PAHCI pThis, PAHCIREQ pAhciReq,
3437 PAHCIR3MEMCOPYCALLBACK pfnCopyWorker,
3438 PRTSGBUF pSgBuf, size_t cbSkip, size_t cbCopy)
3439{
3440 RTGCPHYS GCPhysPrdtl = pAhciReq->GCPhysPrdtl;
3441 unsigned cPrdtlEntries = pAhciReq->cPrdtlEntries;
3442 size_t cbCopied = 0;
3443
3444 /*
3445 * Add the amount to skip to the host buffer size to avoid a
3446 * few conditionals later on.
3447 */
3448 cbCopy += cbSkip;
3449
3450 AssertMsgReturn(cPrdtlEntries > 0, ("Copying 0 bytes is not possible\n"), 0);
3451
3452 do
3453 {
3454 SGLEntry aPrdtlEntries[32];
3455 uint32_t cPrdtlEntriesRead = cPrdtlEntries < RT_ELEMENTS(aPrdtlEntries)
3456 ? cPrdtlEntries
3457 : RT_ELEMENTS(aPrdtlEntries);
3458
3459 PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhysPrdtl, &aPrdtlEntries[0],
3460 cPrdtlEntriesRead * sizeof(SGLEntry));
3461
3462 for (uint32_t i = 0; (i < cPrdtlEntriesRead) && cbCopy; i++)
3463 {
3464 RTGCPHYS GCPhysAddrDataBase = AHCI_RTGCPHYS_FROM_U32(aPrdtlEntries[i].u32DBAUp, aPrdtlEntries[i].u32DBA);
3465 uint32_t cbThisCopy = (aPrdtlEntries[i].u32DescInf & SGLENTRY_DESCINF_DBC) + 1;
3466
3467 cbThisCopy = (uint32_t)RT_MIN(cbThisCopy, cbCopy);
3468
3469 /* Copy into SG entry. */
3470 pfnCopyWorker(pThis, GCPhysAddrDataBase, pSgBuf, cbThisCopy, &cbSkip);
3471
3472 cbCopy -= cbThisCopy;
3473 cbCopied += cbThisCopy;
3474 }
3475
3476 GCPhysPrdtl += cPrdtlEntriesRead * sizeof(SGLEntry);
3477 cPrdtlEntries -= cPrdtlEntriesRead;
3478 } while (cPrdtlEntries && cbCopy);
3479
3480 if (cbCopied < cbCopy)
3481 pAhciReq->fFlags |= AHCI_REQ_OVERFLOW;
3482
3483 return cbCopied;
3484}
3485
3486/**
3487 * Copies a data buffer into the S/G buffer set up by the guest.
3488 *
3489 * @returns Amount of bytes copied to the PRDTL.
3490 * @param pThis The AHCI controller device instance.
3491 * @param pAhciReq AHCI request structure.
3492 * @param pSgBuf The S/G buffer to copy from.
3493 * @param cbSkip How many bytes to skip in advance before starting to copy.
3494 * @param cbCopy How many bytes to copy.
3495 */
3496static size_t ahciR3CopySgBufToPrdtl(PAHCI pThis, PAHCIREQ pAhciReq, PRTSGBUF pSgBuf,
3497 size_t cbSkip, size_t cbCopy)
3498{
3499 return ahciR3PrdtlWalk(pThis, pAhciReq, ahciR3CopyBufferToGuestWorker,
3500 pSgBuf, cbSkip, cbCopy);
3501}
3502
3503/**
3504 * Copies the S/G buffer into a data buffer.
3505 *
3506 * @returns Amount of bytes copied from the PRDTL.
3507 * @param pThis The AHCI controller device instance.
3508 * @param pAhciReq AHCI request structure.
3509 * @param pSgBuf The S/G buffer to copy into.
3510 * @param cbSkip How many bytes to skip in advance before starting to copy.
3511 * @param cbCopy How many bytes to copy.
3512 */
3513static size_t ahciR3CopySgBufFromPrdtl(PAHCI pThis, PAHCIREQ pAhciReq, PRTSGBUF pSgBuf,
3514 size_t cbSkip, size_t cbCopy)
3515{
3516 return ahciR3PrdtlWalk(pThis, pAhciReq, ahciR3CopyBufferFromGuestWorker,
3517 pSgBuf, cbSkip, cbCopy);
3518}
3519
3520/**
3521 * Copy a simple memory buffer to the guest memory buffer.
3522 *
3523 * @returns Amount of bytes copied from the PRDTL.
3524 * @param pThis The AHCI controller device instance.
3525 * @param pAhciReq AHCI request structure.
3526 * @param pvSrc The buffer to copy from.
3527 * @param cbSrc How many bytes to copy.
3528 * @param cbSkip How many bytes to skip initially.
3529 */
3530static size_t ahciR3CopyBufferToPrdtl(PAHCI pThis, PAHCIREQ pAhciReq, const void *pvSrc,
3531 size_t cbSrc, size_t cbSkip)
3532{
3533 RTSGSEG Seg;
3534 RTSGBUF SgBuf;
3535 Seg.pvSeg = (void *)pvSrc;
3536 Seg.cbSeg = cbSrc;
3537 RTSgBufInit(&SgBuf, &Seg, 1);
3538 return ahciR3CopySgBufToPrdtl(pThis, pAhciReq, &SgBuf, cbSkip, cbSrc);
3539}
3540
3541/**
3542 * Calculates the size of the guest buffer described by the PRDT.
3543 *
3544 * @returns VBox status code.
3545 * @param pThis The AHCI controller device instance.
3546 * @param pAhciReq AHCI request structure.
3547 * @param pcbPrdt Where to store the size of the guest buffer.
3548 */
3549static int ahciR3PrdtQuerySize(PAHCI pThis, PAHCIREQ pAhciReq, size_t *pcbPrdt)
3550{
3551 RTGCPHYS GCPhysPrdtl = pAhciReq->GCPhysPrdtl;
3552 unsigned cPrdtlEntries = pAhciReq->cPrdtlEntries;
3553 size_t cbPrdt = 0;
3554
3555 do
3556 {
3557 SGLEntry aPrdtlEntries[32];
3558 uint32_t cPrdtlEntriesRead = cPrdtlEntries < RT_ELEMENTS(aPrdtlEntries)
3559 ? cPrdtlEntries
3560 : RT_ELEMENTS(aPrdtlEntries);
3561
3562 PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhysPrdtl, &aPrdtlEntries[0],
3563 cPrdtlEntriesRead * sizeof(SGLEntry));
3564
3565 for (uint32_t i = 0; i < cPrdtlEntriesRead; i++)
3566 cbPrdt += (aPrdtlEntries[i].u32DescInf & SGLENTRY_DESCINF_DBC) + 1;
3567
3568 GCPhysPrdtl += cPrdtlEntriesRead * sizeof(SGLEntry);
3569 cPrdtlEntries -= cPrdtlEntriesRead;
3570 } while (cPrdtlEntries);
3571
3572 *pcbPrdt = cbPrdt;
3573 return VINF_SUCCESS;
3574}
3575
3576/**
3577 * Cancels all active tasks on the port.
3578 *
3579 * @returns Whether all active tasks were canceled.
3580 * @param pAhciPort The AHCI port.
3581 */
3582static bool ahciCancelActiveTasks(PAHCIPort pAhciPort)
3583{
3584 if (pAhciPort->pDrvMediaEx)
3585 {
3586 int rc = pAhciPort->pDrvMediaEx->pfnIoReqCancelAll(pAhciPort->pDrvMediaEx);
3587 AssertRC(rc);
3588 }
3589 return true; /* always true for now because tasks don't use guest memory as the buffer which makes canceling a task impossible. */
3590}
3591
3592/**
3593 * Creates the array of ranges to trim.
3594 *
3595 * @returns VBox status code.
3596 * @param pAhciPort AHCI port state.
3597 * @param pAhciReq The request handling the TRIM request.
3598 * @param idxRangeStart Index of the first range to start copying.
3599 * @param paRanges Where to store the ranges.
3600 * @param cRanges Number of ranges fitting into the array.
3601 * @param pcRanges Where to store the amount of ranges actually copied on success.
3602 */
3603static int ahciTrimRangesCreate(PAHCIPort pAhciPort, PAHCIREQ pAhciReq, uint32_t idxRangeStart,
3604 PRTRANGE paRanges, uint32_t cRanges, uint32_t *pcRanges)
3605{
3606 SGLEntry aPrdtlEntries[32];
3607 uint64_t aRanges[64];
3608 uint32_t cPrdtlEntries = pAhciReq->cPrdtlEntries;
3609 RTGCPHYS GCPhysPrdtl = pAhciReq->GCPhysPrdtl;
3610 PPDMDEVINS pDevIns = pAhciPort->CTX_SUFF(pDevIns);
3611 int rc = VERR_PDM_MEDIAEX_IOBUF_OVERFLOW;
3612 uint32_t idxRange = 0;
3613
3614 LogFlowFunc(("pAhciPort=%#p pAhciReq=%#p\n", pAhciPort, pAhciReq));
3615
3616 AssertMsgReturn(pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_DISCARD, ("This is not a trim request\n"), VERR_INVALID_PARAMETER);
3617
3618 if (!cPrdtlEntries)
3619 pAhciReq->fFlags |= AHCI_REQ_OVERFLOW;
3620
3621 /* Convert the ranges from ATA to our format. */
3622 while ( cPrdtlEntries
3623 && idxRange < cRanges)
3624 {
3625 uint32_t cPrdtlEntriesRead = RT_MIN(cPrdtlEntries, RT_ELEMENTS(aPrdtlEntries));
3626
3627 rc = VINF_SUCCESS;
3628 PDMDevHlpPhysRead(pDevIns, GCPhysPrdtl, &aPrdtlEntries[0], cPrdtlEntriesRead * sizeof(SGLEntry));
3629
3630 for (uint32_t i = 0; i < cPrdtlEntriesRead && idxRange < cRanges; i++)
3631 {
3632 RTGCPHYS GCPhysAddrDataBase = AHCI_RTGCPHYS_FROM_U32(aPrdtlEntries[i].u32DBAUp, aPrdtlEntries[i].u32DBA);
3633 uint32_t cbThisCopy = (aPrdtlEntries[i].u32DescInf & SGLENTRY_DESCINF_DBC) + 1;
3634
3635 cbThisCopy = RT_MIN(cbThisCopy, sizeof(aRanges));
3636
3637 /* Copy into buffer. */
3638 PDMDevHlpPhysRead(pDevIns, GCPhysAddrDataBase, aRanges, cbThisCopy);
3639
3640 for (unsigned idxRangeSrc = 0; idxRangeSrc < RT_ELEMENTS(aRanges) && idxRange < cRanges; idxRangeSrc++)
3641 {
3642 /* Skip range if told to do so. */
3643 if (!idxRangeStart)
3644 {
3645 aRanges[idxRangeSrc] = RT_H2LE_U64(aRanges[idxRangeSrc]);
3646 if (AHCI_RANGE_LENGTH_GET(aRanges[idxRangeSrc]) != 0)
3647 {
3648 paRanges[idxRange].offStart = (aRanges[idxRangeSrc] & AHCI_RANGE_LBA_MASK) * pAhciPort->cbSector;
3649 paRanges[idxRange].cbRange = AHCI_RANGE_LENGTH_GET(aRanges[idxRangeSrc]) * pAhciPort->cbSector;
3650 idxRange++;
3651 }
3652 else
3653 break;
3654 }
3655 else
3656 idxRangeStart--;
3657 }
3658 }
3659
3660 GCPhysPrdtl += cPrdtlEntriesRead * sizeof(SGLEntry);
3661 cPrdtlEntries -= cPrdtlEntriesRead;
3662 }
3663
3664 *pcRanges = idxRange;
3665
3666 LogFlowFunc(("returns rc=%Rrc\n", rc));
3667 return rc;
3668}
3669
3670/**
3671 * Allocates a new AHCI request.
3672 *
3673 * @returns A new AHCI request structure or NULL if out of memory.
3674 * @param pAhciPort The AHCI port.
3675 * @param uTag The tag to assign.
3676 */
3677static PAHCIREQ ahciR3ReqAlloc(PAHCIPort pAhciPort, uint32_t uTag)
3678{
3679 PAHCIREQ pAhciReq = NULL;
3680 PDMMEDIAEXIOREQ hIoReq = NULL;
3681
3682 int rc = pAhciPort->pDrvMediaEx->pfnIoReqAlloc(pAhciPort->pDrvMediaEx, &hIoReq, (void **)&pAhciReq,
3683 uTag, PDMIMEDIAEX_F_SUSPEND_ON_RECOVERABLE_ERR);
3684 if (RT_SUCCESS(rc))
3685 {
3686 pAhciReq->hIoReq = hIoReq;
3687 pAhciReq->fMapped = false;
3688 }
3689 else
3690 pAhciReq = NULL;
3691 return pAhciReq;
3692}
3693
3694/**
3695 * Frees a given AHCI request structure.
3696 *
3697 * @returns nothing.
3698 * @param pAhciPort The AHCI port.
3699 * @param pAhciReq The request to free.
3700 */
3701static void ahciR3ReqFree(PAHCIPort pAhciPort, PAHCIREQ pAhciReq)
3702{
3703 if ( pAhciReq
3704 && !(pAhciReq->fFlags & AHCI_REQ_IS_ON_STACK))
3705 {
3706 int rc = pAhciPort->pDrvMediaEx->pfnIoReqFree(pAhciPort->pDrvMediaEx, pAhciReq->hIoReq);
3707 AssertRC(rc);
3708 }
3709}
3710
3711/**
3712 * Complete a data transfer task by freeing all occupied resources
3713 * and notifying the guest.
3714 *
3715 * @returns Flag whether the given request was canceled inbetween;
3716 *
3717 * @param pAhciPort Pointer to the port where to request completed.
3718 * @param pAhciReq Pointer to the task which finished.
3719 * @param rcReq IPRT status code of the completed request.
3720 */
3721static bool ahciTransferComplete(PAHCIPort pAhciPort, PAHCIREQ pAhciReq, int rcReq)
3722{
3723 bool fCanceled = false;
3724
3725 LogFlowFunc(("pAhciPort=%p pAhciReq=%p rcReq=%d\n",
3726 pAhciPort, pAhciReq, rcReq));
3727
3728 VBOXDD_AHCI_REQ_COMPLETED(pAhciReq, rcReq, pAhciReq->uOffset, pAhciReq->cbTransfer);
3729
3730 if (pAhciReq->fMapped)
3731 PDMDevHlpPhysReleasePageMappingLock(pAhciPort->CTX_SUFF(pAhci)->CTX_SUFF(pDevIns),
3732 &pAhciReq->PgLck);
3733
3734 if (rcReq != VERR_PDM_MEDIAEX_IOREQ_CANCELED)
3735 {
3736 if (pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_READ)
3737 pAhciPort->Led.Actual.s.fReading = 0;
3738 else if (pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_WRITE)
3739 pAhciPort->Led.Actual.s.fWriting = 0;
3740 else if (pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_DISCARD)
3741 pAhciPort->Led.Actual.s.fWriting = 0;
3742 else if (pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_SCSI)
3743 {
3744 pAhciPort->Led.Actual.s.fWriting = 0;
3745 pAhciPort->Led.Actual.s.fReading = 0;
3746 }
3747
3748 if (RT_FAILURE(rcReq))
3749 {
3750 /* Log the error. */
3751 if (pAhciPort->cErrors++ < MAX_LOG_REL_ERRORS)
3752 {
3753 if (pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_FLUSH)
3754 LogRel(("AHCI#%uP%u: Flush returned rc=%Rrc\n",
3755 pAhciPort->CTX_SUFF(pDevIns)->iInstance, pAhciPort->iLUN, rcReq));
3756 else if (pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_DISCARD)
3757 LogRel(("AHCI#%uP%u: Trim returned rc=%Rrc\n",
3758 pAhciPort->CTX_SUFF(pDevIns)->iInstance, pAhciPort->iLUN, rcReq));
3759 else
3760 LogRel(("AHCI#%uP%u: %s at offset %llu (%zu bytes left) returned rc=%Rrc\n",
3761 pAhciPort->CTX_SUFF(pDevIns)->iInstance, pAhciPort->iLUN,
3762 pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_READ
3763 ? "Read"
3764 : "Write",
3765 pAhciReq->uOffset,
3766 pAhciReq->cbTransfer, rcReq));
3767 }
3768
3769 ahciReqSetStatus(pAhciReq, ID_ERR, ATA_STAT_READY | ATA_STAT_ERR);
3770 /*
3771 * We have to duplicate the request here as the underlying I/O
3772 * request will be freed later.
3773 */
3774 PAHCIREQ pReqDup = (PAHCIREQ)RTMemDup(pAhciReq, sizeof(AHCIREQ));
3775 if ( pReqDup
3776 && !ASMAtomicCmpXchgPtr(&pAhciPort->pTaskErr, pReqDup, NULL))
3777 RTMemFree(pReqDup);
3778 }
3779 else
3780 {
3781 /* Status will be set already for non I/O requests. */
3782 if (pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_SCSI)
3783 {
3784 if (pAhciReq->u8ScsiSts == SCSI_STATUS_OK)
3785 {
3786 ahciReqSetStatus(pAhciReq, 0, ATA_STAT_READY | ATA_STAT_SEEK);
3787 pAhciReq->cmdFis[AHCI_CMDFIS_SECTN] = (pAhciReq->cmdFis[AHCI_CMDFIS_SECTN] & ~7)
3788 | ((pAhciReq->fFlags & AHCI_REQ_XFER_2_HOST) ? ATAPI_INT_REASON_IO : 0)
3789 | (!pAhciReq->cbTransfer ? ATAPI_INT_REASON_CD : 0);
3790 }
3791 else
3792 {
3793 ahciReqSetStatus(pAhciReq, pAhciPort->abATAPISense[2] << 4, ATA_STAT_READY | ATA_STAT_ERR);
3794 pAhciReq->cmdFis[AHCI_CMDFIS_SECTN] = (pAhciReq->cmdFis[AHCI_CMDFIS_SECTN] & ~7) |
3795 ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
3796 pAhciReq->cbTransfer = 0;
3797 LogFlowFunc(("SCSI request completed with %u status\n", pAhciReq->u8ScsiSts));
3798 }
3799 }
3800 else if (pAhciReq->enmType != PDMMEDIAEXIOREQTYPE_INVALID)
3801 ahciReqSetStatus(pAhciReq, 0, ATA_STAT_READY | ATA_STAT_SEEK);
3802
3803 /* Write updated command header into memory of the guest. */
3804 uint32_t u32PRDBC = 0;
3805 if (pAhciReq->enmType != PDMMEDIAEXIOREQTYPE_INVALID)
3806 {
3807 size_t cbXfer = 0;
3808 int rc = pAhciPort->pDrvMediaEx->pfnIoReqQueryXferSize(pAhciPort->pDrvMediaEx, pAhciReq->hIoReq, &cbXfer);
3809 AssertRC(rc);
3810 u32PRDBC = (uint32_t)RT_MIN(cbXfer, pAhciReq->cbTransfer);
3811 }
3812 else
3813 u32PRDBC = (uint32_t)pAhciReq->cbTransfer;
3814
3815 PDMDevHlpPCIPhysWrite(pAhciPort->CTX_SUFF(pDevIns), pAhciReq->GCPhysCmdHdrAddr + RT_UOFFSETOF(CmdHdr, u32PRDBC),
3816 &u32PRDBC, sizeof(u32PRDBC));
3817
3818 if (pAhciReq->fFlags & AHCI_REQ_OVERFLOW)
3819 {
3820 /*
3821 * The guest tried to transfer more data than there is space in the buffer.
3822 * Terminate task and set the overflow bit.
3823 */
3824 /* Notify the guest. */
3825 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_OFS);
3826 if (pAhciPort->regIE & AHCI_PORT_IE_OFE)
3827 ahciHbaSetInterrupt(pAhciPort->CTX_SUFF(pAhci), pAhciPort->iLUN, VERR_IGNORED);
3828 }
3829 }
3830
3831 /*
3832 * Make a copy of the required data now and free the request. Otherwise the guest
3833 * might issue a new request with the same tag and we run into a conflict when allocating
3834 * a new request with the same tag later on.
3835 */
3836 uint32_t fFlags = pAhciReq->fFlags;
3837 uint32_t uTag = pAhciReq->uTag;
3838 size_t cbTransfer = pAhciReq->cbTransfer;
3839 bool fRead = pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_READ;
3840 uint8_t cmdFis[AHCI_CMDFIS_TYPE_H2D_SIZE];
3841 memcpy(&cmdFis[0], &pAhciReq->cmdFis[0], sizeof(cmdFis));
3842
3843 ahciR3ReqFree(pAhciPort, pAhciReq);
3844
3845 /* Post a PIO setup FIS first if this is a PIO command which transfers data. */
3846 if (fFlags & AHCI_REQ_PIO_DATA)
3847 ahciSendPioSetupFis(pAhciPort, cbTransfer, &cmdFis[0], fRead, false /* fInterrupt */);
3848
3849 if (fFlags & AHCI_REQ_CLEAR_SACT)
3850 {
3851 if (RT_SUCCESS(rcReq) && !ASMAtomicReadPtrT(&pAhciPort->pTaskErr, PAHCIREQ))
3852 ASMAtomicOrU32(&pAhciPort->u32QueuedTasksFinished, RT_BIT_32(uTag));
3853 }
3854
3855 if (fFlags & AHCI_REQ_IS_QUEUED)
3856 {
3857 /*
3858 * Always raise an interrupt after task completion; delaying
3859 * this (interrupt coalescing) increases latency and has a significant
3860 * impact on performance (see @bugref{5071})
3861 */
3862 ahciSendSDBFis(pAhciPort, 0, true);
3863 }
3864 else
3865 ahciSendD2HFis(pAhciPort, uTag, &cmdFis[0], true);
3866 }
3867 else
3868 {
3869 /*
3870 * Task was canceled, do the cleanup but DO NOT access the guest memory!
3871 * The guest might use it for other things now because it doesn't know about that task anymore.
3872 */
3873 fCanceled = true;
3874
3875 /* Leave a log message about the canceled request. */
3876 if (pAhciPort->cErrors++ < MAX_LOG_REL_ERRORS)
3877 {
3878 if (pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_FLUSH)
3879 LogRel(("AHCI#%uP%u: Canceled flush returned rc=%Rrc\n",
3880 pAhciPort->CTX_SUFF(pDevIns)->iInstance, pAhciPort->iLUN, rcReq));
3881 else if (pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_DISCARD)
3882 LogRel(("AHCI#%uP%u: Canceled trim returned rc=%Rrc\n",
3883 pAhciPort->CTX_SUFF(pDevIns)->iInstance,pAhciPort->iLUN, rcReq));
3884 else
3885 LogRel(("AHCI#%uP%u: Canceled %s at offset %llu (%zu bytes left) returned rc=%Rrc\n",
3886 pAhciPort->CTX_SUFF(pDevIns)->iInstance, pAhciPort->iLUN,
3887 pAhciReq->enmType == PDMMEDIAEXIOREQTYPE_READ
3888 ? "read"
3889 : "write",
3890 pAhciReq->uOffset,
3891 pAhciReq->cbTransfer, rcReq));
3892 }
3893
3894 ahciR3ReqFree(pAhciPort, pAhciReq);
3895 }
3896
3897 /*
3898 * Decrement the active task counter as the last step or we might run into a
3899 * hang during power off otherwise (see @bugref{7859}).
3900 * Before it could happen that we signal PDM that we are done while we still have to
3901 * copy the data to the guest but EMT might be busy destroying the driver chains
3902 * below us while we have to delegate copying data to EMT instead of doing it
3903 * on this thread.
3904 */
3905 ASMAtomicDecU32(&pAhciPort->cTasksActive);
3906
3907 if (pAhciPort->cTasksActive == 0 && pAhciPort->pAhciR3->fSignalIdle)
3908 PDMDevHlpAsyncNotificationCompleted(pAhciPort->pDevInsR3);
3909
3910 return fCanceled;
3911}
3912
3913/**
3914 * @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyFromBuf}
3915 */
3916static DECLCALLBACK(int) ahciR3IoReqCopyFromBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
3917 void *pvIoReqAlloc, uint32_t offDst, PRTSGBUF pSgBuf,
3918 size_t cbCopy)
3919{
3920 RT_NOREF1(hIoReq);
3921 PAHCIPort pAhciPort = RT_FROM_MEMBER(pInterface, AHCIPort, IMediaExPort);
3922 int rc = VINF_SUCCESS;
3923 PAHCIREQ pIoReq = (PAHCIREQ)pvIoReqAlloc;
3924
3925 ahciR3CopySgBufToPrdtl(pAhciPort->CTX_SUFF(pAhci), pIoReq, pSgBuf, offDst, cbCopy);
3926
3927 if (pIoReq->fFlags & AHCI_REQ_OVERFLOW)
3928 rc = VERR_PDM_MEDIAEX_IOBUF_OVERFLOW;
3929
3930 return rc;
3931}
3932
3933/**
3934 * @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyToBuf}
3935 */
3936static DECLCALLBACK(int) ahciR3IoReqCopyToBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
3937 void *pvIoReqAlloc, uint32_t offSrc, PRTSGBUF pSgBuf,
3938 size_t cbCopy)
3939{
3940 RT_NOREF1(hIoReq);
3941 PAHCIPort pAhciPort = RT_FROM_MEMBER(pInterface, AHCIPort, IMediaExPort);
3942 int rc = VINF_SUCCESS;
3943 PAHCIREQ pIoReq = (PAHCIREQ)pvIoReqAlloc;
3944
3945 ahciR3CopySgBufFromPrdtl(pAhciPort->CTX_SUFF(pAhci), pIoReq, pSgBuf, offSrc, cbCopy);
3946 if (pIoReq->fFlags & AHCI_REQ_OVERFLOW)
3947 rc = VERR_PDM_MEDIAEX_IOBUF_UNDERRUN;
3948
3949 return rc;
3950}
3951
3952/**
3953 * @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqQueryBuf}
3954 */
3955static DECLCALLBACK(int) ahciR3IoReqQueryBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
3956 void *pvIoReqAlloc, void **ppvBuf, size_t *pcbBuf)
3957{
3958 RT_NOREF(hIoReq);
3959 int rc = VERR_NOT_SUPPORTED;
3960 PAHCIPort pAhciPort = RT_FROM_MEMBER(pInterface, AHCIPort, IMediaExPort);
3961 PAHCIREQ pIoReq = (PAHCIREQ)pvIoReqAlloc;
3962 PAHCI pThis = pAhciPort->CTX_SUFF(pAhci);
3963
3964 /* Only allow single 4KB page aligned buffers at the moment. */
3965 if ( pIoReq->cPrdtlEntries == 1
3966 && pIoReq->cbTransfer == _4K)
3967 {
3968 RTGCPHYS GCPhysPrdt = pIoReq->GCPhysPrdtl;
3969 SGLEntry PrdtEntry;
3970
3971 PDMDevHlpPhysRead(pThis->pDevInsR3, GCPhysPrdt, &PrdtEntry, sizeof(SGLEntry));
3972
3973 RTGCPHYS GCPhysAddrDataBase = AHCI_RTGCPHYS_FROM_U32(PrdtEntry.u32DBAUp, PrdtEntry.u32DBA);
3974 uint32_t cbData = (PrdtEntry.u32DescInf & SGLENTRY_DESCINF_DBC) + 1;
3975
3976 if ( cbData >= _4K
3977 && !(GCPhysAddrDataBase & (_4K - 1)))
3978 {
3979 rc = PDMDevHlpPhysGCPhys2CCPtr(pThis->pDevInsR3, GCPhysAddrDataBase,
3980 0, ppvBuf, &pIoReq->PgLck);
3981 if (RT_SUCCESS(rc))
3982 {
3983 pIoReq->fMapped = true;
3984 *pcbBuf = cbData;
3985 }
3986 else
3987 rc = VERR_NOT_SUPPORTED;
3988 }
3989 }
3990
3991 return rc;
3992}
3993
3994/**
3995 * @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqQueryDiscardRanges}
3996 */
3997static DECLCALLBACK(int) ahciR3IoReqQueryDiscardRanges(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
3998 void *pvIoReqAlloc, uint32_t idxRangeStart,
3999 uint32_t cRanges, PRTRANGE paRanges,
4000 uint32_t *pcRanges)
4001{
4002 RT_NOREF1(hIoReq);
4003 PAHCIPort pAhciPort = RT_FROM_MEMBER(pInterface, AHCIPort, IMediaExPort);
4004 PAHCIREQ pIoReq = (PAHCIREQ)pvIoReqAlloc;
4005
4006 return ahciTrimRangesCreate(pAhciPort, pIoReq, idxRangeStart, paRanges, cRanges, pcRanges);
4007}
4008
4009/**
4010 * @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCompleteNotify}
4011 */
4012static DECLCALLBACK(int) ahciR3IoReqCompleteNotify(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
4013 void *pvIoReqAlloc, int rcReq)
4014{
4015 RT_NOREF(hIoReq);
4016 PAHCIPort pAhciPort = RT_FROM_MEMBER(pInterface, AHCIPort, IMediaExPort);
4017 ahciTransferComplete(pAhciPort, (PAHCIREQ)pvIoReqAlloc, rcReq);
4018 return VINF_SUCCESS;
4019}
4020
4021/**
4022 * @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqStateChanged}
4023 */
4024static DECLCALLBACK(void) ahciR3IoReqStateChanged(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
4025 void *pvIoReqAlloc, PDMMEDIAEXIOREQSTATE enmState)
4026{
4027 RT_NOREF2(hIoReq, pvIoReqAlloc);
4028 PAHCIPort pAhciPort = RT_FROM_MEMBER(pInterface, AHCIPort, IMediaExPort);
4029
4030 switch (enmState)
4031 {
4032 case PDMMEDIAEXIOREQSTATE_SUSPENDED:
4033 {
4034 /* Make sure the request is not accounted for so the VM can suspend successfully. */
4035 uint32_t cTasksActive = ASMAtomicDecU32(&pAhciPort->cTasksActive);
4036 if (!cTasksActive && pAhciPort->pAhciR3->fSignalIdle)
4037 PDMDevHlpAsyncNotificationCompleted(pAhciPort->pDevInsR3);
4038 break;
4039 }
4040 case PDMMEDIAEXIOREQSTATE_ACTIVE:
4041 /* Make sure the request is accounted for so the VM suspends only when the request is complete. */
4042 ASMAtomicIncU32(&pAhciPort->cTasksActive);
4043 break;
4044 default:
4045 AssertMsgFailed(("Invalid request state given %u\n", enmState));
4046 }
4047}
4048
4049/**
4050 * @interface_method_impl{PDMIMEDIAEXPORT,pfnMediumEjected}
4051 */
4052static DECLCALLBACK(void) ahciR3MediumEjected(PPDMIMEDIAEXPORT pInterface)
4053{
4054 PAHCIPort pAhciPort = RT_FROM_MEMBER(pInterface, AHCIPort, IMediaExPort);
4055 PAHCI pThis = pAhciPort->CTX_SUFF(pAhci);
4056
4057 if (pThis->pMediaNotify)
4058 {
4059 int rc = VMR3ReqCallNoWait(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), VMCPUID_ANY,
4060 (PFNRT)pThis->pMediaNotify->pfnEjected, 2,
4061 pThis->pMediaNotify, pAhciPort->iLUN);
4062 AssertRC(rc);
4063 }
4064}
4065
4066/**
4067 * Process an non read/write ATA command.
4068 *
4069 * @returns The direction of the data transfer
4070 * @param pAhciPort The AHCI port of the request.
4071 * @param pAhciReq The AHCI request state.
4072 * @param pCmdFis Pointer to the command FIS.
4073 */
4074static PDMMEDIAEXIOREQTYPE ahciProcessCmd(PAHCIPort pAhciPort, PAHCIREQ pAhciReq, uint8_t *pCmdFis)
4075{
4076 PDMMEDIAEXIOREQTYPE enmType = PDMMEDIAEXIOREQTYPE_INVALID;
4077 bool fLBA48 = false;
4078
4079 AssertMsg(pCmdFis[AHCI_CMDFIS_TYPE] == AHCI_CMDFIS_TYPE_H2D, ("FIS is not a host to device Fis!!\n"));
4080
4081 pAhciReq->cbTransfer = 0;
4082
4083 switch (pCmdFis[AHCI_CMDFIS_CMD])
4084 {
4085 case ATA_IDENTIFY_DEVICE:
4086 {
4087 if (pAhciPort->pDrvMedia && !pAhciPort->fATAPI)
4088 {
4089 uint16_t u16Temp[256];
4090
4091 /* Fill the buffer. */
4092 ahciIdentifySS(pAhciPort, u16Temp);
4093
4094 /* Copy the buffer. */
4095 size_t cbCopied = ahciR3CopyBufferToPrdtl(pAhciPort->CTX_SUFF(pAhci), pAhciReq,
4096 &u16Temp[0], sizeof(u16Temp), 0 /* cbSkip */);
4097
4098 pAhciReq->fFlags |= AHCI_REQ_PIO_DATA;
4099 pAhciReq->cbTransfer = cbCopied;
4100 ahciReqSetStatus(pAhciReq, 0, ATA_STAT_READY | ATA_STAT_SEEK);
4101 }
4102 else
4103 ahciReqSetStatus(pAhciReq, ABRT_ERR, ATA_STAT_READY | ATA_STAT_SEEK | ATA_STAT_ERR);
4104 break;
4105 }
4106 case ATA_READ_NATIVE_MAX_ADDRESS_EXT:
4107 case ATA_READ_NATIVE_MAX_ADDRESS:
4108 break;
4109 case ATA_SET_FEATURES:
4110 {
4111 switch (pCmdFis[AHCI_CMDFIS_FET])
4112 {
4113 case 0x02: /* write cache enable */
4114 case 0xaa: /* read look-ahead enable */
4115 case 0x55: /* read look-ahead disable */
4116 case 0xcc: /* reverting to power-on defaults enable */
4117 case 0x66: /* reverting to power-on defaults disable */
4118 ahciReqSetStatus(pAhciReq, 0, ATA_STAT_READY | ATA_STAT_SEEK);
4119 break;
4120 case 0x82: /* write cache disable */
4121 enmType = PDMMEDIAEXIOREQTYPE_FLUSH;
4122 break;
4123 case 0x03:
4124 {
4125 /* set transfer mode */
4126 Log2(("%s: transfer mode %#04x\n", __FUNCTION__, pCmdFis[AHCI_CMDFIS_SECTC]));
4127 switch (pCmdFis[AHCI_CMDFIS_SECTC] & 0xf8)
4128 {
4129 case 0x00: /* PIO default */
4130 case 0x08: /* PIO mode */
4131 break;
4132 case ATA_MODE_MDMA: /* MDMA mode */
4133 pAhciPort->uATATransferMode = (pCmdFis[AHCI_CMDFIS_SECTC] & 0xf8) | RT_MIN(pCmdFis[AHCI_CMDFIS_SECTC] & 0x07, ATA_MDMA_MODE_MAX);
4134 break;
4135 case ATA_MODE_UDMA: /* UDMA mode */
4136 pAhciPort->uATATransferMode = (pCmdFis[AHCI_CMDFIS_SECTC] & 0xf8) | RT_MIN(pCmdFis[AHCI_CMDFIS_SECTC] & 0x07, ATA_UDMA_MODE_MAX);
4137 break;
4138 }
4139 ahciReqSetStatus(pAhciReq, 0, ATA_STAT_READY | ATA_STAT_SEEK);
4140 break;
4141 }
4142 default:
4143 ahciReqSetStatus(pAhciReq, ABRT_ERR, ATA_STAT_READY | ATA_STAT_ERR);
4144 }
4145 break;
4146 }
4147 case ATA_DEVICE_RESET:
4148 {
4149 if (!pAhciPort->fATAPI)
4150 ahciReqSetStatus(pAhciReq, ABRT_ERR, ATA_STAT_READY | ATA_STAT_ERR);
4151 else
4152 {
4153 /* Reset the device. */
4154 ahciDeviceReset(pAhciPort, pAhciReq);
4155 }
4156 break;
4157 }
4158 case ATA_FLUSH_CACHE_EXT:
4159 case ATA_FLUSH_CACHE:
4160 enmType = PDMMEDIAEXIOREQTYPE_FLUSH;
4161 break;
4162 case ATA_PACKET:
4163 if (!pAhciPort->fATAPI)
4164 ahciReqSetStatus(pAhciReq, ABRT_ERR, ATA_STAT_READY | ATA_STAT_ERR);
4165 else
4166 enmType = PDMMEDIAEXIOREQTYPE_SCSI;
4167 break;
4168 case ATA_IDENTIFY_PACKET_DEVICE:
4169 if (!pAhciPort->fATAPI)
4170 ahciReqSetStatus(pAhciReq, ABRT_ERR, ATA_STAT_READY | ATA_STAT_ERR);
4171 else
4172 {
4173 size_t cbData;
4174 ahciR3AtapiIdentify(pAhciReq, pAhciPort, 512, &cbData);
4175
4176 pAhciReq->fFlags |= AHCI_REQ_PIO_DATA;
4177 pAhciReq->cbTransfer = cbData;
4178 pAhciReq->cmdFis[AHCI_CMDFIS_SECTN] = (pAhciReq->cmdFis[AHCI_CMDFIS_SECTN] & ~7)
4179 | ((pAhciReq->fFlags & AHCI_REQ_XFER_2_HOST) ? ATAPI_INT_REASON_IO : 0)
4180 | (!pAhciReq->cbTransfer ? ATAPI_INT_REASON_CD : 0);
4181
4182 ahciReqSetStatus(pAhciReq, 0, ATA_STAT_READY | ATA_STAT_SEEK);
4183 }
4184 break;
4185 case ATA_SET_MULTIPLE_MODE:
4186 if ( pCmdFis[AHCI_CMDFIS_SECTC] != 0
4187 && ( pCmdFis[AHCI_CMDFIS_SECTC] > ATA_MAX_MULT_SECTORS
4188 || (pCmdFis[AHCI_CMDFIS_SECTC] & (pCmdFis[AHCI_CMDFIS_SECTC] - 1)) != 0))
4189 ahciReqSetStatus(pAhciReq, ABRT_ERR, ATA_STAT_READY | ATA_STAT_ERR);
4190 else
4191 {
4192 Log2(("%s: set multi sector count to %d\n", __FUNCTION__, pCmdFis[AHCI_CMDFIS_SECTC]));
4193 pAhciPort->cMultSectors = pCmdFis[AHCI_CMDFIS_SECTC];
4194 ahciReqSetStatus(pAhciReq, 0, ATA_STAT_READY | ATA_STAT_SEEK);
4195 }
4196 break;
4197 case ATA_STANDBY_IMMEDIATE:
4198 break; /* Do nothing. */
4199 case ATA_CHECK_POWER_MODE:
4200 pAhciReq->cmdFis[AHCI_CMDFIS_SECTC] = 0xff; /* drive active or idle */
4201 RT_FALL_THRU();
4202 case ATA_INITIALIZE_DEVICE_PARAMETERS:
4203 case ATA_IDLE_IMMEDIATE:
4204 case ATA_RECALIBRATE:
4205 case ATA_NOP:
4206 case ATA_READ_VERIFY_SECTORS_EXT:
4207 case ATA_READ_VERIFY_SECTORS:
4208 case ATA_READ_VERIFY_SECTORS_WITHOUT_RETRIES:
4209 case ATA_SLEEP:
4210 ahciReqSetStatus(pAhciReq, 0, ATA_STAT_READY | ATA_STAT_SEEK);
4211 break;
4212 case ATA_READ_DMA_EXT:
4213 fLBA48 = true;
4214 RT_FALL_THRU();
4215 case ATA_READ_DMA:
4216 {
4217 pAhciReq->cbTransfer = ahciGetNSectors(pCmdFis, fLBA48) * pAhciPort->cbSector;
4218 pAhciReq->uOffset = ahciGetSector(pAhciPort, pCmdFis, fLBA48) * pAhciPort->cbSector;
4219 enmType = PDMMEDIAEXIOREQTYPE_READ;
4220 break;
4221 }
4222 case ATA_WRITE_DMA_EXT:
4223 fLBA48 = true;
4224 RT_FALL_THRU();
4225 case ATA_WRITE_DMA:
4226 {
4227 pAhciReq->cbTransfer = ahciGetNSectors(pCmdFis, fLBA48) * pAhciPort->cbSector;
4228 pAhciReq->uOffset = ahciGetSector(pAhciPort, pCmdFis, fLBA48) * pAhciPort->cbSector;
4229 enmType = PDMMEDIAEXIOREQTYPE_WRITE;
4230 break;
4231 }
4232 case ATA_READ_FPDMA_QUEUED:
4233 {
4234 pAhciReq->cbTransfer = ahciGetNSectorsQueued(pCmdFis) * pAhciPort->cbSector;
4235 pAhciReq->uOffset = ahciGetSectorQueued(pCmdFis) * pAhciPort->cbSector;
4236 pAhciReq->fFlags |= AHCI_REQ_IS_QUEUED;
4237 enmType = PDMMEDIAEXIOREQTYPE_READ;
4238 break;
4239 }
4240 case ATA_WRITE_FPDMA_QUEUED:
4241 {
4242 pAhciReq->cbTransfer = ahciGetNSectorsQueued(pCmdFis) * pAhciPort->cbSector;
4243 pAhciReq->uOffset = ahciGetSectorQueued(pCmdFis) * pAhciPort->cbSector;
4244 pAhciReq->fFlags |= AHCI_REQ_IS_QUEUED;
4245 enmType = PDMMEDIAEXIOREQTYPE_WRITE;
4246 break;
4247 }
4248 case ATA_READ_LOG_EXT:
4249 {
4250 size_t cbLogRead = ((pCmdFis[AHCI_CMDFIS_SECTCEXP] << 8) | pCmdFis[AHCI_CMDFIS_SECTC]) * 512;
4251 unsigned offLogRead = ((pCmdFis[AHCI_CMDFIS_CYLLEXP] << 8) | pCmdFis[AHCI_CMDFIS_CYLL]) * 512;
4252 unsigned iPage = pCmdFis[AHCI_CMDFIS_SECTN];
4253
4254 LogFlow(("Trying to read %zu bytes starting at offset %u from page %u\n", cbLogRead, offLogRead, iPage));
4255
4256 uint8_t aBuf[512];
4257
4258 memset(aBuf, 0, sizeof(aBuf));
4259
4260 if (offLogRead + cbLogRead <= sizeof(aBuf))
4261 {
4262 switch (iPage)
4263 {
4264 case 0x10:
4265 {
4266 LogFlow(("Reading error page\n"));
4267 PAHCIREQ pTaskErr = ASMAtomicXchgPtrT(&pAhciPort->pTaskErr, NULL, PAHCIREQ);
4268 if (pTaskErr)
4269 {
4270 aBuf[0] = (pTaskErr->fFlags & AHCI_REQ_IS_QUEUED) ? pTaskErr->uTag : (1 << 7);
4271 aBuf[2] = pTaskErr->cmdFis[AHCI_CMDFIS_STS];
4272 aBuf[3] = pTaskErr->cmdFis[AHCI_CMDFIS_ERR];
4273 aBuf[4] = pTaskErr->cmdFis[AHCI_CMDFIS_SECTN];
4274 aBuf[5] = pTaskErr->cmdFis[AHCI_CMDFIS_CYLL];
4275 aBuf[6] = pTaskErr->cmdFis[AHCI_CMDFIS_CYLH];
4276 aBuf[7] = pTaskErr->cmdFis[AHCI_CMDFIS_HEAD];
4277 aBuf[8] = pTaskErr->cmdFis[AHCI_CMDFIS_SECTNEXP];
4278 aBuf[9] = pTaskErr->cmdFis[AHCI_CMDFIS_CYLLEXP];
4279 aBuf[10] = pTaskErr->cmdFis[AHCI_CMDFIS_CYLHEXP];
4280 aBuf[12] = pTaskErr->cmdFis[AHCI_CMDFIS_SECTC];
4281 aBuf[13] = pTaskErr->cmdFis[AHCI_CMDFIS_SECTCEXP];
4282
4283 /* Calculate checksum */
4284 uint8_t uChkSum = 0;
4285 for (unsigned i = 0; i < RT_ELEMENTS(aBuf)-1; i++)
4286 uChkSum += aBuf[i];
4287
4288 aBuf[511] = (uint8_t)-(int8_t)uChkSum;
4289
4290 /* Finally free the error task state structure because it is completely unused now. */
4291 RTMemFree(pTaskErr);
4292 }
4293
4294 /*
4295 * Reading this log page results in an abort of all outstanding commands
4296 * and clearing the SActive register and TaskFile register.
4297 *
4298 * See SATA2 1.2 spec chapter 4.2.3.4
4299 */
4300 bool fAbortedAll = ahciCancelActiveTasks(pAhciPort);
4301 Assert(fAbortedAll); NOREF(fAbortedAll);
4302 ahciSendSDBFis(pAhciPort, 0xffffffff, true);
4303
4304 break;
4305 }
4306 }
4307
4308 /* Copy the buffer. */
4309 size_t cbCopied = ahciR3CopyBufferToPrdtl(pAhciPort->CTX_SUFF(pAhci), pAhciReq,
4310 &aBuf[offLogRead], cbLogRead, 0 /* cbSkip */);
4311
4312 pAhciReq->fFlags |= AHCI_REQ_PIO_DATA;
4313 pAhciReq->cbTransfer = cbCopied;
4314 }
4315
4316 break;
4317 }
4318 case ATA_DATA_SET_MANAGEMENT:
4319 {
4320 if (pAhciPort->fTrimEnabled)
4321 {
4322 /* Check that the trim bit is set and all other bits are 0. */
4323 if ( !(pAhciReq->cmdFis[AHCI_CMDFIS_FET] & UINT16_C(0x01))
4324 || (pAhciReq->cmdFis[AHCI_CMDFIS_FET] & ~UINT16_C(0x1)))
4325 ahciReqSetStatus(pAhciReq, ABRT_ERR, ATA_STAT_READY | ATA_STAT_ERR);
4326 else
4327 enmType = PDMMEDIAEXIOREQTYPE_DISCARD;
4328 break;
4329 }
4330 /* else: fall through and report error to the guest. */
4331 }
4332 RT_FALL_THRU();
4333 /* All not implemented commands go below. */
4334 case ATA_SECURITY_FREEZE_LOCK:
4335 case ATA_SMART:
4336 case ATA_NV_CACHE:
4337 case ATA_IDLE:
4338 case ATA_TRUSTED_RECEIVE_DMA: /* Windows 8+ */
4339 ahciReqSetStatus(pAhciReq, ABRT_ERR, ATA_STAT_READY | ATA_STAT_ERR);
4340 break;
4341 default: /* For debugging purposes. */
4342 AssertMsgFailed(("Unknown command issued (%#x)\n", pCmdFis[AHCI_CMDFIS_CMD]));
4343 ahciReqSetStatus(pAhciReq, ABRT_ERR, ATA_STAT_READY | ATA_STAT_ERR);
4344 }
4345
4346 return enmType;
4347}
4348
4349/**
4350 * Retrieve a command FIS from guest memory.
4351 *
4352 * @returns whether the H2D FIS was successfully read from the guest memory.
4353 * @param pAhciPort The AHCI port of the request.
4354 * @param pAhciReq The state of the actual task.
4355 */
4356static bool ahciPortTaskGetCommandFis(PAHCIPort pAhciPort, PAHCIREQ pAhciReq)
4357{
4358 AssertMsgReturn(pAhciPort->GCPhysAddrClb && pAhciPort->GCPhysAddrFb,
4359 ("%s: GCPhysAddrClb and/or GCPhysAddrFb are 0\n", __FUNCTION__),
4360 false);
4361
4362 /*
4363 * First we are reading the command header pointed to by regCLB.
4364 * From this we get the address of the command table which we are reading too.
4365 * We can process the Command FIS afterwards.
4366 */
4367 CmdHdr cmdHdr;
4368 pAhciReq->GCPhysCmdHdrAddr = pAhciPort->GCPhysAddrClb + pAhciReq->uTag * sizeof(CmdHdr);
4369 LogFlow(("%s: PDMDevHlpPhysRead GCPhysAddrCmdLst=%RGp cbCmdHdr=%u\n", __FUNCTION__,
4370 pAhciReq->GCPhysCmdHdrAddr, sizeof(CmdHdr)));
4371 PDMDevHlpPhysRead(pAhciPort->CTX_SUFF(pDevIns), pAhciReq->GCPhysCmdHdrAddr, &cmdHdr, sizeof(CmdHdr));
4372
4373#ifdef LOG_ENABLED
4374 /* Print some infos about the command header. */
4375 ahciDumpCmdHdrInfo(pAhciPort, &cmdHdr);
4376#endif
4377
4378 RTGCPHYS GCPhysAddrCmdTbl = AHCI_RTGCPHYS_FROM_U32(cmdHdr.u32CmdTblAddrUp, cmdHdr.u32CmdTblAddr);
4379
4380 AssertMsgReturn((cmdHdr.u32DescInf & AHCI_CMDHDR_CFL_MASK) * sizeof(uint32_t) == AHCI_CMDFIS_TYPE_H2D_SIZE,
4381 ("This is not a command FIS!!\n"),
4382 false);
4383
4384 /* Read the command Fis. */
4385 LogFlow(("%s: PDMDevHlpPhysRead GCPhysAddrCmdTbl=%RGp cbCmdFis=%u\n", __FUNCTION__, GCPhysAddrCmdTbl, AHCI_CMDFIS_TYPE_H2D_SIZE));
4386 PDMDevHlpPhysRead(pAhciPort->CTX_SUFF(pDevIns), GCPhysAddrCmdTbl, &pAhciReq->cmdFis[0], AHCI_CMDFIS_TYPE_H2D_SIZE);
4387
4388 AssertMsgReturn(pAhciReq->cmdFis[AHCI_CMDFIS_TYPE] == AHCI_CMDFIS_TYPE_H2D,
4389 ("This is not a command FIS\n"),
4390 false);
4391
4392 /* Set transfer direction. */
4393 pAhciReq->fFlags |= (cmdHdr.u32DescInf & AHCI_CMDHDR_W) ? 0 : AHCI_REQ_XFER_2_HOST;
4394
4395 /* If this is an ATAPI command read the atapi command. */
4396 if (cmdHdr.u32DescInf & AHCI_CMDHDR_A)
4397 {
4398 GCPhysAddrCmdTbl += AHCI_CMDHDR_ACMD_OFFSET;
4399 PDMDevHlpPhysRead(pAhciPort->CTX_SUFF(pDevIns), GCPhysAddrCmdTbl, &pAhciReq->aATAPICmd[0], ATAPI_PACKET_SIZE);
4400 }
4401
4402 /* We "received" the FIS. Clear the BSY bit in regTFD. */
4403 if ((cmdHdr.u32DescInf & AHCI_CMDHDR_C) && (pAhciReq->fFlags & AHCI_REQ_CLEAR_SACT))
4404 {
4405 /*
4406 * We need to send a FIS which clears the busy bit if this is a queued command so that the guest can queue other commands.
4407 * but this FIS does not assert an interrupt
4408 */
4409 ahciSendD2HFis(pAhciPort, pAhciReq->uTag, pAhciReq->cmdFis, false);
4410 pAhciPort->regTFD &= ~AHCI_PORT_TFD_BSY;
4411 }
4412
4413 pAhciReq->GCPhysPrdtl = AHCI_RTGCPHYS_FROM_U32(cmdHdr.u32CmdTblAddrUp, cmdHdr.u32CmdTblAddr) + AHCI_CMDHDR_PRDT_OFFSET;
4414 pAhciReq->cPrdtlEntries = AHCI_CMDHDR_PRDTL_ENTRIES(cmdHdr.u32DescInf);
4415
4416#ifdef LOG_ENABLED
4417 /* Print some infos about the FIS. */
4418 ahciDumpFisInfo(pAhciPort, &pAhciReq->cmdFis[0]);
4419
4420 /* Print the PRDT */
4421 ahciLog(("PRDT address %RGp number of entries %u\n", pAhciReq->GCPhysPrdtl, pAhciReq->cPrdtlEntries));
4422 RTGCPHYS GCPhysPrdtl = pAhciReq->GCPhysPrdtl;
4423
4424 for (unsigned i = 0; i < pAhciReq->cPrdtlEntries; i++)
4425 {
4426 SGLEntry SGEntry;
4427
4428 ahciLog(("Entry %u at address %RGp\n", i, GCPhysPrdtl));
4429 PDMDevHlpPhysRead(pAhciPort->CTX_SUFF(pDevIns), GCPhysPrdtl, &SGEntry, sizeof(SGLEntry));
4430
4431 RTGCPHYS GCPhysDataAddr = AHCI_RTGCPHYS_FROM_U32(SGEntry.u32DBAUp, SGEntry.u32DBA);
4432 ahciLog(("GCPhysAddr=%RGp Size=%u\n", GCPhysDataAddr, SGEntry.u32DescInf & SGLENTRY_DESCINF_DBC));
4433
4434 GCPhysPrdtl += sizeof(SGLEntry);
4435 }
4436#endif
4437
4438 return true;
4439}
4440
4441/**
4442 * Submits a given request for execution.
4443 *
4444 * @returns Flag whether the request was canceled inbetween.
4445 * @param pAhciPort The port the request is for.
4446 * @param pAhciReq The request to submit.
4447 * @param enmType The request type.
4448 */
4449static bool ahciR3ReqSubmit(PAHCIPort pAhciPort, PAHCIREQ pAhciReq, PDMMEDIAEXIOREQTYPE enmType)
4450{
4451 int rc = VINF_SUCCESS;
4452 bool fReqCanceled = false;
4453
4454 VBOXDD_AHCI_REQ_SUBMIT(pAhciReq, pAhciReq->enmType, pAhciReq->uOffset, pAhciReq->cbTransfer);
4455
4456 if (enmType == PDMMEDIAEXIOREQTYPE_FLUSH)
4457 rc = pAhciPort->pDrvMediaEx->pfnIoReqFlush(pAhciPort->pDrvMediaEx, pAhciReq->hIoReq);
4458 else if (enmType == PDMMEDIAEXIOREQTYPE_DISCARD)
4459 {
4460 uint32_t cRangesMax;
4461
4462 /* The data buffer contains LBA range entries. Each range is 8 bytes big. */
4463 if (!pAhciReq->cmdFis[AHCI_CMDFIS_SECTC] && !pAhciReq->cmdFis[AHCI_CMDFIS_SECTCEXP])
4464 cRangesMax = 65536 * 512 / 8;
4465 else
4466 cRangesMax = pAhciReq->cmdFis[AHCI_CMDFIS_SECTC] * 512 / 8;
4467
4468 pAhciPort->Led.Asserted.s.fWriting = pAhciPort->Led.Actual.s.fWriting = 1;
4469 rc = pAhciPort->pDrvMediaEx->pfnIoReqDiscard(pAhciPort->pDrvMediaEx, pAhciReq->hIoReq,
4470 cRangesMax);
4471 }
4472 else if (enmType == PDMMEDIAEXIOREQTYPE_READ)
4473 {
4474 pAhciPort->Led.Asserted.s.fReading = pAhciPort->Led.Actual.s.fReading = 1;
4475 rc = pAhciPort->pDrvMediaEx->pfnIoReqRead(pAhciPort->pDrvMediaEx, pAhciReq->hIoReq,
4476 pAhciReq->uOffset, pAhciReq->cbTransfer);
4477 }
4478 else if (enmType == PDMMEDIAEXIOREQTYPE_WRITE)
4479 {
4480 pAhciPort->Led.Asserted.s.fWriting = pAhciPort->Led.Actual.s.fWriting = 1;
4481 rc = pAhciPort->pDrvMediaEx->pfnIoReqWrite(pAhciPort->pDrvMediaEx, pAhciReq->hIoReq,
4482 pAhciReq->uOffset, pAhciReq->cbTransfer);
4483 }
4484 else if (enmType == PDMMEDIAEXIOREQTYPE_SCSI)
4485 {
4486 size_t cbBuf = 0;
4487
4488 if (pAhciReq->cPrdtlEntries)
4489 rc = ahciR3PrdtQuerySize(pAhciPort->CTX_SUFF(pAhci), pAhciReq, &cbBuf);
4490 pAhciReq->cbTransfer = cbBuf;
4491 if (RT_SUCCESS(rc))
4492 {
4493 if (cbBuf && (pAhciReq->fFlags & AHCI_REQ_XFER_2_HOST))
4494 pAhciPort->Led.Asserted.s.fReading = pAhciPort->Led.Actual.s.fReading = 1;
4495 else if (cbBuf)
4496 pAhciPort->Led.Asserted.s.fWriting = pAhciPort->Led.Actual.s.fWriting = 1;
4497 rc = pAhciPort->pDrvMediaEx->pfnIoReqSendScsiCmd(pAhciPort->pDrvMediaEx, pAhciReq->hIoReq,
4498 0, &pAhciReq->aATAPICmd[0], ATAPI_PACKET_SIZE,
4499 PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN, cbBuf,
4500 &pAhciPort->abATAPISense[0], sizeof(pAhciPort->abATAPISense),
4501 &pAhciReq->u8ScsiSts, 30 * RT_MS_1SEC);
4502 }
4503 }
4504
4505 if (rc == VINF_SUCCESS)
4506 fReqCanceled = ahciTransferComplete(pAhciPort, pAhciReq, VINF_SUCCESS);
4507 else if (rc != VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS)
4508 fReqCanceled = ahciTransferComplete(pAhciPort, pAhciReq, rc);
4509
4510 return fReqCanceled;
4511}
4512
4513/**
4514 * Prepares the command for execution coping it from guest memory and doing a few
4515 * validation checks on it.
4516 *
4517 * @returns Whether the command was successfully fetched from guest memory and
4518 * can be continued.
4519 * @param pAhciPort The AHCI port the request is for.
4520 * @param pAhciReq Request structure to copy the command to.
4521 */
4522static bool ahciR3CmdPrepare(PAHCIPort pAhciPort, PAHCIREQ pAhciReq)
4523{
4524 /* Set current command slot */
4525 ASMAtomicWriteU32(&pAhciPort->u32CurrentCommandSlot, pAhciReq->uTag);
4526
4527 bool fContinue = ahciPortTaskGetCommandFis(pAhciPort, pAhciReq);
4528 if (fContinue)
4529 {
4530 /* Mark the task as processed by the HBA if this is a queued task so that it doesn't occur in the CI register anymore. */
4531 if (pAhciPort->regSACT & RT_BIT_32(pAhciReq->uTag))
4532 {
4533 pAhciReq->fFlags |= AHCI_REQ_CLEAR_SACT;
4534 ASMAtomicOrU32(&pAhciPort->u32TasksFinished, RT_BIT_32(pAhciReq->uTag));
4535 }
4536
4537 if (pAhciReq->cmdFis[AHCI_CMDFIS_BITS] & AHCI_CMDFIS_C)
4538 {
4539 /*
4540 * It is possible that the request counter can get one higher than the maximum because
4541 * the request counter is decremented after the guest was notified about the completed
4542 * request (see @bugref{7859}). If the completing thread is preempted in between the
4543 * guest might already issue another request before the request counter is decremented
4544 * which would trigger the following assertion incorrectly in the past.
4545 */
4546 AssertLogRelMsg(ASMAtomicReadU32(&pAhciPort->cTasksActive) <= AHCI_NR_COMMAND_SLOTS,
4547 ("AHCI#%uP%u: There are more than %u (+1) requests active",
4548 pAhciPort->CTX_SUFF(pDevIns)->iInstance, pAhciPort->iLUN,
4549 AHCI_NR_COMMAND_SLOTS));
4550 ASMAtomicIncU32(&pAhciPort->cTasksActive);
4551 }
4552 else
4553 {
4554 /* If the reset bit is set put the device into reset state. */
4555 if (pAhciReq->cmdFis[AHCI_CMDFIS_CTL] & AHCI_CMDFIS_CTL_SRST)
4556 {
4557 ahciLog(("%s: Setting device into reset state\n", __FUNCTION__));
4558 pAhciPort->fResetDevice = true;
4559 ahciSendD2HFis(pAhciPort, pAhciReq->uTag, pAhciReq->cmdFis, true);
4560 }
4561 else if (pAhciPort->fResetDevice) /* The bit is not set and we are in a reset state. */
4562 ahciFinishStorageDeviceReset(pAhciPort, pAhciReq);
4563 else /* We are not in a reset state update the control registers. */
4564 AssertMsgFailed(("%s: Update the control register\n", __FUNCTION__));
4565
4566 fContinue = false;
4567 }
4568 }
4569 else
4570 {
4571 /*
4572 * Couldn't find anything in either the AHCI or SATA spec which
4573 * indicates what should be done if the FIS is not read successfully.
4574 * The closest thing is in the state machine, stating that the device
4575 * should go into idle state again (SATA spec 1.0 chapter 8.7.1).
4576 * Do the same here and ignore any corrupt FIS types, after all
4577 * the guest messed up everything and this behavior is undefined.
4578 */
4579 fContinue = false;
4580 }
4581
4582 return fContinue;
4583}
4584
4585/**
4586 * Transmit queue consumer
4587 * Queue a new async task.
4588 *
4589 * @returns Success indicator.
4590 * If false the item will not be removed and the flushing will stop.
4591 * @param pDevIns The device instance.
4592 * @param pItem The item to consume. Upon return this item will be freed.
4593 */
4594static DECLCALLBACK(bool) ahciNotifyQueueConsumer(PPDMDEVINS pDevIns, PPDMQUEUEITEMCORE pItem)
4595{
4596 PDEVPORTNOTIFIERQUEUEITEM pNotifierItem = (PDEVPORTNOTIFIERQUEUEITEM)pItem;
4597 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
4598 PAHCIPort pAhciPort = &pThis->ahciPort[pNotifierItem->iPort];
4599 int rc = VINF_SUCCESS;
4600
4601 ahciLog(("%s: Got notification from GC\n", __FUNCTION__));
4602 /* Notify the async IO thread. */
4603 rc = SUPSemEventSignal(pThis->pSupDrvSession, pAhciPort->hEvtProcess);
4604 AssertRC(rc);
4605
4606 return true;
4607}
4608
4609/* The async IO thread for one port. */
4610static DECLCALLBACK(int) ahciAsyncIOLoop(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
4611{
4612 RT_NOREF(pDevIns);
4613 PAHCIPort pAhciPort = (PAHCIPort)pThread->pvUser;
4614 PAHCI pAhci = pAhciPort->CTX_SUFF(pAhci);
4615 int rc = VINF_SUCCESS;
4616
4617 ahciLog(("%s: Port %d entering async IO loop.\n", __FUNCTION__, pAhciPort->iLUN));
4618
4619 if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
4620 return VINF_SUCCESS;
4621
4622 while (pThread->enmState == PDMTHREADSTATE_RUNNING)
4623 {
4624 unsigned idx = 0;
4625 uint32_t u32Tasks = 0;
4626 uint32_t u32RegHbaCtrl = 0;
4627
4628 ASMAtomicWriteBool(&pAhciPort->fWrkThreadSleeping, true);
4629 u32Tasks = ASMAtomicXchgU32(&pAhciPort->u32TasksNew, 0);
4630 if (!u32Tasks)
4631 {
4632 Assert(ASMAtomicReadBool(&pAhciPort->fWrkThreadSleeping));
4633 rc = SUPSemEventWaitNoResume(pAhci->pSupDrvSession, pAhciPort->hEvtProcess, RT_INDEFINITE_WAIT);
4634 AssertLogRelMsgReturn(RT_SUCCESS(rc) || rc == VERR_INTERRUPTED, ("%Rrc\n", rc), rc);
4635 if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
4636 break;
4637 LogFlowFunc(("Woken up with rc=%Rrc\n", rc));
4638 u32Tasks = ASMAtomicXchgU32(&pAhciPort->u32TasksNew, 0);
4639 }
4640
4641 ASMAtomicWriteBool(&pAhciPort->fWrkThreadSleeping, false);
4642 ASMAtomicIncU32(&pAhci->cThreadsActive);
4643
4644 /* Check whether the thread should be suspended. */
4645 if (pAhci->fSignalIdle)
4646 {
4647 if (!ASMAtomicDecU32(&pAhci->cThreadsActive))
4648 PDMDevHlpAsyncNotificationCompleted(pAhciPort->pDevInsR3);
4649 continue;
4650 }
4651
4652 /*
4653 * Check whether the global host controller bit is set and go to sleep immediately again
4654 * if it is set.
4655 */
4656 u32RegHbaCtrl = ASMAtomicReadU32(&pAhci->regHbaCtrl);
4657 if ( u32RegHbaCtrl & AHCI_HBA_CTRL_HR
4658 && !ASMAtomicDecU32(&pAhci->cThreadsActive))
4659 {
4660 ahciHBAReset(pAhci);
4661 if (pAhci->fSignalIdle)
4662 PDMDevHlpAsyncNotificationCompleted(pAhciPort->pDevInsR3);
4663 continue;
4664 }
4665
4666 idx = ASMBitFirstSetU32(u32Tasks);
4667 while ( idx
4668 && !pAhciPort->fPortReset)
4669 {
4670 bool fReqCanceled = false;
4671
4672 /* Decrement to get the slot number. */
4673 idx--;
4674 ahciLog(("%s: Processing command at slot %d\n", __FUNCTION__, idx));
4675
4676 PAHCIREQ pAhciReq = ahciR3ReqAlloc(pAhciPort, idx);
4677 if (RT_LIKELY(pAhciReq))
4678 {
4679 pAhciReq->uTag = idx;
4680 pAhciReq->fFlags = 0;
4681
4682 bool fContinue = ahciR3CmdPrepare(pAhciPort, pAhciReq);
4683 if (fContinue)
4684 {
4685 PDMMEDIAEXIOREQTYPE enmType = ahciProcessCmd(pAhciPort, pAhciReq, pAhciReq->cmdFis);
4686 pAhciReq->enmType = enmType;
4687
4688 if (enmType != PDMMEDIAEXIOREQTYPE_INVALID)
4689 fReqCanceled = ahciR3ReqSubmit(pAhciPort, pAhciReq, enmType);
4690 else
4691 fReqCanceled = ahciTransferComplete(pAhciPort, pAhciReq, VINF_SUCCESS);
4692 } /* Command */
4693 else
4694 ahciR3ReqFree(pAhciPort, pAhciReq);
4695 }
4696 else /* !Request allocated, use on stack variant to signal the error. */
4697 {
4698 AHCIREQ Req;
4699 Req.uTag = idx;
4700 Req.fFlags = AHCI_REQ_IS_ON_STACK;
4701 Req.fMapped = false;
4702 Req.cbTransfer = 0;
4703 Req.uOffset = 0;
4704 Req.enmType = PDMMEDIAEXIOREQTYPE_INVALID;
4705
4706 bool fContinue = ahciR3CmdPrepare(pAhciPort, &Req);
4707 if (fContinue)
4708 fReqCanceled = ahciTransferComplete(pAhciPort, &Req, VERR_NO_MEMORY);
4709 }
4710
4711 /*
4712 * Don't process other requests if the last one was canceled,
4713 * the others are not valid anymore.
4714 */
4715 if (fReqCanceled)
4716 break;
4717
4718 u32Tasks &= ~RT_BIT_32(idx); /* Clear task bit. */
4719 idx = ASMBitFirstSetU32(u32Tasks);
4720 } /* while tasks available */
4721
4722 /* Check whether a port reset was active. */
4723 if ( ASMAtomicReadBool(&pAhciPort->fPortReset)
4724 && (pAhciPort->regSCTL & AHCI_PORT_SCTL_DET) == AHCI_PORT_SCTL_DET_NINIT)
4725 ahciPortResetFinish(pAhciPort);
4726
4727 /*
4728 * Check whether a host controller reset is pending and execute the reset
4729 * if this is the last active thread.
4730 */
4731 u32RegHbaCtrl = ASMAtomicReadU32(&pAhci->regHbaCtrl);
4732 uint32_t cThreadsActive = ASMAtomicDecU32(&pAhci->cThreadsActive);
4733 if ( (u32RegHbaCtrl & AHCI_HBA_CTRL_HR)
4734 && !cThreadsActive)
4735 ahciHBAReset(pAhci);
4736
4737 if (!cThreadsActive && pAhci->fSignalIdle)
4738 PDMDevHlpAsyncNotificationCompleted(pAhciPort->pDevInsR3);
4739 } /* While running */
4740
4741 ahciLog(("%s: Port %d async IO thread exiting\n", __FUNCTION__, pAhciPort->iLUN));
4742 return VINF_SUCCESS;
4743}
4744
4745/**
4746 * Unblock the async I/O thread so it can respond to a state change.
4747 *
4748 * @returns VBox status code.
4749 * @param pDevIns The device instance.
4750 * @param pThread The send thread.
4751 */
4752static DECLCALLBACK(int) ahciAsyncIOLoopWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
4753{
4754 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
4755 PAHCIPort pAhciPort = (PAHCIPort)pThread->pvUser;
4756 return SUPSemEventSignal(pThis->pSupDrvSession, pAhciPort->hEvtProcess);
4757}
4758
4759/* -=-=-=-=- DBGF -=-=-=-=- */
4760
4761/**
4762 * AHCI status info callback.
4763 *
4764 * @param pDevIns The device instance.
4765 * @param pHlp The output helpers.
4766 * @param pszArgs The arguments.
4767 */
4768static DECLCALLBACK(void) ahciR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
4769{
4770 RT_NOREF(pszArgs);
4771 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
4772
4773 /*
4774 * Show info.
4775 */
4776 pHlp->pfnPrintf(pHlp,
4777 "%s#%d: mmio=%RGp ports=%u GC=%RTbool R0=%RTbool\n",
4778 pDevIns->pReg->szName,
4779 pDevIns->iInstance,
4780 pThis->MMIOBase,
4781 pThis->cPortsImpl,
4782 pThis->fGCEnabled ? true : false,
4783 pThis->fR0Enabled ? true : false);
4784
4785 /*
4786 * Show global registers.
4787 */
4788 pHlp->pfnPrintf(pHlp, "HbaCap=%#x\n", pThis->regHbaCap);
4789 pHlp->pfnPrintf(pHlp, "HbaCtrl=%#x\n", pThis->regHbaCtrl);
4790 pHlp->pfnPrintf(pHlp, "HbaIs=%#x\n", pThis->regHbaIs);
4791 pHlp->pfnPrintf(pHlp, "HbaPi=%#x\n", pThis->regHbaPi);
4792 pHlp->pfnPrintf(pHlp, "HbaVs=%#x\n", pThis->regHbaVs);
4793 pHlp->pfnPrintf(pHlp, "HbaCccCtl=%#x\n", pThis->regHbaCccCtl);
4794 pHlp->pfnPrintf(pHlp, "HbaCccPorts=%#x\n", pThis->regHbaCccPorts);
4795 pHlp->pfnPrintf(pHlp, "PortsInterrupted=%#x\n", pThis->u32PortsInterrupted);
4796
4797 /*
4798 * Per port data.
4799 */
4800 for (unsigned i = 0; i < pThis->cPortsImpl; i++)
4801 {
4802 PAHCIPort pThisPort = &pThis->ahciPort[i];
4803
4804 pHlp->pfnPrintf(pHlp, "Port %d: device-attached=%RTbool\n",
4805 pThisPort->iLUN, pThisPort->pDrvBase != NULL);
4806 pHlp->pfnPrintf(pHlp, "PortClb=%#x\n", pThisPort->regCLB);
4807 pHlp->pfnPrintf(pHlp, "PortClbU=%#x\n", pThisPort->regCLBU);
4808 pHlp->pfnPrintf(pHlp, "PortFb=%#x\n", pThisPort->regFB);
4809 pHlp->pfnPrintf(pHlp, "PortFbU=%#x\n", pThisPort->regFBU);
4810 pHlp->pfnPrintf(pHlp, "PortIs=%#x\n", pThisPort->regIS);
4811 pHlp->pfnPrintf(pHlp, "PortIe=%#x\n", pThisPort->regIE);
4812 pHlp->pfnPrintf(pHlp, "PortCmd=%#x\n", pThisPort->regCMD);
4813 pHlp->pfnPrintf(pHlp, "PortTfd=%#x\n", pThisPort->regTFD);
4814 pHlp->pfnPrintf(pHlp, "PortSig=%#x\n", pThisPort->regSIG);
4815 pHlp->pfnPrintf(pHlp, "PortSSts=%#x\n", pThisPort->regSSTS);
4816 pHlp->pfnPrintf(pHlp, "PortSCtl=%#x\n", pThisPort->regSCTL);
4817 pHlp->pfnPrintf(pHlp, "PortSErr=%#x\n", pThisPort->regSERR);
4818 pHlp->pfnPrintf(pHlp, "PortSAct=%#x\n", pThisPort->regSACT);
4819 pHlp->pfnPrintf(pHlp, "PortCi=%#x\n", pThisPort->regCI);
4820 pHlp->pfnPrintf(pHlp, "PortPhysClb=%RGp\n", pThisPort->GCPhysAddrClb);
4821 pHlp->pfnPrintf(pHlp, "PortPhysFb=%RGp\n", pThisPort->GCPhysAddrFb);
4822 pHlp->pfnPrintf(pHlp, "PortActTasksActive=%u\n", pThisPort->cTasksActive);
4823 pHlp->pfnPrintf(pHlp, "PortPoweredOn=%RTbool\n", pThisPort->fPoweredOn);
4824 pHlp->pfnPrintf(pHlp, "PortSpunUp=%RTbool\n", pThisPort->fSpunUp);
4825 pHlp->pfnPrintf(pHlp, "PortFirstD2HFisSent=%RTbool\n", pThisPort->fFirstD2HFisSent);
4826 pHlp->pfnPrintf(pHlp, "PortATAPI=%RTbool\n", pThisPort->fATAPI);
4827 pHlp->pfnPrintf(pHlp, "PortTasksFinished=%#x\n", pThisPort->u32TasksFinished);
4828 pHlp->pfnPrintf(pHlp, "PortQueuedTasksFinished=%#x\n", pThisPort->u32QueuedTasksFinished);
4829 pHlp->pfnPrintf(pHlp, "PortTasksNew=%#x\n", pThisPort->u32TasksNew);
4830 pHlp->pfnPrintf(pHlp, "\n");
4831 }
4832}
4833
4834/* -=-=-=-=- Helper -=-=-=-=- */
4835
4836/**
4837 * Checks if all asynchronous I/O is finished, both AHCI and IDE.
4838 *
4839 * Used by ahciR3Reset, ahciR3Suspend and ahciR3PowerOff. ahciR3SavePrep makes
4840 * use of it in strict builds (which is why it's up here).
4841 *
4842 * @returns true if quiesced, false if busy.
4843 * @param pDevIns The device instance.
4844 */
4845static bool ahciR3AllAsyncIOIsFinished(PPDMDEVINS pDevIns)
4846{
4847 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
4848
4849 if (pThis->cThreadsActive)
4850 return false;
4851
4852 for (uint32_t i = 0; i < RT_ELEMENTS(pThis->ahciPort); i++)
4853 {
4854 PAHCIPort pThisPort = &pThis->ahciPort[i];
4855 if (pThisPort->pDrvBase)
4856 {
4857 if ( (pThisPort->cTasksActive != 0)
4858 || (pThisPort->u32TasksNew != 0))
4859 return false;
4860 }
4861 }
4862 return true;
4863}
4864
4865/* -=-=-=-=- Saved State -=-=-=-=- */
4866
4867/**
4868 * @callback_method_impl{FNSSMDEVSAVEPREP}
4869 */
4870static DECLCALLBACK(int) ahciR3SavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
4871{
4872 RT_NOREF(pDevIns, pSSM);
4873 Assert(ahciR3AllAsyncIOIsFinished(pDevIns));
4874 return VINF_SUCCESS;
4875}
4876
4877/**
4878 * @callback_method_impl{FNSSMDEVLOADPREP}
4879 */
4880static DECLCALLBACK(int) ahciR3LoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
4881{
4882 RT_NOREF(pDevIns, pSSM);
4883 Assert(ahciR3AllAsyncIOIsFinished(pDevIns));
4884 return VINF_SUCCESS;
4885}
4886
4887/**
4888 * @callback_method_impl{FNSSMDEVLIVEEXEC}
4889 */
4890static DECLCALLBACK(int) ahciR3LiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
4891{
4892 RT_NOREF(uPass);
4893 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
4894
4895 /* config. */
4896 SSMR3PutU32(pSSM, pThis->cPortsImpl);
4897 for (uint32_t i = 0; i < AHCI_MAX_NR_PORTS_IMPL; i++)
4898 {
4899 SSMR3PutBool(pSSM, pThis->ahciPort[i].pDrvBase != NULL);
4900 SSMR3PutBool(pSSM, pThis->ahciPort[i].fHotpluggable);
4901 SSMR3PutStrZ(pSSM, pThis->ahciPort[i].szSerialNumber);
4902 SSMR3PutStrZ(pSSM, pThis->ahciPort[i].szFirmwareRevision);
4903 SSMR3PutStrZ(pSSM, pThis->ahciPort[i].szModelNumber);
4904 }
4905
4906 static const char *s_apszIdeEmuPortNames[4] = { "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
4907 for (uint32_t i = 0; i < RT_ELEMENTS(s_apszIdeEmuPortNames); i++)
4908 {
4909 uint32_t iPort;
4910 int rc = CFGMR3QueryU32Def(pDevIns->pCfg, s_apszIdeEmuPortNames[i], &iPort, i);
4911 AssertRCReturn(rc, rc);
4912 SSMR3PutU32(pSSM, iPort);
4913 }
4914
4915 return VINF_SSM_DONT_CALL_AGAIN;
4916}
4917
4918/**
4919 * @callback_method_impl{FNSSMDEVSAVEEXEC}
4920 */
4921static DECLCALLBACK(int) ahciR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
4922{
4923 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
4924 uint32_t i;
4925 int rc;
4926
4927 Assert(!pThis->f8ByteMMIO4BytesWrittenSuccessfully);
4928
4929 /* The config */
4930 rc = ahciR3LiveExec(pDevIns, pSSM, SSM_PASS_FINAL);
4931 AssertRCReturn(rc, rc);
4932
4933 /* The main device structure. */
4934 SSMR3PutU32(pSSM, pThis->regHbaCap);
4935 SSMR3PutU32(pSSM, pThis->regHbaCtrl);
4936 SSMR3PutU32(pSSM, pThis->regHbaIs);
4937 SSMR3PutU32(pSSM, pThis->regHbaPi);
4938 SSMR3PutU32(pSSM, pThis->regHbaVs);
4939 SSMR3PutU32(pSSM, pThis->regHbaCccCtl);
4940 SSMR3PutU32(pSSM, pThis->regHbaCccPorts);
4941 SSMR3PutU8(pSSM, pThis->uCccPortNr);
4942 SSMR3PutU64(pSSM, pThis->uCccTimeout);
4943 SSMR3PutU32(pSSM, pThis->uCccNr);
4944 SSMR3PutU32(pSSM, pThis->uCccCurrentNr);
4945 SSMR3PutU32(pSSM, pThis->u32PortsInterrupted);
4946 SSMR3PutBool(pSSM, pThis->fReset);
4947 SSMR3PutBool(pSSM, pThis->f64BitAddr);
4948 SSMR3PutBool(pSSM, pThis->fR0Enabled);
4949 SSMR3PutBool(pSSM, pThis->fGCEnabled);
4950 SSMR3PutBool(pSSM, pThis->fLegacyPortResetMethod);
4951
4952 /* Now every port. */
4953 for (i = 0; i < AHCI_MAX_NR_PORTS_IMPL; i++)
4954 {
4955 Assert(pThis->ahciPort[i].cTasksActive == 0);
4956 SSMR3PutU32(pSSM, pThis->ahciPort[i].regCLB);
4957 SSMR3PutU32(pSSM, pThis->ahciPort[i].regCLBU);
4958 SSMR3PutU32(pSSM, pThis->ahciPort[i].regFB);
4959 SSMR3PutU32(pSSM, pThis->ahciPort[i].regFBU);
4960 SSMR3PutGCPhys(pSSM, pThis->ahciPort[i].GCPhysAddrClb);
4961 SSMR3PutGCPhys(pSSM, pThis->ahciPort[i].GCPhysAddrFb);
4962 SSMR3PutU32(pSSM, pThis->ahciPort[i].regIS);
4963 SSMR3PutU32(pSSM, pThis->ahciPort[i].regIE);
4964 SSMR3PutU32(pSSM, pThis->ahciPort[i].regCMD);
4965 SSMR3PutU32(pSSM, pThis->ahciPort[i].regTFD);
4966 SSMR3PutU32(pSSM, pThis->ahciPort[i].regSIG);
4967 SSMR3PutU32(pSSM, pThis->ahciPort[i].regSSTS);
4968 SSMR3PutU32(pSSM, pThis->ahciPort[i].regSCTL);
4969 SSMR3PutU32(pSSM, pThis->ahciPort[i].regSERR);
4970 SSMR3PutU32(pSSM, pThis->ahciPort[i].regSACT);
4971 SSMR3PutU32(pSSM, pThis->ahciPort[i].regCI);
4972 SSMR3PutU32(pSSM, pThis->ahciPort[i].PCHSGeometry.cCylinders);
4973 SSMR3PutU32(pSSM, pThis->ahciPort[i].PCHSGeometry.cHeads);
4974 SSMR3PutU32(pSSM, pThis->ahciPort[i].PCHSGeometry.cSectors);
4975 SSMR3PutU64(pSSM, pThis->ahciPort[i].cTotalSectors);
4976 SSMR3PutU32(pSSM, pThis->ahciPort[i].cMultSectors);
4977 SSMR3PutU8(pSSM, pThis->ahciPort[i].uATATransferMode);
4978 SSMR3PutBool(pSSM, pThis->ahciPort[i].fResetDevice);
4979 SSMR3PutBool(pSSM, pThis->ahciPort[i].fPoweredOn);
4980 SSMR3PutBool(pSSM, pThis->ahciPort[i].fSpunUp);
4981 SSMR3PutU32(pSSM, pThis->ahciPort[i].u32TasksFinished);
4982 SSMR3PutU32(pSSM, pThis->ahciPort[i].u32QueuedTasksFinished);
4983 SSMR3PutU32(pSSM, pThis->ahciPort[i].u32CurrentCommandSlot);
4984
4985 /* ATAPI saved state. */
4986 SSMR3PutBool(pSSM, pThis->ahciPort[i].fATAPI);
4987 SSMR3PutMem(pSSM, &pThis->ahciPort[i].abATAPISense[0], sizeof(pThis->ahciPort[i].abATAPISense));
4988 }
4989
4990 return SSMR3PutU32(pSSM, UINT32_MAX); /* sanity/terminator */
4991}
4992
4993/**
4994 * Loads a saved legacy ATA emulated device state.
4995 *
4996 * @returns VBox status code.
4997 * @param pSSM The handle to the saved state.
4998 */
4999static int ahciR3LoadLegacyEmulationState(PSSMHANDLE pSSM)
5000{
5001 int rc;
5002 uint32_t u32Version;
5003 uint32_t u32;
5004 uint32_t u32IOBuffer;
5005
5006 /* Test for correct version. */
5007 rc = SSMR3GetU32(pSSM, &u32Version);
5008 AssertRCReturn(rc, rc);
5009 LogFlow(("LoadOldSavedStates u32Version = %d\n", u32Version));
5010
5011 if ( u32Version != ATA_CTL_SAVED_STATE_VERSION
5012 && u32Version != ATA_CTL_SAVED_STATE_VERSION_WITHOUT_FULL_SENSE
5013 && u32Version != ATA_CTL_SAVED_STATE_VERSION_WITHOUT_EVENT_STATUS)
5014 {
5015 AssertMsgFailed(("u32Version=%d\n", u32Version));
5016 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
5017 }
5018
5019 SSMR3Skip(pSSM, 19 + 5 * sizeof(bool) + 8 /* sizeof(BMDMAState) */);
5020
5021 for (uint32_t j = 0; j < 2; j++)
5022 {
5023 SSMR3Skip(pSSM, 88 + 5 * sizeof(bool) );
5024
5025 if (u32Version > ATA_CTL_SAVED_STATE_VERSION_WITHOUT_FULL_SENSE)
5026 SSMR3Skip(pSSM, 64);
5027 else
5028 SSMR3Skip(pSSM, 2);
5029 /** @todo triple-check this hack after passthrough is working */
5030 SSMR3Skip(pSSM, 1);
5031
5032 if (u32Version > ATA_CTL_SAVED_STATE_VERSION_WITHOUT_EVENT_STATUS)
5033 SSMR3Skip(pSSM, 4);
5034
5035 SSMR3Skip(pSSM, sizeof(PDMLED));
5036 SSMR3GetU32(pSSM, &u32IOBuffer);
5037 if (u32IOBuffer)
5038 SSMR3Skip(pSSM, u32IOBuffer);
5039 }
5040
5041 rc = SSMR3GetU32(pSSM, &u32);
5042 if (RT_FAILURE(rc))
5043 return rc;
5044 if (u32 != ~0U)
5045 {
5046 AssertMsgFailed(("u32=%#x expected ~0\n", u32));
5047 rc = VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
5048 return rc;
5049 }
5050
5051 return VINF_SUCCESS;
5052}
5053
5054/**
5055 * @callback_method_impl{FNSSMDEVLOADEXEC}
5056 */
5057static DECLCALLBACK(int) ahciR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
5058{
5059 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
5060 uint32_t u32;
5061 int rc;
5062
5063 if ( uVersion > AHCI_SAVED_STATE_VERSION
5064 || uVersion < AHCI_SAVED_STATE_VERSION_VBOX_30)
5065 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
5066
5067 /* Deal with the priod after removing the saved IDE bits where the saved
5068 state version remained unchanged. */
5069 if ( uVersion == AHCI_SAVED_STATE_VERSION_IDE_EMULATION
5070 && SSMR3HandleRevision(pSSM) >= 79045
5071 && SSMR3HandleRevision(pSSM) < 79201)
5072 uVersion++;
5073
5074 /*
5075 * Check whether we have to resort to the legacy port reset method to
5076 * prevent older BIOS versions from failing after a reset.
5077 */
5078 if (uVersion <= AHCI_SAVED_STATE_VERSION_PRE_PORT_RESET_CHANGES)
5079 pThis->fLegacyPortResetMethod = true;
5080
5081 /* Verify config. */
5082 if (uVersion > AHCI_SAVED_STATE_VERSION_VBOX_30)
5083 {
5084 rc = SSMR3GetU32(pSSM, &u32);
5085 AssertRCReturn(rc, rc);
5086 if (u32 != pThis->cPortsImpl)
5087 {
5088 LogRel(("AHCI: Config mismatch: cPortsImpl - saved=%u config=%u\n", u32, pThis->cPortsImpl));
5089 if ( u32 < pThis->cPortsImpl
5090 || u32 > AHCI_MAX_NR_PORTS_IMPL)
5091 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch: cPortsImpl - saved=%u config=%u"),
5092 u32, pThis->cPortsImpl);
5093 }
5094
5095 for (uint32_t i = 0; i < AHCI_MAX_NR_PORTS_IMPL; i++)
5096 {
5097 bool fInUse;
5098 rc = SSMR3GetBool(pSSM, &fInUse);
5099 AssertRCReturn(rc, rc);
5100 if (fInUse != (pThis->ahciPort[i].pDrvBase != NULL))
5101 return SSMR3SetCfgError(pSSM, RT_SRC_POS,
5102 N_("The %s VM is missing a device on port %u. Please make sure the source and target VMs have compatible storage configurations"),
5103 fInUse ? "target" : "source", i );
5104
5105 if (uVersion > AHCI_SAVED_STATE_VERSION_PRE_HOTPLUG_FLAG)
5106 {
5107 bool fHotpluggable;
5108 rc = SSMR3GetBool(pSSM, &fHotpluggable);
5109 AssertRCReturn(rc, rc);
5110 if (fHotpluggable != pThis->ahciPort[i].fHotpluggable)
5111 return SSMR3SetCfgError(pSSM, RT_SRC_POS,
5112 N_("AHCI: Port %u config mismatch: Hotplug flag - saved=%RTbool config=%RTbool\n"),
5113 i, fHotpluggable, pThis->ahciPort[i].fHotpluggable);
5114 }
5115 else
5116 Assert(pThis->ahciPort[i].fHotpluggable);
5117
5118 char szSerialNumber[AHCI_SERIAL_NUMBER_LENGTH+1];
5119 rc = SSMR3GetStrZ(pSSM, szSerialNumber, sizeof(szSerialNumber));
5120 AssertRCReturn(rc, rc);
5121 if (strcmp(szSerialNumber, pThis->ahciPort[i].szSerialNumber))
5122 LogRel(("AHCI: Port %u config mismatch: Serial number - saved='%s' config='%s'\n",
5123 i, szSerialNumber, pThis->ahciPort[i].szSerialNumber));
5124
5125 char szFirmwareRevision[AHCI_FIRMWARE_REVISION_LENGTH+1];
5126 rc = SSMR3GetStrZ(pSSM, szFirmwareRevision, sizeof(szFirmwareRevision));
5127 AssertRCReturn(rc, rc);
5128 if (strcmp(szFirmwareRevision, pThis->ahciPort[i].szFirmwareRevision))
5129 LogRel(("AHCI: Port %u config mismatch: Firmware revision - saved='%s' config='%s'\n",
5130 i, szFirmwareRevision, pThis->ahciPort[i].szFirmwareRevision));
5131
5132 char szModelNumber[AHCI_MODEL_NUMBER_LENGTH+1];
5133 rc = SSMR3GetStrZ(pSSM, szModelNumber, sizeof(szModelNumber));
5134 AssertRCReturn(rc, rc);
5135 if (strcmp(szModelNumber, pThis->ahciPort[i].szModelNumber))
5136 LogRel(("AHCI: Port %u config mismatch: Model number - saved='%s' config='%s'\n",
5137 i, szModelNumber, pThis->ahciPort[i].szModelNumber));
5138 }
5139
5140 static const char *s_apszIdeEmuPortNames[4] = { "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
5141 for (uint32_t i = 0; i < RT_ELEMENTS(s_apszIdeEmuPortNames); i++)
5142 {
5143 uint32_t iPort;
5144 rc = CFGMR3QueryU32Def(pDevIns->pCfg, s_apszIdeEmuPortNames[i], &iPort, i);
5145 AssertRCReturn(rc, rc);
5146
5147 uint32_t iPortSaved;
5148 rc = SSMR3GetU32(pSSM, &iPortSaved);
5149 AssertRCReturn(rc, rc);
5150
5151 if (iPortSaved != iPort)
5152 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("IDE %s config mismatch: saved=%u config=%u"),
5153 s_apszIdeEmuPortNames[i], iPortSaved, iPort);
5154 }
5155 }
5156
5157 if (uPass == SSM_PASS_FINAL)
5158 {
5159 /* Restore data. */
5160
5161 /* The main device structure. */
5162 SSMR3GetU32(pSSM, &pThis->regHbaCap);
5163 SSMR3GetU32(pSSM, &pThis->regHbaCtrl);
5164 SSMR3GetU32(pSSM, &pThis->regHbaIs);
5165 SSMR3GetU32(pSSM, &pThis->regHbaPi);
5166 SSMR3GetU32(pSSM, &pThis->regHbaVs);
5167 SSMR3GetU32(pSSM, &pThis->regHbaCccCtl);
5168 SSMR3GetU32(pSSM, &pThis->regHbaCccPorts);
5169 SSMR3GetU8(pSSM, &pThis->uCccPortNr);
5170 SSMR3GetU64(pSSM, &pThis->uCccTimeout);
5171 SSMR3GetU32(pSSM, &pThis->uCccNr);
5172 SSMR3GetU32(pSSM, &pThis->uCccCurrentNr);
5173
5174 SSMR3GetU32(pSSM, (uint32_t *)&pThis->u32PortsInterrupted);
5175 SSMR3GetBool(pSSM, &pThis->fReset);
5176 SSMR3GetBool(pSSM, &pThis->f64BitAddr);
5177 SSMR3GetBool(pSSM, &pThis->fR0Enabled);
5178 SSMR3GetBool(pSSM, &pThis->fGCEnabled);
5179 if (uVersion > AHCI_SAVED_STATE_VERSION_PRE_PORT_RESET_CHANGES)
5180 SSMR3GetBool(pSSM, &pThis->fLegacyPortResetMethod);
5181
5182 /* Now every port. */
5183 for (uint32_t i = 0; i < AHCI_MAX_NR_PORTS_IMPL; i++)
5184 {
5185 PAHCIPort pAhciPort = &pThis->ahciPort[i];
5186
5187 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regCLB);
5188 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regCLBU);
5189 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regFB);
5190 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regFBU);
5191 SSMR3GetGCPhys(pSSM, (RTGCPHYS *)&pThis->ahciPort[i].GCPhysAddrClb);
5192 SSMR3GetGCPhys(pSSM, (RTGCPHYS *)&pThis->ahciPort[i].GCPhysAddrFb);
5193 SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].regIS);
5194 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regIE);
5195 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regCMD);
5196 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regTFD);
5197 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regSIG);
5198 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regSSTS);
5199 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regSCTL);
5200 SSMR3GetU32(pSSM, &pThis->ahciPort[i].regSERR);
5201 SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].regSACT);
5202 SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].regCI);
5203 SSMR3GetU32(pSSM, &pThis->ahciPort[i].PCHSGeometry.cCylinders);
5204 SSMR3GetU32(pSSM, &pThis->ahciPort[i].PCHSGeometry.cHeads);
5205 SSMR3GetU32(pSSM, &pThis->ahciPort[i].PCHSGeometry.cSectors);
5206 SSMR3GetU64(pSSM, &pThis->ahciPort[i].cTotalSectors);
5207 SSMR3GetU32(pSSM, &pThis->ahciPort[i].cMultSectors);
5208 SSMR3GetU8(pSSM, &pThis->ahciPort[i].uATATransferMode);
5209 SSMR3GetBool(pSSM, &pThis->ahciPort[i].fResetDevice);
5210
5211 if (uVersion <= AHCI_SAVED_STATE_VERSION_VBOX_30)
5212 SSMR3Skip(pSSM, AHCI_NR_COMMAND_SLOTS * sizeof(uint8_t)); /* no active data here */
5213
5214 if (uVersion < AHCI_SAVED_STATE_VERSION_IDE_EMULATION)
5215 {
5216 /* The old positions in the FIFO, not required. */
5217 SSMR3Skip(pSSM, 2*sizeof(uint8_t));
5218 }
5219 SSMR3GetBool(pSSM, &pThis->ahciPort[i].fPoweredOn);
5220 SSMR3GetBool(pSSM, &pThis->ahciPort[i].fSpunUp);
5221 SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].u32TasksFinished);
5222 SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].u32QueuedTasksFinished);
5223
5224 if (uVersion >= AHCI_SAVED_STATE_VERSION_IDE_EMULATION)
5225 SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].u32CurrentCommandSlot);
5226
5227 if (uVersion > AHCI_SAVED_STATE_VERSION_PRE_ATAPI)
5228 {
5229 SSMR3GetBool(pSSM, &pThis->ahciPort[i].fATAPI);
5230 SSMR3GetMem(pSSM, pThis->ahciPort[i].abATAPISense, sizeof(pThis->ahciPort[i].abATAPISense));
5231 if (uVersion <= AHCI_SAVED_STATE_VERSION_PRE_ATAPI_REMOVE)
5232 {
5233 SSMR3Skip(pSSM, 1); /* cNotifiedMediaChange. */
5234 SSMR3Skip(pSSM, 4); /* MediaEventStatus */
5235 }
5236 }
5237 else if (pThis->ahciPort[i].fATAPI)
5238 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch: atapi - saved=false config=true"));
5239
5240 /* Check if we have tasks pending. */
5241 uint32_t fTasksOutstanding = pAhciPort->regCI & ~pAhciPort->u32TasksFinished;
5242 uint32_t fQueuedTasksOutstanding = pAhciPort->regSACT & ~pAhciPort->u32QueuedTasksFinished;
5243
5244 pAhciPort->u32TasksNew = fTasksOutstanding | fQueuedTasksOutstanding;
5245
5246 if (pAhciPort->u32TasksNew)
5247 {
5248 /*
5249 * There are tasks pending. The VM was saved after a task failed
5250 * because of non-fatal error. Set the redo flag.
5251 */
5252 pAhciPort->fRedo = true;
5253 }
5254 }
5255
5256 if (uVersion <= AHCI_SAVED_STATE_VERSION_IDE_EMULATION)
5257 {
5258 for (uint32_t i = 0; i < 2; i++)
5259 {
5260 rc = ahciR3LoadLegacyEmulationState(pSSM);
5261 if(RT_FAILURE(rc))
5262 return rc;
5263 }
5264 }
5265
5266 rc = SSMR3GetU32(pSSM, &u32);
5267 if (RT_FAILURE(rc))
5268 return rc;
5269 AssertMsgReturn(u32 == UINT32_MAX, ("%#x\n", u32), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
5270 }
5271
5272 return VINF_SUCCESS;
5273}
5274
5275/* -=-=-=-=- device PDM interface -=-=-=-=- */
5276
5277static DECLCALLBACK(void) ahciR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
5278{
5279 uint32_t i;
5280 PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
5281
5282 pAhci->pDevInsRC += offDelta;
5283 pAhci->pHbaCccTimerRC = TMTimerRCPtr(pAhci->pHbaCccTimerR3);
5284 pAhci->pNotifierQueueRC = PDMQueueRCPtr(pAhci->pNotifierQueueR3);
5285
5286 /* Relocate every port. */
5287 for (i = 0; i < RT_ELEMENTS(pAhci->ahciPort); i++)
5288 {
5289 PAHCIPort pAhciPort = &pAhci->ahciPort[i];
5290 pAhciPort->pAhciRC += offDelta;
5291 pAhciPort->pDevInsRC += offDelta;
5292 }
5293}
5294
5295/**
5296 * Configure the attached device for a port.
5297 *
5298 * Used by ahciR3Construct and ahciR3Attach.
5299 *
5300 * @returns VBox status code
5301 * @param pDevIns The device instance data.
5302 * @param pAhciPort The port for which the device is to be configured.
5303 */
5304static int ahciR3ConfigureLUN(PPDMDEVINS pDevIns, PAHCIPort pAhciPort)
5305{
5306 /* Query the media interface. */
5307 pAhciPort->pDrvMedia = PDMIBASE_QUERY_INTERFACE(pAhciPort->pDrvBase, PDMIMEDIA);
5308 AssertMsgReturn(VALID_PTR(pAhciPort->pDrvMedia),
5309 ("AHCI configuration error: LUN#%d misses the basic media interface!\n", pAhciPort->iLUN),
5310 VERR_PDM_MISSING_INTERFACE);
5311
5312 /* Get the extended media interface. */
5313 pAhciPort->pDrvMediaEx = PDMIBASE_QUERY_INTERFACE(pAhciPort->pDrvBase, PDMIMEDIAEX);
5314 AssertMsgReturn(VALID_PTR(pAhciPort->pDrvMediaEx),
5315 ("AHCI configuration error: LUN#%d misses the extended media interface!\n", pAhciPort->iLUN),
5316 VERR_PDM_MISSING_INTERFACE);
5317
5318 /*
5319 * Validate type.
5320 */
5321 PDMMEDIATYPE enmType = pAhciPort->pDrvMedia->pfnGetType(pAhciPort->pDrvMedia);
5322 AssertMsgReturn(enmType == PDMMEDIATYPE_HARD_DISK || enmType == PDMMEDIATYPE_CDROM || enmType == PDMMEDIATYPE_DVD,
5323 ("AHCI configuration error: LUN#%d isn't a disk or cd/dvd. enmType=%u\n", pAhciPort->iLUN, enmType),
5324 VERR_PDM_UNSUPPORTED_BLOCK_TYPE);
5325
5326 int rc = pAhciPort->pDrvMediaEx->pfnIoReqAllocSizeSet(pAhciPort->pDrvMediaEx, sizeof(AHCIREQ));
5327 if (RT_FAILURE(rc))
5328 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
5329 N_("AHCI configuration error: LUN#%u: Failed to set I/O request size!"),
5330 pAhciPort->iLUN);
5331
5332 uint32_t fFeatures = 0;
5333 rc = pAhciPort->pDrvMediaEx->pfnQueryFeatures(pAhciPort->pDrvMediaEx, &fFeatures);
5334 if (RT_FAILURE(rc))
5335 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
5336 N_("AHCI configuration error: LUN#%u: Failed to query features of device"),
5337 pAhciPort->iLUN);
5338
5339 if (fFeatures & PDMIMEDIAEX_FEATURE_F_DISCARD)
5340 pAhciPort->fTrimEnabled = true;
5341
5342 pAhciPort->fATAPI = (enmType == PDMMEDIATYPE_CDROM || enmType == PDMMEDIATYPE_DVD)
5343 && RT_BOOL(fFeatures & PDMIMEDIAEX_FEATURE_F_RAWSCSICMD);
5344 if (pAhciPort->fATAPI)
5345 {
5346 pAhciPort->PCHSGeometry.cCylinders = 0;
5347 pAhciPort->PCHSGeometry.cHeads = 0;
5348 pAhciPort->PCHSGeometry.cSectors = 0;
5349 LogRel(("AHCI: LUN#%d: CD/DVD\n", pAhciPort->iLUN));
5350 }
5351 else
5352 {
5353 pAhciPort->cbSector = pAhciPort->pDrvMedia->pfnGetSectorSize(pAhciPort->pDrvMedia);
5354 pAhciPort->cTotalSectors = pAhciPort->pDrvMedia->pfnGetSize(pAhciPort->pDrvMedia) / pAhciPort->cbSector;
5355 rc = pAhciPort->pDrvMedia->pfnBiosGetPCHSGeometry(pAhciPort->pDrvMedia, &pAhciPort->PCHSGeometry);
5356 if (rc == VERR_PDM_MEDIA_NOT_MOUNTED)
5357 {
5358 pAhciPort->PCHSGeometry.cCylinders = 0;
5359 pAhciPort->PCHSGeometry.cHeads = 16; /*??*/
5360 pAhciPort->PCHSGeometry.cSectors = 63; /*??*/
5361 }
5362 else if (rc == VERR_PDM_GEOMETRY_NOT_SET)
5363 {
5364 pAhciPort->PCHSGeometry.cCylinders = 0; /* autodetect marker */
5365 rc = VINF_SUCCESS;
5366 }
5367 AssertRC(rc);
5368
5369 if ( pAhciPort->PCHSGeometry.cCylinders == 0
5370 || pAhciPort->PCHSGeometry.cHeads == 0
5371 || pAhciPort->PCHSGeometry.cSectors == 0)
5372 {
5373 uint64_t cCylinders = pAhciPort->cTotalSectors / (16 * 63);
5374 pAhciPort->PCHSGeometry.cCylinders = RT_MAX(RT_MIN(cCylinders, 16383), 1);
5375 pAhciPort->PCHSGeometry.cHeads = 16;
5376 pAhciPort->PCHSGeometry.cSectors = 63;
5377 /* Set the disk geometry information. Ignore errors. */
5378 pAhciPort->pDrvMedia->pfnBiosSetPCHSGeometry(pAhciPort->pDrvMedia, &pAhciPort->PCHSGeometry);
5379 rc = VINF_SUCCESS;
5380 }
5381 LogRel(("AHCI: LUN#%d: disk, PCHS=%u/%u/%u, total number of sectors %Ld\n",
5382 pAhciPort->iLUN, pAhciPort->PCHSGeometry.cCylinders,
5383 pAhciPort->PCHSGeometry.cHeads, pAhciPort->PCHSGeometry.cSectors,
5384 pAhciPort->cTotalSectors));
5385 if (pAhciPort->fTrimEnabled)
5386 LogRel(("AHCI: LUN#%d: Enabled TRIM support\n", pAhciPort->iLUN));
5387 }
5388 return rc;
5389}
5390
5391/**
5392 * Callback employed by ahciR3Suspend and ahciR3PowerOff.
5393 *
5394 * @returns true if we've quiesced, false if we're still working.
5395 * @param pDevIns The device instance.
5396 */
5397static DECLCALLBACK(bool) ahciR3IsAsyncSuspendOrPowerOffDone(PPDMDEVINS pDevIns)
5398{
5399 if (!ahciR3AllAsyncIOIsFinished(pDevIns))
5400 return false;
5401
5402 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
5403 ASMAtomicWriteBool(&pThis->fSignalIdle, false);
5404 return true;
5405}
5406
5407/**
5408 * Common worker for ahciR3Suspend and ahciR3PowerOff.
5409 */
5410static void ahciR3SuspendOrPowerOff(PPDMDEVINS pDevIns)
5411{
5412 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
5413
5414 ASMAtomicWriteBool(&pThis->fSignalIdle, true);
5415 if (!ahciR3AllAsyncIOIsFinished(pDevIns))
5416 PDMDevHlpSetAsyncNotification(pDevIns, ahciR3IsAsyncSuspendOrPowerOffDone);
5417 else
5418 ASMAtomicWriteBool(&pThis->fSignalIdle, false);
5419
5420 for (uint32_t i = 0; i < RT_ELEMENTS(pThis->ahciPort); i++)
5421 {
5422 PAHCIPort pThisPort = &pThis->ahciPort[i];
5423 if (pThisPort->pDrvMediaEx)
5424 pThisPort->pDrvMediaEx->pfnNotifySuspend(pThisPort->pDrvMediaEx);
5425 }
5426}
5427
5428/**
5429 * Suspend notification.
5430 *
5431 * @param pDevIns The device instance data.
5432 */
5433static DECLCALLBACK(void) ahciR3Suspend(PPDMDEVINS pDevIns)
5434{
5435 Log(("ahciR3Suspend\n"));
5436 ahciR3SuspendOrPowerOff(pDevIns);
5437}
5438
5439/**
5440 * Resume notification.
5441 *
5442 * @param pDevIns The device instance data.
5443 */
5444static DECLCALLBACK(void) ahciR3Resume(PPDMDEVINS pDevIns)
5445{
5446 PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
5447
5448 /*
5449 * Check if one of the ports has pending tasks.
5450 * Queue a notification item again in this case.
5451 */
5452 for (unsigned i = 0; i < RT_ELEMENTS(pAhci->ahciPort); i++)
5453 {
5454 PAHCIPort pAhciPort = &pAhci->ahciPort[i];
5455
5456 if (pAhciPort->u32TasksRedo)
5457 {
5458 PDEVPORTNOTIFIERQUEUEITEM pItem = (PDEVPORTNOTIFIERQUEUEITEM)PDMQueueAlloc(pAhci->CTX_SUFF(pNotifierQueue));
5459 AssertMsg(pItem, ("Allocating item for queue failed\n"));
5460
5461 pAhciPort->u32TasksNew |= pAhciPort->u32TasksRedo;
5462 pAhciPort->u32TasksRedo = 0;
5463
5464 Assert(pAhciPort->fRedo);
5465 pAhciPort->fRedo = false;
5466
5467 pItem->iPort = pAhci->ahciPort[i].iLUN;
5468 PDMQueueInsert(pAhci->CTX_SUFF(pNotifierQueue), (PPDMQUEUEITEMCORE)pItem);
5469 }
5470 }
5471
5472 Log(("%s:\n", __FUNCTION__));
5473}
5474
5475/**
5476 * Initializes the VPD data of a attached device.
5477 *
5478 * @returns VBox status code.
5479 * @param pDevIns The device instance.
5480 * @param pAhciPort The attached device.
5481 * @param pszName Name of the port to get the CFGM node.
5482 */
5483static int ahciR3VpdInit(PPDMDEVINS pDevIns, PAHCIPort pAhciPort, const char *pszName)
5484{
5485
5486 /* Generate a default serial number. */
5487 char szSerial[AHCI_SERIAL_NUMBER_LENGTH+1];
5488 RTUUID Uuid;
5489
5490 int rc = VINF_SUCCESS;
5491 if (pAhciPort->pDrvMedia)
5492 rc = pAhciPort->pDrvMedia->pfnGetUuid(pAhciPort->pDrvMedia, &Uuid);
5493 else
5494 RTUuidClear(&Uuid);
5495
5496 if (RT_FAILURE(rc) || RTUuidIsNull(&Uuid))
5497 {
5498 /* Generate a predictable serial for drives which don't have a UUID. */
5499 RTStrPrintf(szSerial, sizeof(szSerial), "VB%x-1a2b3c4d",
5500 pAhciPort->iLUN);
5501 }
5502 else
5503 RTStrPrintf(szSerial, sizeof(szSerial), "VB%08x-%08x", Uuid.au32[0], Uuid.au32[3]);
5504
5505 /* Get user config if present using defaults otherwise. */
5506 PCFGMNODE pCfgNode = CFGMR3GetChild(pDevIns->pCfg, pszName);
5507 rc = CFGMR3QueryStringDef(pCfgNode, "SerialNumber", pAhciPort->szSerialNumber, sizeof(pAhciPort->szSerialNumber),
5508 szSerial);
5509 if (RT_FAILURE(rc))
5510 {
5511 if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
5512 return PDMDEV_SET_ERROR(pDevIns, VERR_INVALID_PARAMETER,
5513 N_("AHCI configuration error: \"SerialNumber\" is longer than 20 bytes"));
5514 return PDMDEV_SET_ERROR(pDevIns, rc,
5515 N_("AHCI configuration error: failed to read \"SerialNumber\" as string"));
5516 }
5517
5518 rc = CFGMR3QueryStringDef(pCfgNode, "FirmwareRevision", pAhciPort->szFirmwareRevision, sizeof(pAhciPort->szFirmwareRevision),
5519 "1.0");
5520 if (RT_FAILURE(rc))
5521 {
5522 if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
5523 return PDMDEV_SET_ERROR(pDevIns, VERR_INVALID_PARAMETER,
5524 N_("AHCI configuration error: \"FirmwareRevision\" is longer than 8 bytes"));
5525 return PDMDEV_SET_ERROR(pDevIns, rc,
5526 N_("AHCI configuration error: failed to read \"FirmwareRevision\" as string"));
5527 }
5528
5529 rc = CFGMR3QueryStringDef(pCfgNode, "ModelNumber", pAhciPort->szModelNumber, sizeof(pAhciPort->szModelNumber),
5530 pAhciPort->fATAPI ? "VBOX CD-ROM" : "VBOX HARDDISK");
5531 if (RT_FAILURE(rc))
5532 {
5533 if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
5534 return PDMDEV_SET_ERROR(pDevIns, VERR_INVALID_PARAMETER,
5535 N_("AHCI configuration error: \"ModelNumber\" is longer than 40 bytes"));
5536 return PDMDEV_SET_ERROR(pDevIns, rc,
5537 N_("AHCI configuration error: failed to read \"ModelNumber\" as string"));
5538 }
5539
5540 rc = CFGMR3QueryU8Def(pCfgNode, "LogicalSectorsPerPhysical", &pAhciPort->cLogSectorsPerPhysicalExp, 0);
5541 if (RT_FAILURE(rc))
5542 return PDMDEV_SET_ERROR(pDevIns, rc,
5543 N_("AHCI configuration error: failed to read \"LogicalSectorsPerPhysical\" as integer"));
5544 if (pAhciPort->cLogSectorsPerPhysicalExp >= 16)
5545 return PDMDEV_SET_ERROR(pDevIns, rc,
5546 N_("AHCI configuration error: \"LogicalSectorsPerPhysical\" must be between 0 and 15"));
5547
5548 /* There are three other identification strings for CD drives used for INQUIRY */
5549 if (pAhciPort->fATAPI)
5550 {
5551 rc = CFGMR3QueryStringDef(pCfgNode, "ATAPIVendorId", pAhciPort->szInquiryVendorId, sizeof(pAhciPort->szInquiryVendorId),
5552 "VBOX");
5553 if (RT_FAILURE(rc))
5554 {
5555 if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
5556 return PDMDEV_SET_ERROR(pDevIns, VERR_INVALID_PARAMETER,
5557 N_("AHCI configuration error: \"ATAPIVendorId\" is longer than 16 bytes"));
5558 return PDMDEV_SET_ERROR(pDevIns, rc,
5559 N_("AHCI configuration error: failed to read \"ATAPIVendorId\" as string"));
5560 }
5561
5562 rc = CFGMR3QueryStringDef(pCfgNode, "ATAPIProductId", pAhciPort->szInquiryProductId, sizeof(pAhciPort->szInquiryProductId),
5563 "CD-ROM");
5564 if (RT_FAILURE(rc))
5565 {
5566 if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
5567 return PDMDEV_SET_ERROR(pDevIns, VERR_INVALID_PARAMETER,
5568 N_("AHCI configuration error: \"ATAPIProductId\" is longer than 16 bytes"));
5569 return PDMDEV_SET_ERROR(pDevIns, rc,
5570 N_("AHCI configuration error: failed to read \"ATAPIProductId\" as string"));
5571 }
5572
5573 rc = CFGMR3QueryStringDef(pCfgNode, "ATAPIRevision", pAhciPort->szInquiryRevision, sizeof(pAhciPort->szInquiryRevision),
5574 "1.0");
5575 if (RT_FAILURE(rc))
5576 {
5577 if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
5578 return PDMDEV_SET_ERROR(pDevIns, VERR_INVALID_PARAMETER,
5579 N_("AHCI configuration error: \"ATAPIRevision\" is longer than 4 bytes"));
5580 return PDMDEV_SET_ERROR(pDevIns, rc,
5581 N_("AHCI configuration error: failed to read \"ATAPIRevision\" as string"));
5582 }
5583 }
5584
5585 return rc;
5586}
5587
5588
5589/**
5590 * Detach notification.
5591 *
5592 * One harddisk at one port has been unplugged.
5593 * The VM is suspended at this point.
5594 *
5595 * @param pDevIns The device instance.
5596 * @param iLUN The logical unit which is being detached.
5597 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
5598 */
5599static DECLCALLBACK(void) ahciR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
5600{
5601 PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
5602 PAHCIPort pAhciPort = &pAhci->ahciPort[iLUN];
5603 int rc = VINF_SUCCESS;
5604
5605 Log(("%s:\n", __FUNCTION__));
5606
5607 AssertMsg(iLUN < pAhci->cPortsImpl, ("iLUN=%u", iLUN));
5608 AssertMsgReturnVoid( pAhciPort->fHotpluggable
5609 || (fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG),
5610 ("AHCI: Port %d is not marked hotpluggable\n", pAhciPort->iLUN));
5611
5612
5613 if (pAhciPort->pAsyncIOThread)
5614 {
5615 int rcThread;
5616 /* Destroy the thread. */
5617 rc = PDMR3ThreadDestroy(pAhciPort->pAsyncIOThread, &rcThread);
5618 if (RT_FAILURE(rc) || RT_FAILURE(rcThread))
5619 AssertMsgFailed(("%s Failed to destroy async IO thread rc=%Rrc rcThread=%Rrc\n", __FUNCTION__, rc, rcThread));
5620
5621 pAhciPort->pAsyncIOThread = NULL;
5622 pAhciPort->fWrkThreadSleeping = true;
5623 }
5624
5625 if (!(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG))
5626 {
5627 /*
5628 * Inform the guest about the removed device.
5629 */
5630 pAhciPort->regSSTS = 0;
5631 pAhciPort->regSIG = 0;
5632 /*
5633 * Clear CR bit too to prevent submission of new commands when CI is written
5634 * (AHCI Spec 1.2: 7.4 Interaction of the Command List and Port Change Status).
5635 */
5636 ASMAtomicAndU32(&pAhciPort->regCMD, ~(AHCI_PORT_CMD_CPS | AHCI_PORT_CMD_CR));
5637 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_CPDS | AHCI_PORT_IS_PRCS | AHCI_PORT_IS_PCS);
5638 ASMAtomicOrU32(&pAhciPort->regSERR, AHCI_PORT_SERR_X | AHCI_PORT_SERR_N);
5639 if ( (pAhciPort->regIE & AHCI_PORT_IE_CPDE)
5640 || (pAhciPort->regIE & AHCI_PORT_IE_PCE)
5641 || (pAhciPort->regIE & AHCI_PORT_IE_PRCE))
5642 ahciHbaSetInterrupt(pAhciPort->CTX_SUFF(pAhci), pAhciPort->iLUN, VERR_IGNORED);
5643 }
5644
5645 /*
5646 * Zero some important members.
5647 */
5648 pAhciPort->pDrvBase = NULL;
5649 pAhciPort->pDrvMedia = NULL;
5650 pAhciPort->pDrvMediaEx = NULL;
5651}
5652
5653/**
5654 * Attach command.
5655 *
5656 * This is called when we change block driver for one port.
5657 * The VM is suspended at this point.
5658 *
5659 * @returns VBox status code.
5660 * @param pDevIns The device instance.
5661 * @param iLUN The logical unit which is being detached.
5662 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
5663 */
5664static DECLCALLBACK(int) ahciR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
5665{
5666 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
5667 PAHCIPort pAhciPort = &pThis->ahciPort[iLUN];
5668 int rc;
5669
5670 Log(("%s:\n", __FUNCTION__));
5671
5672 /* the usual paranoia */
5673 AssertMsg(iLUN < pThis->cPortsImpl, ("iLUN=%u", iLUN));
5674 AssertRelease(!pAhciPort->pDrvBase);
5675 AssertRelease(!pAhciPort->pDrvMedia);
5676 AssertRelease(!pAhciPort->pDrvMediaEx);
5677 Assert(pAhciPort->iLUN == iLUN);
5678
5679 AssertMsgReturn( pAhciPort->fHotpluggable
5680 || (fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG),
5681 ("AHCI: Port %d is not marked hotpluggable\n", pAhciPort->iLUN),
5682 VERR_INVALID_PARAMETER);
5683
5684 /*
5685 * Try attach the block device and get the interfaces,
5686 * required as well as optional.
5687 */
5688 rc = PDMDevHlpDriverAttach(pDevIns, pAhciPort->iLUN, &pAhciPort->IBase, &pAhciPort->pDrvBase, NULL);
5689 if (RT_SUCCESS(rc))
5690 rc = ahciR3ConfigureLUN(pDevIns, pAhciPort);
5691 else
5692 AssertMsgFailed(("Failed to attach LUN#%d. rc=%Rrc\n", pAhciPort->iLUN, rc));
5693
5694 if (RT_FAILURE(rc))
5695 {
5696 pAhciPort->pDrvBase = NULL;
5697 pAhciPort->pDrvMedia = NULL;
5698 }
5699 else
5700 {
5701 char szName[24];
5702 RTStrPrintf(szName, sizeof(szName), "Port%d", iLUN);
5703
5704 rc = SUPSemEventCreate(pThis->pSupDrvSession, &pAhciPort->hEvtProcess);
5705 if (RT_FAILURE(rc))
5706 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
5707 N_("AHCI: Failed to create SUP event semaphore"));
5708
5709 /* Create the async IO thread. */
5710 rc = PDMDevHlpThreadCreate(pDevIns, &pAhciPort->pAsyncIOThread, pAhciPort, ahciAsyncIOLoop, ahciAsyncIOLoopWakeUp, 0,
5711 RTTHREADTYPE_IO, szName);
5712 if (RT_FAILURE(rc))
5713 return rc;
5714
5715 /*
5716 * Init vendor product data.
5717 */
5718 if (RT_SUCCESS(rc))
5719 rc = ahciR3VpdInit(pDevIns, pAhciPort, szName);
5720
5721 /* Inform the guest about the added device in case of hotplugging. */
5722 if ( RT_SUCCESS(rc)
5723 && !(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG))
5724 {
5725 AssertMsgReturn(pAhciPort->fHotpluggable,
5726 ("AHCI: Port %d is not marked hotpluggable\n", pAhciPort->iLUN),
5727 VERR_NOT_SUPPORTED);
5728
5729 /*
5730 * Initialize registers
5731 */
5732 ASMAtomicOrU32(&pAhciPort->regCMD, AHCI_PORT_CMD_CPS);
5733 ASMAtomicOrU32(&pAhciPort->regIS, AHCI_PORT_IS_CPDS | AHCI_PORT_IS_PRCS | AHCI_PORT_IS_PCS);
5734 ASMAtomicOrU32(&pAhciPort->regSERR, AHCI_PORT_SERR_X | AHCI_PORT_SERR_N);
5735
5736 if (pAhciPort->fATAPI)
5737 pAhciPort->regSIG = AHCI_PORT_SIG_ATAPI;
5738 else
5739 pAhciPort->regSIG = AHCI_PORT_SIG_DISK;
5740 pAhciPort->regSSTS = (0x01 << 8) | /* Interface is active. */
5741 (0x02 << 4) | /* Generation 2 (3.0GBps) speed. */
5742 (0x03 << 0); /* Device detected and communication established. */
5743
5744 if ( (pAhciPort->regIE & AHCI_PORT_IE_CPDE)
5745 || (pAhciPort->regIE & AHCI_PORT_IE_PCE)
5746 || (pAhciPort->regIE & AHCI_PORT_IE_PRCE))
5747 ahciHbaSetInterrupt(pAhciPort->CTX_SUFF(pAhci), pAhciPort->iLUN, VERR_IGNORED);
5748 }
5749
5750 }
5751
5752 return rc;
5753}
5754
5755/**
5756 * Common reset worker.
5757 *
5758 * @param pDevIns The device instance data.
5759 */
5760static int ahciR3ResetCommon(PPDMDEVINS pDevIns)
5761{
5762 PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
5763
5764 ahciHBAReset(pAhci);
5765
5766 /* Hardware reset for the ports. */
5767 for (uint32_t i = 0; i < RT_ELEMENTS(pAhci->ahciPort); i++)
5768 ahciPortHwReset(&pAhci->ahciPort[i]);
5769 return VINF_SUCCESS;
5770}
5771
5772/**
5773 * Callback employed by ahciR3Reset.
5774 *
5775 * @returns true if we've quiesced, false if we're still working.
5776 * @param pDevIns The device instance.
5777 */
5778static DECLCALLBACK(bool) ahciR3IsAsyncResetDone(PPDMDEVINS pDevIns)
5779{
5780 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
5781
5782 if (!ahciR3AllAsyncIOIsFinished(pDevIns))
5783 return false;
5784 ASMAtomicWriteBool(&pThis->fSignalIdle, false);
5785
5786 ahciR3ResetCommon(pDevIns);
5787 return true;
5788}
5789
5790/**
5791 * Reset notification.
5792 *
5793 * @param pDevIns The device instance data.
5794 */
5795static DECLCALLBACK(void) ahciR3Reset(PPDMDEVINS pDevIns)
5796{
5797 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
5798
5799 ASMAtomicWriteBool(&pThis->fSignalIdle, true);
5800 if (!ahciR3AllAsyncIOIsFinished(pDevIns))
5801 PDMDevHlpSetAsyncNotification(pDevIns, ahciR3IsAsyncResetDone);
5802 else
5803 {
5804 ASMAtomicWriteBool(&pThis->fSignalIdle, false);
5805 ahciR3ResetCommon(pDevIns);
5806 }
5807}
5808
5809/**
5810 * Poweroff notification.
5811 *
5812 * @param pDevIns Pointer to the device instance
5813 */
5814static DECLCALLBACK(void) ahciR3PowerOff(PPDMDEVINS pDevIns)
5815{
5816 Log(("achiR3PowerOff\n"));
5817 ahciR3SuspendOrPowerOff(pDevIns);
5818}
5819
5820/**
5821 * Destroy a driver instance.
5822 *
5823 * Most VM resources are freed by the VM. This callback is provided so that any non-VM
5824 * resources can be freed correctly.
5825 *
5826 * @param pDevIns The device instance data.
5827 */
5828static DECLCALLBACK(int) ahciR3Destruct(PPDMDEVINS pDevIns)
5829{
5830 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
5831 int rc = VINF_SUCCESS;
5832 PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
5833
5834 /*
5835 * At this point the async I/O thread is suspended and will not enter
5836 * this module again. So, no coordination is needed here and PDM
5837 * will take care of terminating and cleaning up the thread.
5838 */
5839 if (PDMCritSectIsInitialized(&pThis->lock))
5840 {
5841 TMR3TimerDestroy(pThis->CTX_SUFF(pHbaCccTimer));
5842 pThis->CTX_SUFF(pHbaCccTimer) = NULL;
5843
5844 Log(("%s: Destruct every port\n", __FUNCTION__));
5845 for (unsigned iActPort = 0; iActPort < pThis->cPortsImpl; iActPort++)
5846 {
5847 PAHCIPort pAhciPort = &pThis->ahciPort[iActPort];
5848
5849 if (pAhciPort->hEvtProcess != NIL_SUPSEMEVENT)
5850 {
5851 SUPSemEventClose(pThis->pSupDrvSession, pAhciPort->hEvtProcess);
5852 pAhciPort->hEvtProcess = NIL_SUPSEMEVENT;
5853 }
5854 }
5855
5856 PDMR3CritSectDelete(&pThis->lock);
5857 }
5858
5859 return rc;
5860}
5861
5862/**
5863 * @interface_method_impl{PDMDEVREG,pfnConstruct}
5864 */
5865static DECLCALLBACK(int) ahciR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
5866{
5867 PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
5868 PPDMIBASE pBase;
5869 int rc = VINF_SUCCESS;
5870 unsigned i = 0;
5871 bool fGCEnabled = false;
5872 bool fR0Enabled = false;
5873 uint32_t cbTotalBufferSize = 0;
5874 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
5875
5876 LogFlowFunc(("pThis=%#p\n", pThis));
5877
5878 /*
5879 * Validate and read configuration.
5880 */
5881 if (!CFGMR3AreValuesValid(pCfg, "GCEnabled\0"
5882 "R0Enabled\0"
5883 "PrimaryMaster\0"
5884 "PrimarySlave\0"
5885 "SecondaryMaster\0"
5886 "SecondarySlave\0"
5887 "PortCount\0"
5888 "Bootable\0"
5889 "CmdSlotsAvail\0"
5890 "TigerHack\0"))
5891 return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
5892 N_("AHCI configuration error: unknown option specified"));
5893
5894 rc = CFGMR3QueryBoolDef(pCfg, "GCEnabled", &fGCEnabled, true);
5895 if (RT_FAILURE(rc))
5896 return PDMDEV_SET_ERROR(pDevIns, rc,
5897 N_("AHCI configuration error: failed to read GCEnabled as boolean"));
5898 Log(("%s: fGCEnabled=%d\n", __FUNCTION__, fGCEnabled));
5899
5900 rc = CFGMR3QueryBoolDef(pCfg, "R0Enabled", &fR0Enabled, true);
5901 if (RT_FAILURE(rc))
5902 return PDMDEV_SET_ERROR(pDevIns, rc,
5903 N_("AHCI configuration error: failed to read R0Enabled as boolean"));
5904 Log(("%s: fR0Enabled=%d\n", __FUNCTION__, fR0Enabled));
5905
5906 rc = CFGMR3QueryU32Def(pCfg, "PortCount", &pThis->cPortsImpl, AHCI_MAX_NR_PORTS_IMPL);
5907 if (RT_FAILURE(rc))
5908 return PDMDEV_SET_ERROR(pDevIns, rc,
5909 N_("AHCI configuration error: failed to read PortCount as integer"));
5910 Log(("%s: cPortsImpl=%u\n", __FUNCTION__, pThis->cPortsImpl));
5911 if (pThis->cPortsImpl > AHCI_MAX_NR_PORTS_IMPL)
5912 return PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
5913 N_("AHCI configuration error: PortCount=%u should not exceed %u"),
5914 pThis->cPortsImpl, AHCI_MAX_NR_PORTS_IMPL);
5915 if (pThis->cPortsImpl < 1)
5916 return PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
5917 N_("AHCI configuration error: PortCount=%u should be at least 1"),
5918 pThis->cPortsImpl);
5919
5920 rc = CFGMR3QueryBoolDef(pCfg, "Bootable", &pThis->fBootable, true);
5921 if (RT_FAILURE(rc))
5922 return PDMDEV_SET_ERROR(pDevIns, rc,
5923 N_("AHCI configuration error: failed to read Bootable as boolean"));
5924
5925 rc = CFGMR3QueryU32Def(pCfg, "CmdSlotsAvail", &pThis->cCmdSlotsAvail, AHCI_NR_COMMAND_SLOTS);
5926 if (RT_FAILURE(rc))
5927 return PDMDEV_SET_ERROR(pDevIns, rc,
5928 N_("AHCI configuration error: failed to read CmdSlotsAvail as integer"));
5929 Log(("%s: cCmdSlotsAvail=%u\n", __FUNCTION__, pThis->cCmdSlotsAvail));
5930 if (pThis->cCmdSlotsAvail > AHCI_NR_COMMAND_SLOTS)
5931 return PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
5932 N_("AHCI configuration error: CmdSlotsAvail=%u should not exceed %u"),
5933 pThis->cPortsImpl, AHCI_NR_COMMAND_SLOTS);
5934 if (pThis->cCmdSlotsAvail < 1)
5935 return PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
5936 N_("AHCI configuration error: CmdSlotsAvail=%u should be at least 1"),
5937 pThis->cCmdSlotsAvail);
5938 bool fTigerHack;
5939 rc = CFGMR3QueryBoolDef(pCfg, "TigerHack", &fTigerHack, false);
5940 if (RT_FAILURE(rc))
5941 return PDMDEV_SET_ERROR(pDevIns, rc, N_("AHCI configuration error: failed to read TigerHack as boolean"));
5942
5943 /*
5944 * Initialize the instance data (everything touched by the destructor need
5945 * to be initialized here!).
5946 */
5947 pThis->fR0Enabled = fR0Enabled;
5948 pThis->fGCEnabled = fGCEnabled;
5949 pThis->pDevInsR3 = pDevIns;
5950 pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
5951 pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
5952 pThis->pSupDrvSession = PDMDevHlpGetSupDrvSession(pDevIns);
5953
5954 PCIDevSetVendorId (&pThis->dev, 0x8086); /* Intel */
5955 PCIDevSetDeviceId (&pThis->dev, 0x2829); /* ICH-8M */
5956 PCIDevSetCommand (&pThis->dev, 0x0000);
5957#ifdef VBOX_WITH_MSI_DEVICES
5958 PCIDevSetStatus (&pThis->dev, VBOX_PCI_STATUS_CAP_LIST);
5959 PCIDevSetCapabilityList(&pThis->dev, 0x80);
5960#else
5961 PCIDevSetCapabilityList(&pThis->dev, 0x70);
5962#endif
5963 PCIDevSetRevisionId (&pThis->dev, 0x02);
5964 PCIDevSetClassProg (&pThis->dev, 0x01);
5965 PCIDevSetClassSub (&pThis->dev, 0x06);
5966 PCIDevSetClassBase (&pThis->dev, 0x01);
5967 PCIDevSetBaseAddress (&pThis->dev, 5, false, false, false, 0x00000000);
5968
5969 PCIDevSetInterruptLine(&pThis->dev, 0x00);
5970 PCIDevSetInterruptPin (&pThis->dev, 0x01);
5971
5972 pThis->dev.abConfig[0x70] = VBOX_PCI_CAP_ID_PM; /* Capability ID: PCI Power Management Interface */
5973 pThis->dev.abConfig[0x71] = 0xa8; /* next */
5974 pThis->dev.abConfig[0x72] = 0x03; /* version ? */
5975
5976 pThis->dev.abConfig[0x90] = 0x40; /* AHCI mode. */
5977 pThis->dev.abConfig[0x92] = 0x3f;
5978 pThis->dev.abConfig[0x94] = 0x80;
5979 pThis->dev.abConfig[0x95] = 0x01;
5980 pThis->dev.abConfig[0x97] = 0x78;
5981
5982 pThis->dev.abConfig[0xa8] = 0x12; /* SATACR capability */
5983 pThis->dev.abConfig[0xa9] = 0x00; /* next */
5984 PCIDevSetWord(&pThis->dev, 0xaa, 0x0010); /* Revision */
5985 PCIDevSetDWord(&pThis->dev, 0xac, 0x00000028); /* SATA Capability Register 1 */
5986
5987 pThis->cThreadsActive = 0;
5988
5989 /* Initialize port members. */
5990 for (i = 0; i < AHCI_MAX_NR_PORTS_IMPL; i++)
5991 {
5992 PAHCIPort pAhciPort = &pThis->ahciPort[i];
5993 pAhciPort->pDevInsR3 = pDevIns;
5994 pAhciPort->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
5995 pAhciPort->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
5996 pAhciPort->iLUN = i;
5997 pAhciPort->pAhciR3 = pThis;
5998 pAhciPort->pAhciR0 = PDMINS_2_DATA_R0PTR(pDevIns);
5999 pAhciPort->pAhciRC = PDMINS_2_DATA_RCPTR(pDevIns);
6000 pAhciPort->Led.u32Magic = PDMLED_MAGIC;
6001 pAhciPort->pDrvBase = NULL;
6002 pAhciPort->pAsyncIOThread = NULL;
6003 pAhciPort->hEvtProcess = NIL_SUPSEMEVENT;
6004 pAhciPort->fHotpluggable = true;
6005 }
6006
6007 /*
6008 * Init locks, using explicit locking where necessary.
6009 */
6010 rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns));
6011 if (RT_FAILURE(rc))
6012 return rc;
6013
6014 rc = PDMDevHlpCritSectInit(pDevIns, &pThis->lock, RT_SRC_POS, "AHCI#%u", iInstance);
6015 if (RT_FAILURE(rc))
6016 {
6017 Log(("%s: Failed to create critical section.\n", __FUNCTION__));
6018 return rc;
6019 }
6020
6021 /*
6022 * Register the PCI device, it's I/O regions.
6023 */
6024 rc = PDMDevHlpPCIRegister (pDevIns, &pThis->dev);
6025 if (RT_FAILURE(rc))
6026 return rc;
6027
6028#ifdef VBOX_WITH_MSI_DEVICES
6029 PDMMSIREG MsiReg;
6030 RT_ZERO(MsiReg);
6031 MsiReg.cMsiVectors = 1;
6032 MsiReg.iMsiCapOffset = 0x80;
6033 MsiReg.iMsiNextOffset = 0x70;
6034 rc = PDMDevHlpPCIRegisterMsi(pDevIns, &MsiReg);
6035 if (RT_FAILURE(rc))
6036 {
6037 PCIDevSetCapabilityList(&pThis->dev, 0x70);
6038 /* That's OK, we can work without MSI */
6039 }
6040#endif
6041
6042 /*
6043 * Solaris 10 U5 fails to map the AHCI register space when the sets (0..5) for the legacy
6044 * IDE registers are not available.
6045 * We set up "fake" entries in the PCI configuration register.
6046 * That means they are available but read and writes from/to them have no effect.
6047 * No guest should access them anyway because the controller is marked as AHCI in the Programming interface
6048 * and we don't have an option to change to IDE emulation (real hardware provides an option in the BIOS
6049 * to switch to it which also changes device Id and other things in the PCI configuration space).
6050 */
6051 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 8, PCI_ADDRESS_SPACE_IO, ahciR3LegacyFakeIORangeMap);
6052 if (RT_FAILURE(rc))
6053 return PDMDEV_SET_ERROR(pDevIns, rc,
6054 N_("AHCI cannot register PCI I/O region"));
6055
6056 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 1, 1, PCI_ADDRESS_SPACE_IO, ahciR3LegacyFakeIORangeMap);
6057 if (RT_FAILURE(rc))
6058 return PDMDEV_SET_ERROR(pDevIns, rc,
6059 N_("AHCI cannot register PCI I/O region"));
6060
6061 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, 8, PCI_ADDRESS_SPACE_IO, ahciR3LegacyFakeIORangeMap);
6062 if (RT_FAILURE(rc))
6063 return PDMDEV_SET_ERROR(pDevIns, rc,
6064 N_("AHCI cannot register PCI I/O region"));
6065
6066 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 3, 1, PCI_ADDRESS_SPACE_IO, ahciR3LegacyFakeIORangeMap);
6067 if (RT_FAILURE(rc))
6068 return PDMDEV_SET_ERROR(pDevIns, rc,
6069 N_("AHCI cannot register PCI I/O region"));
6070
6071 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 4, 0x10, PCI_ADDRESS_SPACE_IO, ahciR3IdxDataIORangeMap);
6072 if (RT_FAILURE(rc))
6073 return PDMDEV_SET_ERROR(pDevIns, rc,
6074 N_("AHCI cannot register PCI I/O region for BMDMA"));
6075
6076 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 5, 4352, PCI_ADDRESS_SPACE_MEM, ahciR3MMIOMap);
6077 if (RT_FAILURE(rc))
6078 return PDMDEV_SET_ERROR(pDevIns, rc,
6079 N_("AHCI cannot register PCI memory region for registers"));
6080
6081 /* Create the timer for command completion coalescing feature. */
6082 rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ahciCccTimer, pThis,
6083 TMTIMER_FLAGS_NO_CRIT_SECT, "AHCI CCC Timer", &pThis->pHbaCccTimerR3);
6084 if (RT_FAILURE(rc))
6085 {
6086 AssertMsgFailed(("pfnTMTimerCreate -> %Rrc\n", rc));
6087 return rc;
6088 }
6089 pThis->pHbaCccTimerR0 = TMTimerR0Ptr(pThis->pHbaCccTimerR3);
6090 pThis->pHbaCccTimerRC = TMTimerRCPtr(pThis->pHbaCccTimerR3);
6091
6092 /* Status LUN. */
6093 pThis->IBase.pfnQueryInterface = ahciR3Status_QueryInterface;
6094 pThis->ILeds.pfnQueryStatusLed = ahciR3Status_QueryStatusLed;
6095
6096 /*
6097 * Create the notification queue.
6098 *
6099 * We need 2 items for every port because of SMP races.
6100 */
6101 rc = PDMDevHlpQueueCreate(pDevIns, sizeof(DEVPORTNOTIFIERQUEUEITEM), AHCI_MAX_NR_PORTS_IMPL * 2, 0,
6102 ahciNotifyQueueConsumer, true, "AHCI-Xmit", &pThis->pNotifierQueueR3);
6103 if (RT_FAILURE(rc))
6104 return rc;
6105 pThis->pNotifierQueueR0 = PDMQueueR0Ptr(pThis->pNotifierQueueR3);
6106 pThis->pNotifierQueueRC = PDMQueueRCPtr(pThis->pNotifierQueueR3);
6107
6108 /* Initialize static members on every port. */
6109 for (i = 0; i < AHCI_MAX_NR_PORTS_IMPL; i++)
6110 ahciPortHwReset(&pThis->ahciPort[i]);
6111
6112 /* Attach drivers to every available port. */
6113 for (i = 0; i < pThis->cPortsImpl; i++)
6114 {
6115 char *pszName;
6116 if (RTStrAPrintf(&pszName, "Port%u", i) <= 0)
6117 AssertLogRelFailedReturn(VERR_NO_MEMORY);
6118
6119 PAHCIPort pAhciPort = &pThis->ahciPort[i];
6120 /*
6121 * Init interfaces.
6122 */
6123 pAhciPort->IBase.pfnQueryInterface = ahciR3PortQueryInterface;
6124 pAhciPort->IMediaExPort.pfnIoReqCompleteNotify = ahciR3IoReqCompleteNotify;
6125 pAhciPort->IMediaExPort.pfnIoReqCopyFromBuf = ahciR3IoReqCopyFromBuf;
6126 pAhciPort->IMediaExPort.pfnIoReqCopyToBuf = ahciR3IoReqCopyToBuf;
6127 pAhciPort->IMediaExPort.pfnIoReqQueryBuf = ahciR3IoReqQueryBuf;
6128 pAhciPort->IMediaExPort.pfnIoReqQueryDiscardRanges = ahciR3IoReqQueryDiscardRanges;
6129 pAhciPort->IMediaExPort.pfnIoReqStateChanged = ahciR3IoReqStateChanged;
6130 pAhciPort->IMediaExPort.pfnMediumEjected = ahciR3MediumEjected;
6131 pAhciPort->IPort.pfnQueryDeviceLocation = ahciR3PortQueryDeviceLocation;
6132 pAhciPort->IPort.pfnQueryScsiInqStrings = ahciR3PortQueryScsiInqStrings;
6133 pAhciPort->fWrkThreadSleeping = true;
6134
6135 /* Query per port configuration options if available. */
6136 PCFGMNODE pCfgPort = CFGMR3GetChild(pDevIns->pCfg, pszName);
6137 if (pCfgPort)
6138 {
6139 rc = CFGMR3QueryBoolDef(pCfgPort, "Hotpluggable", &pAhciPort->fHotpluggable, true);
6140 if (RT_FAILURE(rc))
6141 return PDMDEV_SET_ERROR(pDevIns, rc,
6142 N_("AHCI configuration error: failed to read Hotpluggable as boolean"));
6143 }
6144
6145 /*
6146 * Attach the block driver
6147 */
6148 rc = PDMDevHlpDriverAttach(pDevIns, pAhciPort->iLUN, &pAhciPort->IBase, &pAhciPort->pDrvBase, pszName);
6149 if (RT_SUCCESS(rc))
6150 {
6151 rc = ahciR3ConfigureLUN(pDevIns, pAhciPort);
6152 if (RT_FAILURE(rc))
6153 {
6154 Log(("%s: Failed to configure the %s.\n", __FUNCTION__, pszName));
6155 return rc;
6156 }
6157
6158 /* Mark that a device is present on that port */
6159 if (i < 6)
6160 pThis->dev.abConfig[0x93] |= (1 << i);
6161
6162 /*
6163 * Init vendor product data.
6164 */
6165 rc = ahciR3VpdInit(pDevIns, pAhciPort, pszName);
6166 if (RT_FAILURE(rc))
6167 return rc;
6168
6169 rc = SUPSemEventCreate(pThis->pSupDrvSession, &pAhciPort->hEvtProcess);
6170 if (RT_FAILURE(rc))
6171 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
6172 N_("AHCI: Failed to create SUP event semaphore"));
6173
6174 rc = PDMDevHlpThreadCreate(pDevIns, &pAhciPort->pAsyncIOThread, pAhciPort, ahciAsyncIOLoop,
6175 ahciAsyncIOLoopWakeUp, 0, RTTHREADTYPE_IO, pszName);
6176 if (RT_FAILURE(rc))
6177 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
6178 N_("AHCI: Failed to create worker thread %s"), pszName);
6179 }
6180 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
6181 {
6182 pAhciPort->pDrvBase = NULL;
6183 rc = VINF_SUCCESS;
6184 LogRel(("AHCI: %s: No driver attached\n", pszName));
6185 }
6186 else
6187 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
6188 N_("AHCI: Failed to attach drive to %s"), pszName);
6189 }
6190
6191 /*
6192 * Attach status driver (optional).
6193 */
6194 rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
6195 if (RT_SUCCESS(rc))
6196 {
6197 pThis->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
6198 pThis->pMediaNotify = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIANOTIFY);
6199 }
6200 else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
6201 {
6202 AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
6203 return PDMDEV_SET_ERROR(pDevIns, rc, N_("AHCI cannot attach to status driver"));
6204 }
6205 rc = PDMDevHlpSSMRegisterEx(pDevIns, AHCI_SAVED_STATE_VERSION, sizeof(*pThis) + cbTotalBufferSize, NULL,
6206 NULL, ahciR3LiveExec, NULL,
6207 ahciR3SavePrep, ahciR3SaveExec, NULL,
6208 ahciR3LoadPrep, ahciR3LoadExec, NULL);
6209 if (RT_FAILURE(rc))
6210 return rc;
6211
6212 /*
6213 * Register the info item.
6214 */
6215 char szTmp[128];
6216 RTStrPrintf(szTmp, sizeof(szTmp), "%s%d", pDevIns->pReg->szName, pDevIns->iInstance);
6217 PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "AHCI info", ahciR3Info);
6218
6219 return ahciR3ResetCommon(pDevIns);
6220}
6221
6222/**
6223 * The device registration structure.
6224 */
6225const PDMDEVREG g_DeviceAHCI =
6226{
6227 /* u32Version */
6228 PDM_DEVREG_VERSION,
6229 /* szName */
6230 "ahci",
6231 /* szRCMod */
6232 "VBoxDDRC.rc",
6233 /* szR0Mod */
6234 "VBoxDDR0.r0",
6235 /* pszDescription */
6236 "Intel AHCI controller.\n",
6237 /* fFlags */
6238 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0 |
6239 PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION | PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION |
6240 PDM_DEVREG_FLAGS_FIRST_RESET_NOTIFICATION,
6241 /* fClass */
6242 PDM_DEVREG_CLASS_STORAGE,
6243 /* cMaxInstances */
6244 ~0U,
6245 /* cbInstance */
6246 sizeof(AHCI),
6247 /* pfnConstruct */
6248 ahciR3Construct,
6249 /* pfnDestruct */
6250 ahciR3Destruct,
6251 /* pfnRelocate */
6252 ahciR3Relocate,
6253 /* pfnMemSetup */
6254 NULL,
6255 /* pfnPowerOn */
6256 NULL,
6257 /* pfnReset */
6258 ahciR3Reset,
6259 /* pfnSuspend */
6260 ahciR3Suspend,
6261 /* pfnResume */
6262 ahciR3Resume,
6263 /* pfnAttach */
6264 ahciR3Attach,
6265 /* pfnDetach */
6266 ahciR3Detach,
6267 /* pfnQueryInterface. */
6268 NULL,
6269 /* pfnInitComplete */
6270 NULL,
6271 /* pfnPowerOff */
6272 ahciR3PowerOff,
6273 /* pfnSoftReset */
6274 NULL,
6275 /* u32VersionEnd */
6276 PDM_DEVREG_VERSION
6277};
6278
6279#endif /* IN_RING3 */
6280#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette