DevBusLogic.cpp@ 89197

Last change on this file since 89197 was 89197, checked in by vboxsync, 4 years ago
Devices/Storage/DevBusLogic,Devices/testcase: Get rid of the VBoxSCSI interface now that we have proper drivers in the BIOS, bugref:4841
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 171.7 KB

Line
1	/* $Id: DevBusLogic.cpp 89197 2021-05-20 09:51:01Z vboxsync $ */
2	/** @file
3	* VBox storage devices - BusLogic SCSI host adapter BT-958.
4	*
5	* Based on the Multi-Master Ultra SCSI Systems Technical Reference Manual.
6	*/
7
8	/*
9	* Copyright (C) 2006-2020 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
21	/*********************************************************************************************************************************
22	* Header Files *
23	*********************************************************************************************************************************/
24	#define LOG_GROUP LOG_GROUP_DEV_BUSLOGIC
25	#include <VBox/vmm/pdmdev.h>
26	#include <VBox/vmm/pdmstorageifs.h>
27	#include <VBox/vmm/pdmcritsect.h>
28	#include <VBox/AssertGuest.h>
29	#include <VBox/scsi.h>
30	#include <iprt/asm.h>
31	#include <iprt/assert.h>
32	#include <iprt/string.h>
33	#include <iprt/log.h>
34	#ifdef IN_RING3
35	# include <iprt/alloc.h>
36	# include <iprt/memcache.h>
37	# include <iprt/param.h>
38	# include <iprt/uuid.h>
39	#endif
40
41	#include "VBoxSCSI.h"
42	#include "VBoxDD.h"
43
44
45	/*********************************************************************************************************************************
46	* Defined Constants And Macros *
47	*********************************************************************************************************************************/
48	/** Maximum number of attached devices the adapter can handle. */
49	#define BUSLOGIC_MAX_DEVICES 16
50
51	/** Maximum number of scatter gather elements this device can handle. */
52	#define BUSLOGIC_MAX_SCATTER_GATHER_LIST_SIZE 128
53
54	/** Size of the command buffer. */
55	#define BUSLOGIC_COMMAND_SIZE_MAX 53
56
57	/** Size of the reply buffer. */
58	#define BUSLOGIC_REPLY_SIZE_MAX 64
59
60	/** Custom fixed I/O ports for BIOS controller access.
61	* Note that these should not be in the ISA range (below 400h) to avoid
62	* conflicts with ISA device probing. Addresses in the 300h-340h range should be
63	* especially avoided.
64	*/
65	#define BUSLOGIC_BIOS_IO_PORT 0x430
66
67	/** State saved version. */
68	#define BUSLOGIC_SAVED_STATE_MINOR_VERSION 5
69	/** Saved state version before VBoxSCSI got removed. */
70	#define BUSLOGIC_SAVED_STATE_MINOR_PRE_VBOXSCSI_REMOVAL 4
71	/** Saved state version before command buffer size was raised. */
72	#define BUSLOGIC_SAVED_STATE_MINOR_PRE_CMDBUF_RESIZE 3
73	/** Saved state version before 24-bit mailbox support was implemented. */
74	#define BUSLOGIC_SAVED_STATE_MINOR_PRE_24BIT_MBOX 2
75	/** Saved state version before the suspend on error feature was implemented. */
76	#define BUSLOGIC_SAVED_STATE_MINOR_PRE_ERROR_HANDLING 1
77
78	/** Command buffer size in old saved states. */
79	#define BUSLOGIC_COMMAND_SIZE_OLD 5
80
81	/** The duration of software-initiated reset (in nano seconds).
82	* Not documented, set to 50 ms. */
83	#define BUSLOGIC_RESET_DURATION_NS UINT64_C(50000000)
84
85
86	/*********************************************************************************************************************************
87	* Structures and Typedefs *
88	*********************************************************************************************************************************/
89	/**
90	* State of a device attached to the buslogic host adapter.
91	*
92	* @implements PDMIBASE
93	* @implements PDMISCSIPORT
94	* @implements PDMILEDPORTS
95	*/
96	typedef struct BUSLOGICDEVICE
97	{
98	/** The ring-3 device instance (for getting our bearings when arriving in an
99	* interface method). */
100	PPDMDEVINSR3 pDevIns;
101
102	/** LUN of the device. */
103	uint32_t iLUN;
104
105	/** Flag whether device is present.
106	* @note This is mirrored in BUSLOGIC::afDevicePresent. */
107	bool fPresent;
108	bool afAlignment[3];
109
110	/** Our base interface. */
111	PDMIBASE IBase;
112	/** Media port interface. */
113	PDMIMEDIAPORT IMediaPort;
114	/** Extended media port interface. */
115	PDMIMEDIAEXPORT IMediaExPort;
116	/** Led interface. */
117	PDMILEDPORTS ILed;
118	/** Pointer to the attached driver's base interface. */
119	R3PTRTYPE(PPDMIBASE) pDrvBase;
120	/** Pointer to the attached driver's media interface. */
121	R3PTRTYPE(PPDMIMEDIA) pDrvMedia;
122	/** Pointer to the attached driver's extended media interface. */
123	R3PTRTYPE(PPDMIMEDIAEX) pDrvMediaEx;
124	/** The status LED state for this device. */
125	PDMLED Led;
126
127	/** Number of outstanding tasks on the port. */
128	volatile uint32_t cOutstandingRequests;
129	/** The device name. */
130	char szName[12];
131	} BUSLOGICDEVICE, *PBUSLOGICDEVICE;
132
133	/**
134	* Commands the BusLogic adapter supports.
135	*/
136	enum BUSLOGICCOMMAND
137	{
138	BUSLOGICCOMMAND_TEST_CMDC_INTERRUPT = 0x00,
139	BUSLOGICCOMMAND_INITIALIZE_MAILBOX = 0x01,
140	BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND = 0x02,
141	BUSLOGICCOMMAND_EXECUTE_BIOS_COMMAND = 0x03,
142	BUSLOGICCOMMAND_INQUIRE_BOARD_ID = 0x04,
143	BUSLOGICCOMMAND_ENABLE_OUTGOING_MAILBOX_AVAILABLE_INTERRUPT = 0x05,
144	BUSLOGICCOMMAND_SET_SCSI_SELECTION_TIMEOUT = 0x06,
145	BUSLOGICCOMMAND_SET_PREEMPT_TIME_ON_BUS = 0x07,
146	BUSLOGICCOMMAND_SET_TIME_OFF_BUS = 0x08,
147	BUSLOGICCOMMAND_SET_BUS_TRANSFER_RATE = 0x09,
148	BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_0_TO_7 = 0x0a,
149	BUSLOGICCOMMAND_INQUIRE_CONFIGURATION = 0x0b,
150	BUSLOGICCOMMAND_ENABLE_TARGET_MODE = 0x0c,
151	BUSLOGICCOMMAND_INQUIRE_SETUP_INFORMATION = 0x0d,
152	BUSLOGICCOMMAND_WRITE_ADAPTER_LOCAL_RAM = 0x1a,
153	BUSLOGICCOMMAND_READ_ADAPTER_LOCAL_RAM = 0x1b,
154	BUSLOGICCOMMAND_WRITE_BUSMASTER_CHIP_FIFO = 0x1c,
155	BUSLOGICCOMMAND_READ_BUSMASTER_CHIP_FIFO = 0x1d,
156	BUSLOGICCOMMAND_ECHO_COMMAND_DATA = 0x1f,
157	BUSLOGICCOMMAND_HOST_ADAPTER_DIAGNOSTIC = 0x20,
158	BUSLOGICCOMMAND_SET_ADAPTER_OPTIONS = 0x21,
159	BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_8_TO_15 = 0x23,
160	BUSLOGICCOMMAND_INQUIRE_TARGET_DEVICES = 0x24,
161	BUSLOGICCOMMAND_DISABLE_HOST_ADAPTER_INTERRUPT = 0x25,
162	BUSLOGICCOMMAND_EXT_BIOS_INFO = 0x28,
163	BUSLOGICCOMMAND_UNLOCK_MAILBOX = 0x29,
164	BUSLOGICCOMMAND_INITIALIZE_EXTENDED_MAILBOX = 0x81,
165	BUSLOGICCOMMAND_EXECUTE_SCSI_COMMAND = 0x83,
166	BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_3RD_LETTER = 0x84,
167	BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_LETTER = 0x85,
168	BUSLOGICCOMMAND_INQUIRE_PCI_HOST_ADAPTER_INFORMATION = 0x86,
169	BUSLOGICCOMMAND_INQUIRE_HOST_ADAPTER_MODEL_NUMBER = 0x8b,
170	BUSLOGICCOMMAND_INQUIRE_SYNCHRONOUS_PERIOD = 0x8c,
171	BUSLOGICCOMMAND_INQUIRE_EXTENDED_SETUP_INFORMATION = 0x8d,
172	BUSLOGICCOMMAND_ENABLE_STRICT_ROUND_ROBIN_MODE = 0x8f,
173	BUSLOGICCOMMAND_STORE_HOST_ADAPTER_LOCAL_RAM = 0x90,
174	BUSLOGICCOMMAND_FETCH_HOST_ADAPTER_LOCAL_RAM = 0x91,
175	BUSLOGICCOMMAND_STORE_LOCAL_DATA_IN_EEPROM = 0x92,
176	BUSLOGICCOMMAND_UPLOAD_AUTO_SCSI_CODE = 0x94,
177	BUSLOGICCOMMAND_MODIFY_IO_ADDRESS = 0x95,
178	BUSLOGICCOMMAND_SET_CCB_FORMAT = 0x96,
179	BUSLOGICCOMMAND_WRITE_INQUIRY_BUFFER = 0x9a,
180	BUSLOGICCOMMAND_READ_INQUIRY_BUFFER = 0x9b,
181	BUSLOGICCOMMAND_FLASH_ROM_UPLOAD_DOWNLOAD = 0xa7,
182	BUSLOGICCOMMAND_READ_SCAM_DATA = 0xa8,
183	BUSLOGICCOMMAND_WRITE_SCAM_DATA = 0xa9
184	} BUSLOGICCOMMAND;
185
186	#pragma pack(1)
187	/**
188	* Auto SCSI structure which is located
189	* in host adapter RAM and contains several
190	* configuration parameters.
191	*/
192	typedef struct AutoSCSIRam
193	{
194	uint8_t aInternalSignature[2];
195	uint8_t cbInformation;
196	uint8_t aHostAdaptertype[6];
197	uint8_t uReserved1;
198	bool fFloppyEnabled : 1;
199	bool fFloppySecondary : 1;
200	bool fLevelSensitiveInterrupt : 1;
201	unsigned char uReserved2 : 2;
202	unsigned char uSystemRAMAreForBIOS : 3;
203	unsigned char uDMAChannel : 7;
204	bool fDMAAutoConfiguration : 1;
205	unsigned char uIrqChannel : 7;
206	bool fIrqAutoConfiguration : 1;
207	uint8_t uDMATransferRate;
208	uint8_t uSCSIId;
209	bool fLowByteTerminated : 1;
210	bool fParityCheckingEnabled : 1;
211	bool fHighByteTerminated : 1;
212	bool fNoisyCablingEnvironment : 1;
213	bool fFastSynchronousNeogtiation : 1;
214	bool fBusResetEnabled : 1;
215	bool fReserved3 : 1;
216	bool fActiveNegotiationEnabled : 1;
217	uint8_t uBusOnDelay;
218	uint8_t uBusOffDelay;
219	bool fHostAdapterBIOSEnabled : 1;
220	bool fBIOSRedirectionOfInt19 : 1;
221	bool fExtendedTranslation : 1;
222	bool fMapRemovableAsFixed : 1;
223	bool fReserved4 : 1;
224	bool fBIOSSupportsMoreThan2Drives : 1;
225	bool fBIOSInterruptMode : 1;
226	bool fFlopticalSupport : 1;
227	uint16_t u16DeviceEnabledMask;
228	uint16_t u16WidePermittedMask;
229	uint16_t u16FastPermittedMask;
230	uint16_t u16SynchronousPermittedMask;
231	uint16_t u16DisconnectPermittedMask;
232	uint16_t u16SendStartUnitCommandMask;
233	uint16_t u16IgnoreInBIOSScanMask;
234	unsigned char uPCIInterruptPin : 2;
235	unsigned char uHostAdapterIoPortAddress : 2;
236	bool fStrictRoundRobinMode : 1;
237	bool fVesaBusSpeedGreaterThan33MHz : 1;
238	bool fVesaBurstWrite : 1;
239	bool fVesaBurstRead : 1;
240	uint16_t u16UltraPermittedMask;
241	uint32_t uReserved5;
242	uint8_t uReserved6;
243	uint8_t uAutoSCSIMaximumLUN;
244	bool fReserved7 : 1;
245	bool fSCAMDominant : 1;
246	bool fSCAMenabled : 1;
247	bool fSCAMLevel2 : 1;
248	unsigned char uReserved8 : 4;
249	bool fInt13Extension : 1;
250	bool fReserved9 : 1;
251	bool fCDROMBoot : 1;
252	unsigned char uReserved10 : 5;
253	unsigned char uBootTargetId : 4;
254	unsigned char uBootChannel : 4;
255	bool fForceBusDeviceScanningOrder : 1;
256	unsigned char uReserved11 : 7;
257	uint16_t u16NonTaggedToAlternateLunPermittedMask;
258	uint16_t u16RenegotiateSyncAfterCheckConditionMask;
259	uint8_t aReserved12[10];
260	uint8_t aManufacturingDiagnostic[2];
261	uint16_t u16Checksum;
262	} AutoSCSIRam, *PAutoSCSIRam;
263	AssertCompileSize(AutoSCSIRam, 64);
264	#pragma pack()
265
266	/**
267	* The local Ram.
268	*/
269	typedef union HostAdapterLocalRam
270	{
271	/** Byte view. */
272	uint8_t u8View[256];
273	/** Structured view. */
274	struct
275	{
276	/** Offset 0 - 63 is for BIOS. */
277	uint8_t u8Bios[64];
278	/** Auto SCSI structure. */
279	AutoSCSIRam autoSCSIData;
280	} structured;
281	} HostAdapterLocalRam, *PHostAdapterLocalRam;
282	AssertCompileSize(HostAdapterLocalRam, 256);
283
284
285	/** Ugly 24-bit big-endian addressing. */
286	typedef struct
287	{
288	uint8_t hi;
289	uint8_t mid;
290	uint8_t lo;
291	} Addr24, Len24;
292	AssertCompileSize(Addr24, 3);
293
294	#define ADDR_TO_U32(x) (((x).hi << 16) \| ((x).mid << 8) \| (x).lo)
295	#define LEN_TO_U32 ADDR_TO_U32
296	#define U32_TO_ADDR(a, x) do {(a).hi = (x) >> 16; (a).mid = (x) >> 8; (a).lo = (x);} while(0)
297	#define U32_TO_LEN U32_TO_ADDR
298
299	/** @name Compatible ISA base I/O port addresses. Disabled if zero.
300	* @{ */
301	#define NUM_ISA_BASES 8
302	#define MAX_ISA_BASE (NUM_ISA_BASES - 1)
303	#define ISA_BASE_DISABLED 6
304
305	#ifdef IN_RING3
306	static uint16_t const g_aISABases[NUM_ISA_BASES] =
307	{
308	0x330, 0x334, 0x230, 0x234, 0x130, 0x134, 0, 0
309	};
310	#endif
311	/** @} */
312
313	/**
314	* Emulated device types.
315	*/
316	enum BL_DEVICE_TYPE
317	{
318	DEV_BT_958D = 0, /* BusLogic BT-958D, PCI. */
319	DEV_BT_545C = 1, /* BusLogic BT-545C, ISA. */
320	DEV_AHA_1540B = 2 /* Adaptec AHA-1540B, ISA. */
321	};
322
323	/** Pointer to a task state structure. */
324	typedef struct BUSLOGICREQ *PBUSLOGICREQ;
325
326	/**
327	* The shared BusLogic device emulation state.
328	*/
329	typedef struct BUSLOGIC
330	{
331	/** Status register - Readonly. */
332	volatile uint8_t regStatus;
333	/** Interrupt register - Readonly. */
334	volatile uint8_t regInterrupt;
335	/** Geometry register - Readonly. */
336	volatile uint8_t regGeometry;
337	/** Pending (delayed) interrupt. */
338	uint8_t uPendingIntr;
339
340	/** Command code the guest issued. */
341	uint8_t uOperationCode;
342	/** Current position in the command buffer. */
343	uint8_t iParameter;
344	/** Parameters left until the command is complete. */
345	uint8_t cbCommandParametersLeft;
346	/** Buffer for the command parameters the adapter is currently receiving from the guest.
347	* Size of the largest command which is possible. */
348	uint8_t aCommandBuffer[BUSLOGIC_COMMAND_SIZE_MAX]; /* Size of the biggest request. */
349
350	/** Only for LOG_ENABLED builds! */
351	volatile uint32_t cInMailboxesReadyIfLogEnabled;
352
353	/** Position in the buffer we are reading next.
354	* @note aligned on 64 byte boundrary for cache-line mojo. Means IOISABase
355	* is at offset 130. */
356	uint8_t iReply;
357	/** Bytes left until the reply buffer is empty. */
358	uint8_t cbReplyParametersLeft;
359	/** Buffer to store reply data from the controller to the guest. */
360	uint8_t aReplyBuffer[BUSLOGIC_REPLY_SIZE_MAX]; /* Size of the biggest reply. */
361
362	/** ISA I/O port base (disabled if zero). */
363	RTIOPORT IOISABase;
364	/** Default ISA I/O port base in FW-compatible format. */
365	uint8_t uDefaultISABaseCode;
366	/** Emulated device type. */
367	uint8_t uDevType;
368
369	/** Signature index for Adaptec models. */
370	uint8_t uAhaSigIdx;
371
372	/** Whether we are using the RAM or reply buffer. */
373	bool fUseLocalRam;
374
375	/** Flag whether IRQs are enabled. */
376	bool fIRQEnabled;
377	/** Flag whether 24-bit mailboxes are in use (default is 32-bit). */
378	bool fMbxIs24Bit;
379	/** ISA I/O port base (encoded in FW-compatible format). */
380	uint8_t uISABaseCode;
381	/** ISA IRQ, non-zero if in ISA mode. */
382	uint8_t uIsaIrq;
383
384	/** Number of mailboxes the guest set up. */
385	uint32_t cMailbox;
386
387	/** Time when HBA reset was last initiated. */
388	uint64_t u64ResetTime; /*< @todo does this need to be saved? /
389	/** Physical base address of the outgoing mailboxes. */
390	RTGCPHYS GCPhysAddrMailboxOutgoingBase;
391	/** Current outgoing mailbox position. */
392	uint32_t uMailboxOutgoingPositionCurrent;
393	/** Number of mailboxes ready. */
394	volatile uint32_t cMailboxesReady;
395	/** Whether a notification to R3 was sent. */
396	volatile bool fNotificationSent;
397
398	/** Whether strict round robin is enabled. */
399	bool fStrictRoundRobinMode;
400	/** Whether the extended LUN CCB format is enabled for 32 possible logical units. */
401	bool fExtendedLunCCBFormat;
402	/** Last completed command, for debugging. */
403	uint8_t uPrevCmd;
404
405	/** Current incoming mailbox position. */
406	uint32_t uMailboxIncomingPositionCurrent;
407	/** Physical base address of the incoming mailboxes. */
408	RTGCPHYS GCPhysAddrMailboxIncomingBase;
409
410	/** Critical section protecting access to the interrupt status register. */
411	PDMCRITSECT CritSectIntr;
412
413	/** Device presence indicators.
414	* @note Copy of BUSLOGICDEVICE::fPresent accessible from ring-0. */
415	bool afDevicePresent[BUSLOGIC_MAX_DEVICES];
416
417	/** The event semaphore the processing thread waits on. */
418	SUPSEMEVENT hEvtProcess;
419
420	/** ISA compatibility I/O ports. */
421	IOMIOPORTHANDLE hIoPortsIsa;
422	/** BIOS I/O ports for booting, optional. */
423	IOMIOPORTHANDLE hIoPortsBios;
424	/** PCI Region \#0: I/O ports. */
425	IOMIOPORTHANDLE hIoPortsPci;
426	/** PCI Region \#1: MMIO (32 bytes, but probably rounded up to 4KB). */
427	IOMMMIOHANDLE hMmio;
428
429	/** Local RAM for the fetch hostadapter local RAM request.
430	* I don't know how big the buffer really is but the maximum
431	* seems to be 256 bytes because the offset and count field in the command request
432	* are only one byte big.
433	*/
434	HostAdapterLocalRam LocalRam;
435	} BUSLOGIC;
436	/** Pointer to the shared BusLogic device emulation state. */
437	typedef BUSLOGIC *PBUSLOGIC;
438
439
440	/**
441	* The ring-3 BusLogic device emulation state.
442	*
443	* @implements PDMILEDPORTS
444	*/
445	typedef struct BUSLOGICR3
446	{
447	/** The device instance - only for getting our bearings in interface methods. */
448	PPDMDEVINSR3 pDevIns;
449
450	/** BusLogic device states. */
451	BUSLOGICDEVICE aDeviceStates[BUSLOGIC_MAX_DEVICES];
452
453	/** The base interface.
454	* @todo use PDMDEVINS::IBase */
455	PDMIBASE IBase;
456	/** Status Port - Leds interface. */
457	PDMILEDPORTS ILeds;
458	/** Partner of ILeds. */
459	R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
460	/** Status LUN: Media Notifys. */
461	R3PTRTYPE(PPDMIMEDIANOTIFY) pMediaNotify;
462
463	/** Indicates that PDMDevHlpAsyncNotificationCompleted should be called when
464	* a port is entering the idle state. */
465	bool volatile fSignalIdle;
466	/** Flag whether the worker thread is sleeping. */
467	volatile bool fWrkThreadSleeping;
468
469	/** Worker thread. */
470	R3PTRTYPE(PPDMTHREAD) pThreadWrk;
471
472	/** Pointer to the array of addresses to redo. */
473	R3PTRTYPE(PRTGCPHYS) paGCPhysAddrCCBRedo;
474	/** Number of addresses the redo array holds. */
475	uint32_t cReqsRedo;
476	} BUSLOGICR3;
477	/** Pointer to the ring-3 BusLogic device emulation state. */
478	typedef BUSLOGICR3 *PBUSLOGICR3;
479
480
481	/**
482	* The ring-0 BusLogic device emulation state.
483	*/
484	typedef struct BUSLOGICR0
485	{
486	uint64_t uUnused;
487	} BUSLOGICR0;
488	/** Pointer to the ring-0 BusLogic device emulation state. */
489	typedef BUSLOGICR0 *PBUSLOGICR0;
490
491
492	/**
493	* The raw-mode BusLogic device emulation state.
494	*/
495	typedef struct BUSLOGICRC
496	{
497	uint64_t uUnused;
498	} BUSLOGICRC;
499	/** Pointer to the raw-mode BusLogic device emulation state. */
500	typedef BUSLOGICRC *PBUSLOGICRC;
501
502
503	/** The current context BusLogic device emulation state. */
504	typedef CTX_SUFF(BUSLOGIC) BUSLOGICCC;
505	/** Pointer to the current context BusLogic device emulation state. */
506	typedef CTX_SUFF(PBUSLOGIC) PBUSLOGICCC;
507
508
509	/** Register offsets in the I/O port space. */
510	#define BUSLOGIC_REGISTER_CONTROL 0 /*< Writeonly /
511	/** Fields for the control register. */
512	# define BL_CTRL_RSBUS RT_BIT(4) /* Reset SCSI Bus. */
513	# define BL_CTRL_RINT RT_BIT(5) /* Reset Interrupt. */
514	# define BL_CTRL_RSOFT RT_BIT(6) /* Soft Reset. */
515	# define BL_CTRL_RHARD RT_BIT(7) /* Hard Reset. */
516
517	#define BUSLOGIC_REGISTER_STATUS 0 /*< Readonly /
518	/** Fields for the status register. */
519	# define BL_STAT_CMDINV RT_BIT(0) /* Command Invalid. */
520	# define BL_STAT_DIRRDY RT_BIT(2) /* Data In Register Ready. */
521	# define BL_STAT_CPRBSY RT_BIT(3) /* Command/Parameter Out Register Busy. */
522	# define BL_STAT_HARDY RT_BIT(4) /* Host Adapter Ready. */
523	# define BL_STAT_INREQ RT_BIT(5) /* Initialization Required. */
524	# define BL_STAT_DFAIL RT_BIT(6) /* Diagnostic Failure. */
525	# define BL_STAT_DACT RT_BIT(7) /* Diagnistic Active. */
526
527	#define BUSLOGIC_REGISTER_COMMAND 1 /*< Writeonly /
528	#define BUSLOGIC_REGISTER_DATAIN 1 /*< Readonly /
529	#define BUSLOGIC_REGISTER_INTERRUPT 2 /*< Readonly /
530	/** Fields for the interrupt register. */
531	# define BL_INTR_IMBL RT_BIT(0) /* Incoming Mailbox Loaded. */
532	# define BL_INTR_OMBR RT_BIT(1) /* Outgoing Mailbox Available. */
533	# define BL_INTR_CMDC RT_BIT(2) /* Command Complete. */
534	# define BL_INTR_RSTS RT_BIT(3) /* SCSI Bus Reset State. */
535	# define BL_INTR_INTV RT_BIT(7) /* Interrupt Valid. */
536
537	#define BUSLOGIC_REGISTER_GEOMETRY 3 /* Readonly */
538	# define BL_GEOM_XLATEN RT_BIT(7) /* Extended geometry translation enabled. */
539
540	/** Structure for the INQUIRE_PCI_HOST_ADAPTER_INFORMATION reply. */
541	typedef struct ReplyInquirePCIHostAdapterInformation
542	{
543	uint8_t IsaIOPort;
544	uint8_t IRQ;
545	unsigned char LowByteTerminated : 1;
546	unsigned char HighByteTerminated : 1;
547	unsigned char uReserved : 2; /* Reserved. */
548	unsigned char JP1 : 1; /* Whatever that means. */
549	unsigned char JP2 : 1; /* Whatever that means. */
550	unsigned char JP3 : 1; /* Whatever that means. */
551	/** Whether the provided info is valid. */
552	unsigned char InformationIsValid: 1;
553	uint8_t uReserved2; /* Reserved. */
554	} ReplyInquirePCIHostAdapterInformation, *PReplyInquirePCIHostAdapterInformation;
555	AssertCompileSize(ReplyInquirePCIHostAdapterInformation, 4);
556
557	/** Structure for the INQUIRE_CONFIGURATION reply. */
558	typedef struct ReplyInquireConfiguration
559	{
560	unsigned char uReserved1 : 5;
561	bool fDmaChannel5 : 1;
562	bool fDmaChannel6 : 1;
563	bool fDmaChannel7 : 1;
564	bool fIrqChannel9 : 1;
565	bool fIrqChannel10 : 1;
566	bool fIrqChannel11 : 1;
567	bool fIrqChannel12 : 1;
568	unsigned char uReserved2 : 1;
569	bool fIrqChannel14 : 1;
570	bool fIrqChannel15 : 1;
571	unsigned char uReserved3 : 1;
572	unsigned char uHostAdapterId : 4;
573	unsigned char uReserved4 : 4;
574	} ReplyInquireConfiguration, *PReplyInquireConfiguration;
575	AssertCompileSize(ReplyInquireConfiguration, 3);
576
577	/** Structure for the INQUIRE_SETUP_INFORMATION reply. */
578	typedef struct ReplyInquireSetupInformationSynchronousValue
579	{
580	unsigned char uOffset : 4;
581	unsigned char uTransferPeriod : 3;
582	bool fSynchronous : 1;
583	}ReplyInquireSetupInformationSynchronousValue, *PReplyInquireSetupInformationSynchronousValue;
584	AssertCompileSize(ReplyInquireSetupInformationSynchronousValue, 1);
585
586	typedef struct ReplyInquireSetupInformation
587	{
588	bool fSynchronousInitiationEnabled : 1;
589	bool fParityCheckingEnabled : 1;
590	unsigned char uReserved1 : 6;
591	uint8_t uBusTransferRate;
592	uint8_t uPreemptTimeOnBus;
593	uint8_t uTimeOffBus;
594	uint8_t cMailbox;
595	Addr24 MailboxAddress;
596	ReplyInquireSetupInformationSynchronousValue SynchronousValuesId0To7[8];
597	uint8_t uDisconnectPermittedId0To7;
598	uint8_t uSignature;
599	uint8_t uCharacterD;
600	uint8_t uHostBusType;
601	uint8_t uWideTransferPermittedId0To7;
602	uint8_t uWideTransfersActiveId0To7;
603	ReplyInquireSetupInformationSynchronousValue SynchronousValuesId8To15[8];
604	uint8_t uDisconnectPermittedId8To15;
605	uint8_t uReserved2;
606	uint8_t uWideTransferPermittedId8To15;
607	uint8_t uWideTransfersActiveId8To15;
608	} ReplyInquireSetupInformation, *PReplyInquireSetupInformation;
609	AssertCompileSize(ReplyInquireSetupInformation, 34);
610
611	/** Structure for the INQUIRE_EXTENDED_SETUP_INFORMATION. */
612	#pragma pack(1)
613	typedef struct ReplyInquireExtendedSetupInformation
614	{
615	uint8_t uBusType;
616	uint8_t uBiosAddress;
617	uint16_t u16ScatterGatherLimit;
618	uint8_t cMailbox;
619	uint32_t uMailboxAddressBase;
620	unsigned char uReserved1 : 2;
621	bool fFastEISA : 1;
622	unsigned char uReserved2 : 3;
623	bool fLevelSensitiveInterrupt : 1;
624	unsigned char uReserved3 : 1;
625	unsigned char aFirmwareRevision[3];
626	bool fHostWideSCSI : 1;
627	bool fHostDifferentialSCSI : 1;
628	bool fHostSupportsSCAM : 1;
629	bool fHostUltraSCSI : 1;
630	bool fHostSmartTermination : 1;
631	unsigned char uReserved4 : 3;
632	} ReplyInquireExtendedSetupInformation, *PReplyInquireExtendedSetupInformation;
633	AssertCompileSize(ReplyInquireExtendedSetupInformation, 14);
634	#pragma pack()
635
636	/** Structure for the INITIALIZE EXTENDED MAILBOX request. */
637	#pragma pack(1)
638	typedef struct RequestInitializeExtendedMailbox
639	{
640	/** Number of mailboxes in guest memory. */
641	uint8_t cMailbox;
642	/** Physical address of the first mailbox. */
643	uint32_t uMailboxBaseAddress;
644	} RequestInitializeExtendedMailbox, *PRequestInitializeExtendedMailbox;
645	AssertCompileSize(RequestInitializeExtendedMailbox, 5);
646	#pragma pack()
647
648	/** Structure for the INITIALIZE MAILBOX request. */
649	typedef struct
650	{
651	/** Number of mailboxes to set up. */
652	uint8_t cMailbox;
653	/** Physical address of the first mailbox. */
654	Addr24 aMailboxBaseAddr;
655	} RequestInitMbx, *PRequestInitMbx;
656	AssertCompileSize(RequestInitMbx, 4);
657
658	/**
659	* Structure of a mailbox in guest memory.
660	* The incoming and outgoing mailbox have the same size
661	* but the incoming one has some more fields defined which
662	* are marked as reserved in the outgoing one.
663	* The last field is also different from the type.
664	* For outgoing mailboxes it is the action and
665	* for incoming ones the completion status code for the task.
666	* We use one structure for both types.
667	*/
668	typedef struct Mailbox32
669	{
670	/** Physical address of the CCB structure in the guest memory. */
671	uint32_t u32PhysAddrCCB;
672	/** Type specific data. */
673	union
674	{
675	/** For outgoing mailboxes. */
676	struct
677	{
678	/** Reserved */
679	uint8_t uReserved[3];
680	/** Action code. */
681	uint8_t uActionCode;
682	} out;
683	/** For incoming mailboxes. */
684	struct
685	{
686	/** The host adapter status after finishing the request. */
687	uint8_t uHostAdapterStatus;
688	/** The status of the device which executed the request after executing it. */
689	uint8_t uTargetDeviceStatus;
690	/** Reserved. */
691	uint8_t uReserved;
692	/** The completion status code of the request. */
693	uint8_t uCompletionCode;
694	} in;
695	} u;
696	} Mailbox32, *PMailbox32;
697	AssertCompileSize(Mailbox32, 8);
698
699	/** Old style 24-bit mailbox entry. */
700	typedef struct Mailbox24
701	{
702	/** Mailbox command (incoming) or state (outgoing). */
703	uint8_t uCmdState;
704	/** Physical address of the CCB structure in the guest memory. */
705	Addr24 aPhysAddrCCB;
706	} Mailbox24, *PMailbox24;
707	AssertCompileSize(Mailbox24, 4);
708
709	/**
710	* Action codes for outgoing mailboxes.
711	*/
712	enum BUSLOGIC_MAILBOX_OUTGOING_ACTION
713	{
714	BUSLOGIC_MAILBOX_OUTGOING_ACTION_FREE = 0x00,
715	BUSLOGIC_MAILBOX_OUTGOING_ACTION_START_COMMAND = 0x01,
716	BUSLOGIC_MAILBOX_OUTGOING_ACTION_ABORT_COMMAND = 0x02
717	};
718
719	/**
720	* Completion codes for incoming mailboxes.
721	*/
722	enum BUSLOGIC_MAILBOX_INCOMING_COMPLETION
723	{
724	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_FREE = 0x00,
725	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITHOUT_ERROR = 0x01,
726	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_ABORTED = 0x02,
727	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_ABORTED_NOT_FOUND = 0x03,
728	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITH_ERROR = 0x04,
729	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_INVALID_CCB = 0x05
730	};
731
732	/**
733	* Host adapter status for incoming mailboxes.
734	*/
735	enum BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS
736	{
737	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_CMD_COMPLETED = 0x00,
738	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_LINKED_CMD_COMPLETED = 0x0a,
739	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_LINKED_CMD_COMPLETED_WITH_FLAG = 0x0b,
740	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_DATA_UNDERUN = 0x0c,
741	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_SCSI_SELECTION_TIMEOUT = 0x11,
742	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_DATA_OVERRUN = 0x12,
743	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_UNEXPECTED_BUS_FREE = 0x13,
744	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_BUS_PHASE_REQUESTED = 0x14,
745	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_OUTGOING_MAILBOX_ACTION_CODE = 0x15,
746	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_COMMAND_OPERATION_CODE = 0x16,
747	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_LINKED_CCB_HAS_INVALID_LUN = 0x17,
748	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_COMMAND_PARAMETER = 0x1a,
749	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_AUTO_REQUEST_SENSE_FAILED = 0x1b,
750	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_TAGGED_QUEUING_MESSAGE_REJECTED = 0x1c,
751	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_UNSUPPORTED_MESSAGE_RECEIVED = 0x1d,
752	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_HARDWARE_FAILED = 0x20,
753	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_TARGET_FAILED_RESPONSE_TO_ATN = 0x21,
754	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_ASSERTED_RST = 0x22,
755	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_OTHER_DEVICE_ASSERTED_RST = 0x23,
756	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_TARGET_DEVICE_RECONNECTED_IMPROPERLY = 0x24,
757	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_ASSERTED_BUS_DEVICE_RESET = 0x25,
758	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_ABORT_QUEUE_GENERATED = 0x26,
759	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_SOFTWARE_ERROR = 0x27,
760	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_HARDWARE_TIMEOUT_ERROR = 0x30,
761	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_SCSI_PARITY_ERROR_DETECTED = 0x34
762	};
763
764	/**
765	* Device status codes for incoming mailboxes.
766	*/
767	enum BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS
768	{
769	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD = 0x00,
770	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_CHECK_CONDITION = 0x02,
771	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_DEVICE_BUSY = 0x08
772	};
773
774	/**
775	* Opcode types for CCB.
776	*/
777	enum BUSLOGIC_CCB_OPCODE
778	{
779	BUSLOGIC_CCB_OPCODE_INITIATOR_CCB = 0x00,
780	BUSLOGIC_CCB_OPCODE_TARGET_CCB = 0x01,
781	BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_SCATTER_GATHER = 0x02,
782	BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_DATA_LENGTH = 0x03,
783	BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_SCATTER_GATHER = 0x04,
784	BUSLOGIC_CCB_OPCODE_BUS_DEVICE_RESET = 0x81
785	};
786
787	/**
788	* Data transfer direction.
789	*/
790	enum BUSLOGIC_CCB_DIRECTION
791	{
792	BUSLOGIC_CCB_DIRECTION_UNKNOWN = 0x00,
793	BUSLOGIC_CCB_DIRECTION_IN = 0x01,
794	BUSLOGIC_CCB_DIRECTION_OUT = 0x02,
795	BUSLOGIC_CCB_DIRECTION_NO_DATA = 0x03
796	};
797
798	/**
799	* The command control block for a SCSI request.
800	*/
801	typedef struct CCB32
802	{
803	/** Opcode. */
804	uint8_t uOpcode;
805	/** Reserved */
806	unsigned char uReserved1 : 3;
807	/** Data direction for the request. */
808	unsigned char uDataDirection : 2;
809	/** Whether the request is tag queued. */
810	bool fTagQueued : 1;
811	/** Queue tag mode. */
812	unsigned char uQueueTag : 2;
813	/** Length of the SCSI CDB. */
814	uint8_t cbCDB;
815	/** Sense data length. */
816	uint8_t cbSenseData;
817	/** Data length. */
818	uint32_t cbData;
819	/** Data pointer.
820	* This points to the data region or a scatter gather list based on the opcode.
821	*/
822	uint32_t u32PhysAddrData;
823	/** Reserved. */
824	uint8_t uReserved2[2];
825	/** Host adapter status. */
826	uint8_t uHostAdapterStatus;
827	/** Device adapter status. */
828	uint8_t uDeviceStatus;
829	/** The device the request is sent to. */
830	uint8_t uTargetId;
831	/*The LUN in the device. /
832	unsigned char uLogicalUnit : 5;
833	/** Legacy tag. */
834	bool fLegacyTagEnable : 1;
835	/** Legacy queue tag. */
836	unsigned char uLegacyQueueTag : 2;
837	/** The SCSI CDB. (A CDB can be 12 bytes long.) */
838	uint8_t abCDB[12];
839	/** Reserved. */
840	uint8_t uReserved3[6];
841	/** Sense data pointer. */
842	uint32_t u32PhysAddrSenseData;
843	} CCB32, *PCCB32;
844	AssertCompileSize(CCB32, 40);
845
846
847	/**
848	* The 24-bit command control block.
849	*/
850	typedef struct CCB24
851	{
852	/** Opcode. */
853	uint8_t uOpcode;
854	/** The LUN in the device. */
855	unsigned char uLogicalUnit : 3;
856	/** Data direction for the request. */
857	unsigned char uDataDirection : 2;
858	/** The target device ID. */
859	unsigned char uTargetId : 3;
860	/** Length of the SCSI CDB. */
861	uint8_t cbCDB;
862	/** Sense data length. */
863	uint8_t cbSenseData;
864	/** Data length. */
865	Len24 acbData;
866	/** Data pointer.
867	* This points to the data region or a scatter gather list based on the opc
868	*/
869	Addr24 aPhysAddrData;
870	/** Pointer to next CCB for linked commands. */
871	Addr24 aPhysAddrLink;
872	/** Command linking identifier. */
873	uint8_t uLinkId;
874	/** Host adapter status. */
875	uint8_t uHostAdapterStatus;
876	/** Device adapter status. */
877	uint8_t uDeviceStatus;
878	/** Two unused bytes. */
879	uint8_t aReserved[2];
880	/** The SCSI CDB. (A CDB can be 12 bytes long.) */
881	uint8_t abCDB[12];
882	} CCB24, *PCCB24;
883	AssertCompileSize(CCB24, 30);
884
885	/**
886	* The common 24-bit/32-bit command control block. The 32-bit CCB is laid out
887	* such that many fields are in the same location as in the older 24-bit CCB.
888	*/
889	typedef struct CCBC
890	{
891	/** Opcode. */
892	uint8_t uOpcode;
893	/** The LUN in the device. */
894	unsigned char uPad1 : 3;
895	/** Data direction for the request. */
896	unsigned char uDataDirection : 2;
897	/** The target device ID. */
898	unsigned char uPad2 : 3;
899	/** Length of the SCSI CDB. */
900	uint8_t cbCDB;
901	/** Sense data length. */
902	uint8_t cbSenseData;
903	uint8_t aPad1[10];
904	/** Host adapter status. */
905	uint8_t uHostAdapterStatus;
906	/** Device adapter status. */
907	uint8_t uDeviceStatus;
908	uint8_t aPad2[2];
909	/** The SCSI CDB (up to 12 bytes). */
910	uint8_t abCDB[12];
911	} CCBC, *PCCBC;
912	AssertCompileSize(CCBC, 30);
913
914	/* Make sure that the 24-bit/32-bit/common CCB offsets match. */
915	AssertCompileMemberOffset(CCBC, cbCDB, 2);
916	AssertCompileMemberOffset(CCB24, cbCDB, 2);
917	AssertCompileMemberOffset(CCB32, cbCDB, 2);
918	AssertCompileMemberOffset(CCBC, uHostAdapterStatus, 14);
919	AssertCompileMemberOffset(CCB24, uHostAdapterStatus, 14);
920	AssertCompileMemberOffset(CCB32, uHostAdapterStatus, 14);
921	AssertCompileMemberOffset(CCBC, abCDB, 18);
922	AssertCompileMemberOffset(CCB24, abCDB, 18);
923	AssertCompileMemberOffset(CCB32, abCDB, 18);
924
925	/** A union of all CCB types (24-bit/32-bit/common). */
926	typedef union CCBU
927	{
928	CCB32 n; /*< New 32-bit CCB. /
929	CCB24 o; /*< Old 24-bit CCB. /
930	CCBC c; /*< Common CCB subset. /
931	} CCBU, *PCCBU;
932
933	/** 32-bit scatter-gather list entry. */
934	typedef struct SGE32
935	{
936	uint32_t cbSegment;
937	uint32_t u32PhysAddrSegmentBase;
938	} SGE32, *PSGE32;
939	AssertCompileSize(SGE32, 8);
940
941	/** 24-bit scatter-gather list entry. */
942	typedef struct SGE24
943	{
944	Len24 acbSegment;
945	Addr24 aPhysAddrSegmentBase;
946	} SGE24, *PSGE24;
947	AssertCompileSize(SGE24, 6);
948
949	/**
950	* The structure for the "Execute SCSI Command" command.
951	*/
952	typedef struct ESCMD
953	{
954	/** Data length. */
955	uint32_t cbData;
956	/** Data pointer. */
957	uint32_t u32PhysAddrData;
958	/** The device the request is sent to. */
959	uint8_t uTargetId;
960	/** The LUN in the device. */
961	uint8_t uLogicalUnit;
962	/** Reserved */
963	unsigned char uReserved1 : 3;
964	/** Data direction for the request. */
965	unsigned char uDataDirection : 2;
966	/** Reserved */
967	unsigned char uReserved2 : 3;
968	/** Length of the SCSI CDB. */
969	uint8_t cbCDB;
970	/** The SCSI CDB. (A CDB can be 12 bytes long.) */
971	uint8_t abCDB[12];
972	} ESCMD, *PESCMD;
973	AssertCompileSize(ESCMD, 24);
974
975	/**
976	* Task state for a CCB request.
977	*/
978	typedef struct BUSLOGICREQ
979	{
980	/** PDM extended media interface I/O request hande. */
981	PDMMEDIAEXIOREQ hIoReq;
982	/** Device this task is assigned to. */
983	PBUSLOGICDEVICE pTargetDevice;
984	/** The command control block from the guest. */
985	CCBU CCBGuest;
986	/** Guest physical address of th CCB. */
987	RTGCPHYS GCPhysAddrCCB;
988	/** Pointer to the R3 sense buffer. */
989	uint8_t *pbSenseBuffer;
990	/** Flag whether this is a request from the BIOS. */
991	bool fBIOS;
992	/** 24-bit request flag (default is 32-bit). */
993	bool fIs24Bit;
994	/** SCSI status code. */
995	uint8_t u8ScsiSts;
996	} BUSLOGICREQ;
997
998	#ifdef IN_RING3
999	/**
1000	* Memory buffer callback.
1001	*
1002	* @returns nothing.
1003	* @param pDevIns The device instance.
1004	* @param pThis Pointer to the shared BusLogic instance data.
1005	* @param GCPhys The guest physical address of the memory buffer.
1006	* @param pSgBuf The pointer to the host R3 S/G buffer.
1007	* @param cbCopy How many bytes to copy between the two buffers.
1008	* @param pcbSkip Initially contains the amount of bytes to skip
1009	* starting from the guest physical address before
1010	* accessing the S/G buffer and start copying data.
1011	* On return this contains the remaining amount if
1012	* cbCopy < *pcbSkip or 0 otherwise.
1013	*/
1014	typedef DECLCALLBACKTYPE(void, FNBUSLOGICR3MEMCOPYCALLBACK,(PPDMDEVINS pDevIns, PBUSLOGIC pThis, RTGCPHYS GCPhys,
1015	PRTSGBUF pSgBuf, size_t cbCopy, size_t *pcbSkip));
1016	/** Pointer to a memory copy buffer callback. */
1017	typedef FNBUSLOGICR3MEMCOPYCALLBACK *PFNBUSLOGICR3MEMCOPYCALLBACK;
1018	#endif
1019
1020	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
1021
1022
1023	/*********************************************************************************************************************************
1024	* Internal Functions *
1025	*********************************************************************************************************************************/
1026	#ifdef IN_RING3
1027	static int buslogicR3RegisterISARange(PPDMDEVINS pDevIns, PBUSLOGIC pThis, uint8_t uBaseCode);
1028	#endif
1029
1030
1031	/**
1032	* Assert IRQ line of the BusLogic adapter. Rather than using
1033	* the more modern method of the guest explicitly only clearing
1034	* the interrupt causes it handled, BusLogic never reports all
1035	* interrupts at once. Instead, new interrupts are postponed if
1036	* an interrupt of a different type is still pending.
1037	*
1038	* @returns nothing.
1039	* @param pDevIns The device instance.
1040	* @param pThis Pointer to the shared BusLogic instance data.
1041	* @param fSuppressIrq Flag to suppress IRQ generation regardless of fIRQEnabled
1042	* @param uIrqType Type of interrupt being generated.
1043	*/
1044	static void buslogicSetInterrupt(PPDMDEVINS pDevIns, PBUSLOGIC pThis, bool fSuppressIrq, uint8_t uIrqType)
1045	{
1046	LogFlowFunc(("pThis=%#p, setting %#02x (current %#02x, pending %#02x)\n",
1047	pThis, uIrqType, pThis->regInterrupt, pThis->uPendingIntr));
1048
1049	/* A CMDC interrupt overrides other pending interrupts. The documentation may claim
1050	* otherwise, but a real BT-958 replaces a pending IMBL with a CMDC; the IMBL simply
1051	* vanishes. However, if there's a CMDC already active, another CMDC is latched and
1052	* reported once the first CMDC is cleared.
1053	*/
1054	if (uIrqType & BL_INTR_CMDC)
1055	{
1056	Assert(uIrqType == BL_INTR_CMDC);
1057	if ((pThis->regInterrupt & BL_INTR_INTV) && !(pThis->regInterrupt & BL_INTR_CMDC))
1058	Log(("CMDC overriding pending interrupt! (was %02x)\n", pThis->regInterrupt));
1059	if (!(pThis->regInterrupt & BL_INTR_CMDC))
1060	pThis->regInterrupt \|= uIrqType \| BL_INTR_INTV; /* Report now. */
1061	else
1062	pThis->uPendingIntr \|= uIrqType; /* Report later. */
1063	}
1064	else if (uIrqType & (BL_INTR_IMBL \| BL_INTR_OMBR))
1065	{
1066	/* If the CMDC interrupt is pending, store IMBL/OMBR for later. Note that IMBL
1067	* and OMBR can be reported together even if an interrupt of the other type is
1068	* already pending.
1069	*/
1070	if (!(pThis->regInterrupt & BL_INTR_CMDC))
1071	pThis->regInterrupt \|= uIrqType \| BL_INTR_INTV; /* Report now. */
1072	else
1073	pThis->uPendingIntr \|= uIrqType; /* Report later. */
1074	}
1075	else /* We do not expect to see BL_INTR_RSTS at this point. */
1076	AssertMsgFailed(("Invalid interrupt state (unknown interrupt cause)!\n"));
1077	AssertMsg(pThis->regInterrupt, ("Invalid interrupt state (interrupt not set)!\n"));
1078	AssertMsg(pThis->regInterrupt != BL_INTR_INTV, ("Invalid interrupt state (set but no cause)!\n"));
1079
1080	if (pThis->fIRQEnabled && !fSuppressIrq)
1081	{
1082	if (!pThis->uIsaIrq)
1083	PDMDevHlpPCISetIrq(pDevIns, 0, 1);
1084	else
1085	PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, 1);
1086	}
1087	}
1088
1089	/**
1090	* Deasserts the interrupt line of the BusLogic adapter.
1091	*
1092	* @returns nothing.
1093	* @param pDevIns The device instance.
1094	* @param pThis Pointer to the shared BusLogic instance data.
1095	*/
1096	static void buslogicClearInterrupt(PPDMDEVINS pDevIns, PBUSLOGIC pThis)
1097	{
1098	LogFlowFunc(("pThis=%#p, clearing %#02x (pending %#02x)\n",
1099	pThis, pThis->regInterrupt, pThis->uPendingIntr));
1100	pThis->regInterrupt = 0;
1101	pThis->regStatus &= ~BL_STAT_CMDINV;
1102	if (!pThis->uIsaIrq)
1103	PDMDevHlpPCISetIrq(pDevIns, 0, 0);
1104	else
1105	PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, 0);
1106	/* If there's another pending interrupt, report it now. */
1107	if (pThis->uPendingIntr)
1108	{
1109	buslogicSetInterrupt(pDevIns, pThis, false, pThis->uPendingIntr);
1110	pThis->uPendingIntr = 0;
1111	}
1112	}
1113
1114	#if defined(IN_RING3)
1115
1116	/**
1117	* Advances the mailbox pointer to the next slot.
1118	*
1119	* @returns nothing.
1120	* @param pThis Pointer to the shared BusLogic instance data.
1121	*/
1122	DECLINLINE(void) buslogicR3OutgoingMailboxAdvance(PBUSLOGIC pThis)
1123	{
1124	pThis->uMailboxOutgoingPositionCurrent = (pThis->uMailboxOutgoingPositionCurrent + 1) % pThis->cMailbox;
1125	}
1126
1127	/**
1128	* Initialize local RAM of host adapter with default values.
1129	*
1130	* @returns nothing.
1131	* @param pThis Pointer to the shared BusLogic instance data.
1132	*/
1133	static void buslogicR3InitializeLocalRam(PBUSLOGIC pThis)
1134	{
1135	/*
1136	* These values are mostly from what I think is right
1137	* looking at the dmesg output from a Linux guest inside
1138	* a VMware server VM.
1139	*
1140	* So they don't have to be right :)
1141	*/
1142	memset(pThis->LocalRam.u8View, 0, sizeof(HostAdapterLocalRam));
1143	pThis->LocalRam.structured.autoSCSIData.fLevelSensitiveInterrupt = true;
1144	pThis->LocalRam.structured.autoSCSIData.fParityCheckingEnabled = true;
1145	pThis->LocalRam.structured.autoSCSIData.fExtendedTranslation = true; /* Same as in geometry register. */
1146	pThis->LocalRam.structured.autoSCSIData.u16DeviceEnabledMask = UINT16_MAX; /* All enabled. Maybe mask out non present devices? */
1147	pThis->LocalRam.structured.autoSCSIData.u16WidePermittedMask = UINT16_MAX;
1148	pThis->LocalRam.structured.autoSCSIData.u16FastPermittedMask = UINT16_MAX;
1149	pThis->LocalRam.structured.autoSCSIData.u16SynchronousPermittedMask = UINT16_MAX;
1150	pThis->LocalRam.structured.autoSCSIData.u16DisconnectPermittedMask = UINT16_MAX;
1151	pThis->LocalRam.structured.autoSCSIData.fStrictRoundRobinMode = pThis->fStrictRoundRobinMode;
1152	pThis->LocalRam.structured.autoSCSIData.u16UltraPermittedMask = UINT16_MAX;
1153	pThis->LocalRam.structured.autoSCSIData.uSCSIId = 7;
1154	pThis->LocalRam.structured.autoSCSIData.uHostAdapterIoPortAddress = pThis->uDefaultISABaseCode == ISA_BASE_DISABLED ? 2 : pThis->uDefaultISABaseCode;
1155	/** @todo calculate checksum? */
1156	}
1157
1158	/**
1159	* Do a hardware reset of the buslogic adapter.
1160	*
1161	* @returns VBox status code.
1162	* @param pDevIns The device instance.
1163	* @param pThis Pointer to the shared BusLogic instance data.
1164	* @param fResetIO Flag determining whether ISA I/O should be reset.
1165	*/
1166	static int buslogicR3HwReset(PPDMDEVINS pDevIns, PBUSLOGIC pThis, bool fResetIO)
1167	{
1168	LogFlowFunc(("pThis=%#p\n", pThis));
1169
1170	/* Reset registers to default values. */
1171	pThis->regStatus = BL_STAT_HARDY \| BL_STAT_INREQ;
1172	pThis->regGeometry = BL_GEOM_XLATEN;
1173	pThis->uOperationCode = 0xff; /* No command executing. */
1174	pThis->uPrevCmd = 0xff;
1175	pThis->iParameter = 0;
1176	pThis->cbCommandParametersLeft = 0;
1177	pThis->fIRQEnabled = true;
1178	pThis->fStrictRoundRobinMode = false;
1179	pThis->fExtendedLunCCBFormat = false;
1180	pThis->uMailboxOutgoingPositionCurrent = 0;
1181	pThis->uMailboxIncomingPositionCurrent = 0;
1182	pThis->uAhaSigIdx = 0;
1183	pThis->cMailbox = 0;
1184	pThis->GCPhysAddrMailboxIncomingBase = 0;
1185	pThis->GCPhysAddrMailboxOutgoingBase = 0;
1186
1187	/* Clear any active/pending interrupts. */
1188	pThis->uPendingIntr = 0;
1189	buslogicClearInterrupt(pDevIns, pThis);
1190
1191	/* Guest-initiated HBA reset does not affect ISA port I/O. */
1192	if (fResetIO)
1193	buslogicR3RegisterISARange(pDevIns, pThis, pThis->uDefaultISABaseCode);
1194	buslogicR3InitializeLocalRam(pThis);
1195
1196	return VINF_SUCCESS;
1197	}
1198
1199	#endif /* IN_RING3 */
1200
1201	/**
1202	* Resets the command state machine for the next command and notifies the guest.
1203	* Note that suppressing CMDC also suppresses the interrupt, but not vice versa.
1204	*
1205	* @returns nothing.
1206	* @param pDevIns The device instance.
1207	* @param pThis Pointer to the shared BusLogic instance data.
1208	* @param fSuppressIrq Flag to suppress IRQ generation regardless of current state
1209	* @param fSuppressCMDC Flag to suppress command completion status as well
1210	*/
1211	static void buslogicCommandComplete(PPDMDEVINS pDevIns, PBUSLOGIC pThis, bool fSuppressIrq, bool fSuppressCMDC)
1212	{
1213	LogFlowFunc(("pThis=%#p\n", pThis));
1214	Assert(pThis->uOperationCode != BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND);
1215
1216	pThis->fUseLocalRam = false;
1217	pThis->regStatus \|= BL_STAT_HARDY;
1218	pThis->regStatus &= ~BL_STAT_DIRRDY;
1219	pThis->iReply = 0;
1220
1221	/* Some commands do not set CMDC when successful. */
1222	if (!fSuppressCMDC)
1223	{
1224	/* Notify that the command is complete. */
1225	buslogicSetInterrupt(pDevIns, pThis, fSuppressIrq, BL_INTR_CMDC);
1226	}
1227
1228	pThis->uPrevCmd = pThis->uOperationCode;
1229	pThis->uOperationCode = 0xff;
1230	pThis->iParameter = 0;
1231	}
1232
1233	/**
1234	* Memory write helper to handle PCI/ISA differences - metadata writes.
1235	*
1236	* @returns nothing.
1237	* @param pDevIns The device instance.
1238	* @param pThis Pointer to the shared BusLogic instance data.
1239	* @param GCPhys Guest physical memory address
1240	* @param pvBuf Host side buffer address
1241	* @param cbWrite Number of bytes to write
1242	*/
1243	static void blPhysWriteMeta(PPDMDEVINS pDevIns, PBUSLOGIC pThis, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
1244	{
1245	if (!pThis->uIsaIrq)
1246	PDMDevHlpPCIPhysWriteMeta(pDevIns, GCPhys, pvBuf, cbWrite);
1247	else
1248	PDMDevHlpPhysWriteMeta(pDevIns, GCPhys, pvBuf, cbWrite);
1249	}
1250
1251	/**
1252	* Memory read helper to handle PCI/ISA differences - metadata reads.
1253	*
1254	* @returns nothing.
1255	* @param pDevIns The device instance.
1256	* @param pThis Pointer to the shared BusLogic instance data.
1257	* @param GCPhys Guest physical memory address.
1258	* @param pvBuf Host side buffer address.
1259	* @param cbRead Number of bytes to read.
1260	*/
1261	static void blPhysReadMeta(PPDMDEVINS pDevIns, PBUSLOGIC pThis, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
1262	{
1263	if (!pThis->uIsaIrq)
1264	PDMDevHlpPCIPhysReadMeta(pDevIns, GCPhys, pvBuf, cbRead);
1265	else
1266	PDMDevHlpPhysReadMeta(pDevIns, GCPhys, pvBuf, cbRead);
1267	}
1268
1269	#if defined(IN_RING3)
1270
1271	/**
1272	* Memory write helper to handle PCI/ISA differences - userdata writes.
1273	*
1274	* @returns nothing.
1275	* @param pDevIns The device instance.
1276	* @param pThis Pointer to the shared BusLogic instance data.
1277	* @param GCPhys Guest physical memory address
1278	* @param pvBuf Host side buffer address
1279	* @param cbWrite Number of bytes to write
1280	*/
1281	static void blPhysWriteUser(PPDMDEVINS pDevIns, PBUSLOGIC pThis, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
1282	{
1283	if (!pThis->uIsaIrq)
1284	PDMDevHlpPCIPhysWriteUser(pDevIns, GCPhys, pvBuf, cbWrite);
1285	else
1286	PDMDevHlpPhysWriteUser(pDevIns, GCPhys, pvBuf, cbWrite);
1287	}
1288
1289	/**
1290	* Memory read helper to handle PCI/ISA differences - userdata reads.
1291	*
1292	* @returns nothing.
1293	* @param pDevIns The device instance.
1294	* @param pThis Pointer to the shared BusLogic instance data.
1295	* @param GCPhys Guest physical memory address.
1296	* @param pvBuf Host side buffer address.
1297	* @param cbRead Number of bytes to read.
1298	*/
1299	static void blPhysReadUser(PPDMDEVINS pDevIns, PBUSLOGIC pThis, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
1300	{
1301	if (!pThis->uIsaIrq)
1302	PDMDevHlpPCIPhysReadUser(pDevIns, GCPhys, pvBuf, cbRead);
1303	else
1304	PDMDevHlpPhysReadUser(pDevIns, GCPhys, pvBuf, cbRead);
1305	}
1306
1307	/**
1308	* Initiates a hard reset which was issued from the guest.
1309	*
1310	* @returns nothing
1311	* @param pDevIns The device instance.
1312	* @param pThis Pointer to the shared BusLogic instance data.
1313	* @param fHardReset Flag initiating a hard (vs. soft) reset.
1314	*/
1315	static void buslogicR3InitiateReset(PPDMDEVINS pDevIns, PBUSLOGIC pThis, bool fHardReset)
1316	{
1317	LogFlowFunc(("pThis=%#p fHardReset=%d\n", pThis, fHardReset));
1318
1319	buslogicR3HwReset(pDevIns, pThis, false);
1320
1321	if (fHardReset)
1322	{
1323	/* Set the diagnostic active bit in the status register and clear the ready state. */
1324	pThis->regStatus \|= BL_STAT_DACT;
1325	pThis->regStatus &= ~BL_STAT_HARDY;
1326
1327	/* Remember when the guest initiated a reset (after we're done resetting). */
1328	pThis->u64ResetTime = PDMDevHlpTMTimeVirtGetNano(pDevIns);
1329	}
1330	}
1331
1332
1333	/**
1334	* Send a mailbox with set status codes to the guest.
1335	*
1336	* @returns nothing.
1337	* @param pDevIns The device instance.
1338	* @param pThis Pointer to the shared BusLogic instance data.
1339	* @param GCPhysAddrCCB The physical guest address of the CCB the mailbox is for.
1340	* @param pCCBGuest The command control block.
1341	* @param uHostAdapterStatus The host adapter status code to set.
1342	* @param uDeviceStatus The target device status to set.
1343	* @param uMailboxCompletionCode Completion status code to set in the mailbox.
1344	*/
1345	static void buslogicR3SendIncomingMailbox(PPDMDEVINS pDevIns, PBUSLOGIC pThis, RTGCPHYS GCPhysAddrCCB,
1346	PCCBU pCCBGuest, uint8_t uHostAdapterStatus,
1347	uint8_t uDeviceStatus, uint8_t uMailboxCompletionCode)
1348	{
1349	Mailbox32 MbxIn;
1350
1351	MbxIn.u32PhysAddrCCB = (uint32_t)GCPhysAddrCCB;
1352	MbxIn.u.in.uHostAdapterStatus = uHostAdapterStatus;
1353	MbxIn.u.in.uTargetDeviceStatus = uDeviceStatus;
1354	MbxIn.u.in.uReserved = 0;
1355	MbxIn.u.in.uCompletionCode = uMailboxCompletionCode;
1356
1357	int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIntr, VINF_SUCCESS);
1358	AssertRC(rc);
1359
1360	RTGCPHYS GCPhysAddrMailboxIncoming = pThis->GCPhysAddrMailboxIncomingBase
1361	+ ( pThis->uMailboxIncomingPositionCurrent
1362	* (pThis->fMbxIs24Bit ? sizeof(Mailbox24) : sizeof(Mailbox32)) );
1363
1364	if (uMailboxCompletionCode != BUSLOGIC_MAILBOX_INCOMING_COMPLETION_ABORTED_NOT_FOUND)
1365	{
1366	LogFlowFunc(("Completing CCB %RGp hstat=%u, dstat=%u, outgoing mailbox at %RGp\n", GCPhysAddrCCB,
1367	uHostAdapterStatus, uDeviceStatus, GCPhysAddrMailboxIncoming));
1368
1369	/* Update CCB. */
1370	pCCBGuest->c.uHostAdapterStatus = uHostAdapterStatus;
1371	pCCBGuest->c.uDeviceStatus = uDeviceStatus;
1372	/* Rewrite CCB up to the CDB; perhaps more than necessary. */
1373	blPhysWriteMeta(pDevIns, pThis, GCPhysAddrCCB, pCCBGuest, RT_UOFFSETOF(CCBC, abCDB));
1374	}
1375
1376	# ifdef RT_STRICT
1377	uint8_t uCode;
1378	unsigned uCodeOffs = pThis->fMbxIs24Bit ? RT_OFFSETOF(Mailbox24, uCmdState) : RT_OFFSETOF(Mailbox32, u.out.uActionCode);
1379	blPhysReadMeta(pDevIns, pThis, GCPhysAddrMailboxIncoming + uCodeOffs, &uCode, sizeof(uCode));
1380	Assert(uCode == BUSLOGIC_MAILBOX_INCOMING_COMPLETION_FREE);
1381	# endif
1382
1383	/* Update mailbox. */
1384	if (pThis->fMbxIs24Bit)
1385	{
1386	Mailbox24 Mbx24;
1387
1388	Mbx24.uCmdState = MbxIn.u.in.uCompletionCode;
1389	U32_TO_ADDR(Mbx24.aPhysAddrCCB, MbxIn.u32PhysAddrCCB);
1390	Log(("24-bit mailbox: completion code=%u, CCB at %RGp\n", Mbx24.uCmdState, (RTGCPHYS)ADDR_TO_U32(Mbx24.aPhysAddrCCB)));
1391	blPhysWriteMeta(pDevIns, pThis, GCPhysAddrMailboxIncoming, &Mbx24, sizeof(Mailbox24));
1392	}
1393	else
1394	{
1395	Log(("32-bit mailbox: completion code=%u, CCB at %RGp\n", MbxIn.u.in.uCompletionCode, GCPhysAddrCCB));
1396	blPhysWriteMeta(pDevIns, pThis, GCPhysAddrMailboxIncoming, &MbxIn, sizeof(Mailbox32));
1397	}
1398
1399	/* Advance to next mailbox position. */
1400	pThis->uMailboxIncomingPositionCurrent++;
1401	if (pThis->uMailboxIncomingPositionCurrent >= pThis->cMailbox)
1402	pThis->uMailboxIncomingPositionCurrent = 0;
1403
1404	# ifdef LOG_ENABLED
1405	ASMAtomicIncU32(&pThis->cInMailboxesReadyIfLogEnabled);
1406	# endif
1407
1408	buslogicSetInterrupt(pDevIns, pThis, false, BL_INTR_IMBL);
1409
1410	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSectIntr);
1411	}
1412
1413	# ifdef LOG_ENABLED
1414
1415	/**
1416	* Dumps the content of a mailbox for debugging purposes.
1417	*
1418	* @return nothing
1419	* @param pMailbox The mailbox to dump.
1420	* @param fOutgoing true if dumping the outgoing state.
1421	* false if dumping the incoming state.
1422	*/
1423	static void buslogicR3DumpMailboxInfo(PMailbox32 pMailbox, bool fOutgoing)
1424	{
1425	Log(("%s: Dump for %s mailbox:\n", __FUNCTION__, fOutgoing ? "outgoing" : "incoming"));
1426	Log(("%s: u32PhysAddrCCB=%#x\n", __FUNCTION__, pMailbox->u32PhysAddrCCB));
1427	if (fOutgoing)
1428	{
1429	Log(("%s: uActionCode=%u\n", __FUNCTION__, pMailbox->u.out.uActionCode));
1430	}
1431	else
1432	{
1433	Log(("%s: uHostAdapterStatus=%u\n", __FUNCTION__, pMailbox->u.in.uHostAdapterStatus));
1434	Log(("%s: uTargetDeviceStatus=%u\n", __FUNCTION__, pMailbox->u.in.uTargetDeviceStatus));
1435	Log(("%s: uCompletionCode=%u\n", __FUNCTION__, pMailbox->u.in.uCompletionCode));
1436	}
1437	}
1438
1439	/**
1440	* Dumps the content of a command control block for debugging purposes.
1441	*
1442	* @returns nothing.
1443	* @param pCCB Pointer to the command control block to dump.
1444	* @param fIs24BitCCB Flag to determine CCB format.
1445	*/
1446	static void buslogicR3DumpCCBInfo(PCCBU pCCB, bool fIs24BitCCB)
1447	{
1448	Log(("%s: Dump for %s Command Control Block:\n", __FUNCTION__, fIs24BitCCB ? "24-bit" : "32-bit"));
1449	Log(("%s: uOpCode=%#x\n", __FUNCTION__, pCCB->c.uOpcode));
1450	Log(("%s: uDataDirection=%u\n", __FUNCTION__, pCCB->c.uDataDirection));
1451	Log(("%s: cbCDB=%u\n", __FUNCTION__, pCCB->c.cbCDB));
1452	Log(("%s: cbSenseData=%u\n", __FUNCTION__, pCCB->c.cbSenseData));
1453	Log(("%s: uHostAdapterStatus=%u\n", __FUNCTION__, pCCB->c.uHostAdapterStatus));
1454	Log(("%s: uDeviceStatus=%u\n", __FUNCTION__, pCCB->c.uDeviceStatus));
1455	if (fIs24BitCCB)
1456	{
1457	Log(("%s: cbData=%u\n", __FUNCTION__, LEN_TO_U32(pCCB->o.acbData)));
1458	Log(("%s: PhysAddrData=%#x\n", __FUNCTION__, ADDR_TO_U32(pCCB->o.aPhysAddrData)));
1459	Log(("%s: uTargetId=%u\n", __FUNCTION__, pCCB->o.uTargetId));
1460	Log(("%s: uLogicalUnit=%u\n", __FUNCTION__, pCCB->o.uLogicalUnit));
1461	}
1462	else
1463	{
1464	Log(("%s: cbData=%u\n", __FUNCTION__, pCCB->n.cbData));
1465	Log(("%s: PhysAddrData=%#x\n", __FUNCTION__, pCCB->n.u32PhysAddrData));
1466	Log(("%s: uTargetId=%u\n", __FUNCTION__, pCCB->n.uTargetId));
1467	Log(("%s: uLogicalUnit=%u\n", __FUNCTION__, pCCB->n.uLogicalUnit));
1468	Log(("%s: fTagQueued=%d\n", __FUNCTION__, pCCB->n.fTagQueued));
1469	Log(("%s: uQueueTag=%u\n", __FUNCTION__, pCCB->n.uQueueTag));
1470	Log(("%s: fLegacyTagEnable=%u\n", __FUNCTION__, pCCB->n.fLegacyTagEnable));
1471	Log(("%s: uLegacyQueueTag=%u\n", __FUNCTION__, pCCB->n.uLegacyQueueTag));
1472	Log(("%s: PhysAddrSenseData=%#x\n", __FUNCTION__, pCCB->n.u32PhysAddrSenseData));
1473	}
1474	Log(("%s: uCDB[0]=%#x\n", __FUNCTION__, pCCB->c.abCDB[0]));
1475	for (int i = 1; i < pCCB->c.cbCDB; i++)
1476	Log(("%s: uCDB[%d]=%u\n", __FUNCTION__, i, pCCB->c.abCDB[i]));
1477	}
1478
1479	# endif /* LOG_ENABLED */
1480
1481	/**
1482	* Allocate data buffer.
1483	*
1484	* @param pDevIns PDM device instance.
1485	* @param fIs24Bit Flag whether the 24bit SG format is used.
1486	* @param GCSGList Guest physical address of S/G list.
1487	* @param cEntries Number of list entries to read.
1488	* @param pSGEList Pointer to 32-bit S/G list storage.
1489	*/
1490	static void buslogicR3ReadSGEntries(PPDMDEVINS pDevIns, bool fIs24Bit, RTGCPHYS GCSGList,
1491	uint32_t cEntries, SGE32 *pSGEList)
1492	{
1493	/* Read the S/G entries. Convert 24-bit entries to 32-bit format. */
1494	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
1495	if (fIs24Bit)
1496	{
1497	SGE24 aSGE24[32];
1498	Assert(cEntries <= RT_ELEMENTS(aSGE24));
1499
1500	Log2(("Converting %u 24-bit S/G entries to 32-bit\n", cEntries));
1501	blPhysReadMeta(pDevIns, pThis, GCSGList, &aSGE24, cEntries * sizeof(SGE24));
1502	for (uint32_t i = 0; i < cEntries; ++i)
1503	{
1504	pSGEList[i].cbSegment = LEN_TO_U32(aSGE24[i].acbSegment);
1505	pSGEList[i].u32PhysAddrSegmentBase = ADDR_TO_U32(aSGE24[i].aPhysAddrSegmentBase);
1506	}
1507	}
1508	else
1509	blPhysReadMeta(pDevIns, pThis, GCSGList, pSGEList, cEntries * sizeof(SGE32));
1510	}
1511
1512	/**
1513	* Determines the size of th guest data buffer.
1514	*
1515	* @returns VBox status code.
1516	* @param pDevIns PDM device instance.
1517	* @param pCCBGuest The CCB of the guest.
1518	* @param fIs24Bit Flag whether the 24bit SG format is used.
1519	* @param pcbBuf Where to store the size of the guest data buffer on success.
1520	*/
1521	static int buslogicR3QueryDataBufferSize(PPDMDEVINS pDevIns, PCCBU pCCBGuest, bool fIs24Bit, size_t *pcbBuf)
1522	{
1523	int rc = VINF_SUCCESS;
1524	uint32_t cbDataCCB;
1525	uint32_t u32PhysAddrCCB;
1526	size_t cbBuf = 0;
1527
1528	/* Extract the data length and physical address from the CCB. */
1529	if (fIs24Bit)
1530	{
1531	u32PhysAddrCCB = ADDR_TO_U32(pCCBGuest->o.aPhysAddrData);
1532	cbDataCCB = LEN_TO_U32(pCCBGuest->o.acbData);
1533	}
1534	else
1535	{
1536	u32PhysAddrCCB = pCCBGuest->n.u32PhysAddrData;
1537	cbDataCCB = pCCBGuest->n.cbData;
1538	}
1539
1540	#if 1
1541	/* Hack for NT 10/91: A CCB describes a 2K buffer, but TEST UNIT READY is executed. This command
1542	* returns no data, hence the buffer must be left alone!
1543	*/
1544	if (pCCBGuest->c.abCDB[0] == 0)
1545	cbDataCCB = 0;
1546	#endif
1547
1548	if ( (pCCBGuest->c.uDataDirection != BUSLOGIC_CCB_DIRECTION_NO_DATA)
1549	&& cbDataCCB)
1550	{
1551	/*
1552	* The BusLogic adapter can handle two different data buffer formats.
1553	* The first one is that the data pointer entry in the CCB points to
1554	* the buffer directly. In second mode the data pointer points to a
1555	* scatter gather list which describes the buffer.
1556	*/
1557	if ( (pCCBGuest->c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_SCATTER_GATHER)
1558	\|\| (pCCBGuest->c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_SCATTER_GATHER))
1559	{
1560	uint32_t cScatterGatherGCRead;
1561	uint32_t iScatterGatherEntry;
1562	SGE32 aScatterGatherReadGC[32]; /* A buffer for scatter gather list entries read from guest memory. */
1563	uint32_t cScatterGatherGCLeft = cbDataCCB / (fIs24Bit ? sizeof(SGE24) : sizeof(SGE32));
1564	RTGCPHYS GCPhysAddrScatterGatherCurrent = u32PhysAddrCCB;
1565
1566	/* Count number of bytes to transfer. */
1567	do
1568	{
1569	cScatterGatherGCRead = (cScatterGatherGCLeft < RT_ELEMENTS(aScatterGatherReadGC))
1570	? cScatterGatherGCLeft
1571	: RT_ELEMENTS(aScatterGatherReadGC);
1572	cScatterGatherGCLeft -= cScatterGatherGCRead;
1573
1574	buslogicR3ReadSGEntries(pDevIns, fIs24Bit, GCPhysAddrScatterGatherCurrent, cScatterGatherGCRead, aScatterGatherReadGC);
1575
1576	for (iScatterGatherEntry = 0; iScatterGatherEntry < cScatterGatherGCRead; iScatterGatherEntry++)
1577	cbBuf += aScatterGatherReadGC[iScatterGatherEntry].cbSegment;
1578
1579	/* Set address to the next entries to read. */
1580	GCPhysAddrScatterGatherCurrent += cScatterGatherGCRead * (fIs24Bit ? sizeof(SGE24) : sizeof(SGE32));
1581	} while (cScatterGatherGCLeft > 0);
1582
1583	Log(("%s: cbBuf=%d\n", __FUNCTION__, cbBuf));
1584	}
1585	else if ( pCCBGuest->c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB
1586	\|\| pCCBGuest->c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_DATA_LENGTH)
1587	cbBuf = cbDataCCB;
1588	}
1589
1590	if (RT_SUCCESS(rc))
1591	*pcbBuf = cbBuf;
1592
1593	return rc;
1594	}
1595
1596	/**
1597	* Copy from guest to host memory worker.
1598	*
1599	* @copydoc FNBUSLOGICR3MEMCOPYCALLBACK
1600	*/
1601	static DECLCALLBACK(void) buslogicR3CopyBufferFromGuestWorker(PPDMDEVINS pDevIns, PBUSLOGIC pThis, RTGCPHYS GCPhys,
1602	PRTSGBUF pSgBuf, size_t cbCopy, size_t *pcbSkip)
1603	{
1604	size_t cbSkipped = RT_MIN(cbCopy, *pcbSkip);
1605	cbCopy -= cbSkipped;
1606	GCPhys += cbSkipped;
1607	*pcbSkip -= cbSkipped;
1608
1609	while (cbCopy)
1610	{
1611	size_t cbSeg = cbCopy;
1612	void *pvSeg = RTSgBufGetNextSegment(pSgBuf, &cbSeg);
1613
1614	AssertPtr(pvSeg);
1615	blPhysReadUser(pDevIns, pThis, GCPhys, pvSeg, cbSeg);
1616	GCPhys += cbSeg;
1617	cbCopy -= cbSeg;
1618	}
1619	}
1620
1621	/**
1622	* Copy from host to guest memory worker.
1623	*
1624	* @copydoc FNBUSLOGICR3MEMCOPYCALLBACK
1625	*/
1626	static DECLCALLBACK(void) buslogicR3CopyBufferToGuestWorker(PPDMDEVINS pDevIns, PBUSLOGIC pThis, RTGCPHYS GCPhys,
1627	PRTSGBUF pSgBuf, size_t cbCopy, size_t *pcbSkip)
1628	{
1629	size_t cbSkipped = RT_MIN(cbCopy, *pcbSkip);
1630	cbCopy -= cbSkipped;
1631	GCPhys += cbSkipped;
1632	*pcbSkip -= cbSkipped;
1633
1634	while (cbCopy)
1635	{
1636	size_t cbSeg = cbCopy;
1637	void *pvSeg = RTSgBufGetNextSegment(pSgBuf, &cbSeg);
1638
1639	AssertPtr(pvSeg);
1640	blPhysWriteUser(pDevIns, pThis, GCPhys, pvSeg, cbSeg);
1641	GCPhys += cbSeg;
1642	cbCopy -= cbSeg;
1643	}
1644	}
1645
1646	/**
1647	* Walks the guest S/G buffer calling the given copy worker for every buffer.
1648	*
1649	* @returns The amout of bytes actually copied.
1650	* @param pDevIns The device instance.
1651	* @param pThis Pointer to the Buslogic device state.
1652	* @param pReq Pointer to the request state.
1653	* @param pfnCopyWorker The copy method to apply for each guest buffer.
1654	* @param pSgBuf The host S/G buffer.
1655	* @param cbSkip How many bytes to skip in advance before starting to copy.
1656	* @param cbCopy How many bytes to copy.
1657	*/
1658	static size_t buslogicR3SgBufWalker(PPDMDEVINS pDevIns, PBUSLOGIC pThis, PBUSLOGICREQ pReq,
1659	PFNBUSLOGICR3MEMCOPYCALLBACK pfnCopyWorker,
1660	PRTSGBUF pSgBuf, size_t cbSkip, size_t cbCopy)
1661	{
1662	uint32_t cbDataCCB;
1663	uint32_t u32PhysAddrCCB;
1664	size_t cbCopied = 0;
1665
1666	/*
1667	* Add the amount to skip to the host buffer size to avoid a
1668	* few conditionals later on.
1669	*/
1670	cbCopy += cbSkip;
1671
1672	/* Extract the data length and physical address from the CCB. */
1673	if (pReq->fIs24Bit)
1674	{
1675	u32PhysAddrCCB = ADDR_TO_U32(pReq->CCBGuest.o.aPhysAddrData);
1676	cbDataCCB = LEN_TO_U32(pReq->CCBGuest.o.acbData);
1677	}
1678	else
1679	{
1680	u32PhysAddrCCB = pReq->CCBGuest.n.u32PhysAddrData;
1681	cbDataCCB = pReq->CCBGuest.n.cbData;
1682	}
1683
1684	#if 1
1685	/* Hack for NT 10/91: A CCB describes a 2K buffer, but TEST UNIT READY is executed. This command
1686	* returns no data, hence the buffer must be left alone!
1687	*/
1688	if (pReq->CCBGuest.c.abCDB[0] == 0)
1689	cbDataCCB = 0;
1690	#endif
1691
1692	LogFlowFunc(("pReq=%#p cbDataCCB=%u direction=%u cbCopy=%zu\n", pReq, cbDataCCB,
1693	pReq->CCBGuest.c.uDataDirection, cbCopy));
1694
1695	if ( (cbDataCCB > 0)
1696	&& ( pReq->CCBGuest.c.uDataDirection == BUSLOGIC_CCB_DIRECTION_IN
1697	\|\| pReq->CCBGuest.c.uDataDirection == BUSLOGIC_CCB_DIRECTION_OUT
1698	\|\| pReq->CCBGuest.c.uDataDirection == BUSLOGIC_CCB_DIRECTION_UNKNOWN))
1699	{
1700	if ( (pReq->CCBGuest.c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_SCATTER_GATHER)
1701	\|\| (pReq->CCBGuest.c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_SCATTER_GATHER))
1702	{
1703	uint32_t cScatterGatherGCRead;
1704	uint32_t iScatterGatherEntry;
1705	SGE32 aScatterGatherReadGC[32]; /* Number of scatter gather list entries read from guest memory. */
1706	uint32_t cScatterGatherGCLeft = cbDataCCB / (pReq->fIs24Bit ? sizeof(SGE24) : sizeof(SGE32));
1707	RTGCPHYS GCPhysAddrScatterGatherCurrent = u32PhysAddrCCB;
1708
1709	do
1710	{
1711	cScatterGatherGCRead = (cScatterGatherGCLeft < RT_ELEMENTS(aScatterGatherReadGC))
1712	? cScatterGatherGCLeft
1713	: RT_ELEMENTS(aScatterGatherReadGC);
1714	cScatterGatherGCLeft -= cScatterGatherGCRead;
1715
1716	buslogicR3ReadSGEntries(pDevIns, pReq->fIs24Bit, GCPhysAddrScatterGatherCurrent,
1717	cScatterGatherGCRead, aScatterGatherReadGC);
1718
1719	for (iScatterGatherEntry = 0; iScatterGatherEntry < cScatterGatherGCRead && cbCopy > 0; iScatterGatherEntry++)
1720	{
1721	RTGCPHYS GCPhysAddrDataBase;
1722	size_t cbCopyThis;
1723
1724	Log(("%s: iScatterGatherEntry=%u\n", __FUNCTION__, iScatterGatherEntry));
1725
1726	GCPhysAddrDataBase = (RTGCPHYS)aScatterGatherReadGC[iScatterGatherEntry].u32PhysAddrSegmentBase;
1727	cbCopyThis = RT_MIN(cbCopy, aScatterGatherReadGC[iScatterGatherEntry].cbSegment);
1728
1729	Log(("%s: GCPhysAddrDataBase=%RGp cbCopyThis=%zu\n", __FUNCTION__, GCPhysAddrDataBase, cbCopyThis));
1730
1731	pfnCopyWorker(pDevIns, pThis, GCPhysAddrDataBase, pSgBuf, cbCopyThis, &cbSkip);
1732	cbCopied += cbCopyThis;
1733	cbCopy -= cbCopyThis;
1734	}
1735
1736	/* Set address to the next entries to read. */
1737	GCPhysAddrScatterGatherCurrent += cScatterGatherGCRead * (pReq->fIs24Bit ? sizeof(SGE24) : sizeof(SGE32));
1738	} while ( cScatterGatherGCLeft > 0
1739	&& cbCopy > 0);
1740
1741	}
1742	else if ( pReq->CCBGuest.c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB
1743	\|\| pReq->CCBGuest.c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_DATA_LENGTH)
1744	{
1745	/* The buffer is not scattered. */
1746	RTGCPHYS GCPhysAddrDataBase = u32PhysAddrCCB;
1747
1748	AssertMsg(GCPhysAddrDataBase != 0, ("Physical address is 0\n"));
1749
1750	Log(("Non-scattered buffer:\n"));
1751	Log(("u32PhysAddrData=%#x\n", u32PhysAddrCCB));
1752	Log(("cbData=%u\n", cbDataCCB));
1753	Log(("GCPhysAddrDataBase=0x%RGp\n", GCPhysAddrDataBase));
1754
1755	/* Copy the data into the guest memory. */
1756	pfnCopyWorker(pDevIns, pThis, GCPhysAddrDataBase, pSgBuf, RT_MIN(cbDataCCB, cbCopy), &cbSkip);
1757	cbCopied += RT_MIN(cbDataCCB, cbCopy);
1758	}
1759	}
1760
1761	return cbCopied - RT_MIN(cbSkip, cbCopied);
1762	}
1763
1764	/**
1765	* Copies a data buffer into the S/G buffer set up by the guest.
1766	*
1767	* @returns Amount of bytes copied to the guest.
1768	* @param pDevIns The device instance.
1769	* @param pThis Pointer to the shared BusLogic instance data.
1770	* @param pReq Request structure.
1771	* @param pSgBuf The S/G buffer to copy from.
1772	* @param cbSkip How many bytes to skip in advance before starting to copy.
1773	* @param cbCopy How many bytes to copy.
1774	*/
1775	static size_t buslogicR3CopySgBufToGuest(PPDMDEVINS pDevIns, PBUSLOGIC pThis, PBUSLOGICREQ pReq,
1776	PRTSGBUF pSgBuf, size_t cbSkip, size_t cbCopy)
1777	{
1778	return buslogicR3SgBufWalker(pDevIns, pThis, pReq, buslogicR3CopyBufferToGuestWorker, pSgBuf, cbSkip, cbCopy);
1779	}
1780
1781	/**
1782	* Copies the guest S/G buffer into a host data buffer.
1783	*
1784	* @returns Amount of bytes copied from the guest.
1785	* @param pDevIns The device instance.
1786	* @param pThis Pointer to the shared BusLogic instance data.
1787	* @param pReq Request structure.
1788	* @param pSgBuf The S/G buffer to copy into.
1789	* @param cbSkip How many bytes to skip in advance before starting to copy.
1790	* @param cbCopy How many bytes to copy.
1791	*/
1792	static size_t buslogicR3CopySgBufFromGuest(PPDMDEVINS pDevIns, PBUSLOGIC pThis, PBUSLOGICREQ pReq,
1793	PRTSGBUF pSgBuf, size_t cbSkip, size_t cbCopy)
1794	{
1795	return buslogicR3SgBufWalker(pDevIns, pThis, pReq, buslogicR3CopyBufferFromGuestWorker, pSgBuf, cbSkip, cbCopy);
1796	}
1797
1798	/** Convert sense buffer length taking into account shortcut values. */
1799	static uint32_t buslogicR3ConvertSenseBufferLength(uint32_t cbSense)
1800	{
1801	/* Convert special sense buffer length values. */
1802	if (cbSense == 0)
1803	cbSense = 14; /* 0 means standard 14-byte buffer. */
1804	else if (cbSense == 1)
1805	cbSense = 0; /* 1 means no sense data. */
1806	else if (cbSense < 8)
1807	AssertMsgFailed(("Reserved cbSense value of %d used!\n", cbSense));
1808
1809	return cbSense;
1810	}
1811
1812	/**
1813	* Free the sense buffer.
1814	*
1815	* @returns nothing.
1816	* @param pReq Pointer to the request state.
1817	* @param fCopy If sense data should be copied to guest memory.
1818	*/
1819	static void buslogicR3SenseBufferFree(PBUSLOGICREQ pReq, bool fCopy)
1820	{
1821	uint32_t cbSenseBuffer;
1822
1823	cbSenseBuffer = buslogicR3ConvertSenseBufferLength(pReq->CCBGuest.c.cbSenseData);
1824
1825	/* Copy the sense buffer into guest memory if requested. */
1826	if (fCopy && cbSenseBuffer)
1827	{
1828	PPDMDEVINS pDevIns = pReq->pTargetDevice->pDevIns;
1829	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
1830	RTGCPHYS GCPhysAddrSenseBuffer;
1831
1832	/* With 32-bit CCBs, the (optional) sense buffer physical address is provided separately.
1833	* On the other hand, with 24-bit CCBs, the sense buffer is simply located at the end of
1834	* the CCB, right after the variable-length CDB.
1835	*/
1836	if (pReq->fIs24Bit)
1837	{
1838	GCPhysAddrSenseBuffer = pReq->GCPhysAddrCCB;
1839	GCPhysAddrSenseBuffer += pReq->CCBGuest.c.cbCDB + RT_OFFSETOF(CCB24, abCDB);
1840	}
1841	else
1842	GCPhysAddrSenseBuffer = pReq->CCBGuest.n.u32PhysAddrSenseData;
1843
1844	Log3(("%s: sense buffer: %.*Rhxs\n", __FUNCTION__, cbSenseBuffer, pReq->pbSenseBuffer));
1845	blPhysWriteMeta(pDevIns, pThis, GCPhysAddrSenseBuffer, pReq->pbSenseBuffer, cbSenseBuffer);
1846	}
1847
1848	RTMemFree(pReq->pbSenseBuffer);
1849	pReq->pbSenseBuffer = NULL;
1850	}
1851
1852	/**
1853	* Alloc the sense buffer.
1854	*
1855	* @returns VBox status code.
1856	* @param pReq Pointer to the task state.
1857	*/
1858	static int buslogicR3SenseBufferAlloc(PBUSLOGICREQ pReq)
1859	{
1860	pReq->pbSenseBuffer = NULL;
1861
1862	uint32_t cbSenseBuffer = buslogicR3ConvertSenseBufferLength(pReq->CCBGuest.c.cbSenseData);
1863	if (cbSenseBuffer)
1864	{
1865	pReq->pbSenseBuffer = (uint8_t *)RTMemAllocZ(cbSenseBuffer);
1866	if (!pReq->pbSenseBuffer)
1867	return VERR_NO_MEMORY;
1868	}
1869
1870	return VINF_SUCCESS;
1871	}
1872
1873	#endif /* IN_RING3 */
1874
1875	/**
1876	* Parses the command buffer and executes it.
1877	*
1878	* @returns VBox status code.
1879	* @param pDevIns The PDM device instance.
1880	* @param pThis Pointer to the shared BusLogic instance data.
1881	*/
1882	static int buslogicProcessCommand(PPDMDEVINS pDevIns, PBUSLOGIC pThis)
1883	{
1884	int rc = VINF_SUCCESS;
1885	bool fSuppressIrq = false;
1886	bool fSuppressCMDC = false;
1887
1888	LogFlowFunc(("pThis=%#p\n", pThis));
1889	AssertMsg(pThis->uOperationCode != 0xff, ("There is no command to execute\n"));
1890
1891	switch (pThis->uOperationCode)
1892	{
1893	case BUSLOGICCOMMAND_TEST_CMDC_INTERRUPT:
1894	/* Valid command, no reply. */
1895	pThis->cbReplyParametersLeft = 0;
1896	break;
1897	case BUSLOGICCOMMAND_INQUIRE_PCI_HOST_ADAPTER_INFORMATION:
1898	{
1899	PReplyInquirePCIHostAdapterInformation pReply = (PReplyInquirePCIHostAdapterInformation)pThis->aReplyBuffer;
1900	memset(pReply, 0, sizeof(ReplyInquirePCIHostAdapterInformation));
1901
1902	/* Modeled after a real BT-958(D) */
1903	pReply->HighByteTerminated = 1;
1904	pReply->LowByteTerminated = 1;
1905	pReply->JP1 = 1; /* Closed; "Factory configured - do not alter" */
1906	pReply->InformationIsValid = 1;
1907	pReply->IsaIOPort = pThis->uISABaseCode < 6 ? pThis->uISABaseCode : 0xff;
1908	pReply->IRQ = PCIDevGetInterruptLine(pDevIns->apPciDevs[0]);
1909	pThis->cbReplyParametersLeft = sizeof(ReplyInquirePCIHostAdapterInformation);
1910	break;
1911	}
1912	case BUSLOGICCOMMAND_SET_SCSI_SELECTION_TIMEOUT:
1913	{
1914	/* no-op */
1915	pThis->cbReplyParametersLeft = 0;
1916	break;
1917	}
1918	case BUSLOGICCOMMAND_MODIFY_IO_ADDRESS:
1919	{
1920
1921	/* Modify the ISA-compatible I/O port base. Note that this technically
1922	* violates the PCI spec, as this address is not reported through PCI.
1923	* However, it is required for compatibility with old drivers.
1924	*/
1925	#ifdef IN_RING3 /* We can do this from ring-0 now, but we'd like to see the LogRel, so we keep going back to ring-3 anyway. */
1926	uint8_t baseCode = pThis->aCommandBuffer[0];
1927
1928	Log(("ISA I/O for PCI (code %x)\n", baseCode));
1929	pThis->cbReplyParametersLeft = 0;
1930	if (baseCode < 8) {
1931	buslogicR3RegisterISARange(pDevIns, pThis, baseCode);
1932	fSuppressIrq = true;
1933	fSuppressCMDC = true;
1934	}
1935	else
1936	{
1937	Log(("ISA base %#x not valid for this adapter\n", baseCode));
1938	pThis->regStatus \|= BL_STAT_CMDINV;
1939	}
1940	break;
1941	#else
1942	AssertMsgFailed(("Must never get here!\n"));
1943	break;
1944	#endif
1945	}
1946	case BUSLOGICCOMMAND_INQUIRE_BOARD_ID:
1947	{
1948	/* The special option byte is important: If it is '0' or 'B', Windows NT drivers
1949	* for Adaptec AHA-154x may claim the adapter. The BusLogic drivers will claim
1950	* the adapter only when the byte is not '0' or 'B'.
1951	*/
1952	if (pThis->uDevType == DEV_AHA_1540B)
1953	{
1954	pThis->aReplyBuffer[0] = 'A'; /* Firmware option bytes */
1955	pThis->aReplyBuffer[1] = '0'; /* Special option byte */
1956	}
1957	else
1958	{
1959	pThis->aReplyBuffer[0] = 'A'; /* Firmware option bytes */
1960	pThis->aReplyBuffer[1] = 'A'; /* Special option byte */
1961	}
1962
1963	/* We report version 5.07B. This reply will provide the first two digits. */
1964	pThis->aReplyBuffer[2] = '5'; /* Major version 5 */
1965	pThis->aReplyBuffer[3] = '0'; /* Minor version 0 */
1966	pThis->cbReplyParametersLeft = 4; /* Reply is 4 bytes long */
1967	break;
1968	}
1969	case BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_3RD_LETTER:
1970	{
1971	if (pThis->uDevType == DEV_AHA_1540B)
1972	{
1973	/* Newer ASPI4DOS.SYS versions expect this command to fail. */
1974	Log(("Command %#x not valid for this adapter\n", pThis->uOperationCode));
1975	pThis->cbReplyParametersLeft = 0;
1976	pThis->regStatus \|= BL_STAT_CMDINV;
1977	break;
1978	}
1979
1980	pThis->aReplyBuffer[0] = '7';
1981	pThis->cbReplyParametersLeft = 1;
1982	break;
1983	}
1984	case BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_LETTER:
1985	{
1986	pThis->aReplyBuffer[0] = 'B';
1987	pThis->cbReplyParametersLeft = 1;
1988	break;
1989	}
1990	case BUSLOGICCOMMAND_SET_ADAPTER_OPTIONS:
1991	/* The parameter list length is determined by the first byte of the command buffer. */
1992	if (pThis->iParameter == 1)
1993	{
1994	/* First pass - set the number of following parameter bytes. */
1995	pThis->cbCommandParametersLeft = RT_MIN(pThis->aCommandBuffer[0], sizeof(pThis->aCommandBuffer) - 1);
1996	Log(("Set HA options: %u bytes follow\n", pThis->cbCommandParametersLeft));
1997	}
1998	else
1999	{
2000	/* Second pass - process received data. */
2001	Log(("Set HA options: received %u bytes\n", pThis->aCommandBuffer[0]));
2002	/* We ignore the data - it only concerns the SCSI hardware protocol. */
2003	}
2004	pThis->cbReplyParametersLeft = 0;
2005	break;
2006
2007	case BUSLOGICCOMMAND_EXECUTE_SCSI_COMMAND:
2008	/* The parameter list length is at least 12 bytes; the 12th byte determines
2009	* the number of additional CDB bytes that will follow.
2010	*/
2011	if (pThis->iParameter == 12)
2012	{
2013	/* First pass - set the number of following CDB bytes. */
2014	pThis->cbCommandParametersLeft = RT_MIN(pThis->aCommandBuffer[11], sizeof(pThis->aCommandBuffer) - 12);
2015	Log(("Execute SCSI cmd: %u more bytes follow\n", pThis->cbCommandParametersLeft));
2016	}
2017	else
2018	{
2019	PESCMD pCmd;
2020
2021	/* Second pass - process received data. */
2022	Log(("Execute SCSI cmd: received %u bytes\n", pThis->aCommandBuffer[0]));
2023
2024	pCmd = (PESCMD)pThis->aCommandBuffer;
2025	Log(("Addr %08X, cbData %08X, cbCDB=%u\n", pCmd->u32PhysAddrData, pCmd->cbData, pCmd->cbCDB));
2026	}
2027	// This is currently a dummy - just fails every command.
2028	pThis->cbReplyParametersLeft = 4;
2029	pThis->aReplyBuffer[0] = pThis->aReplyBuffer[1] = 0;
2030	pThis->aReplyBuffer[2] = 0x11; /* HBA status (timeout). */
2031	pThis->aReplyBuffer[3] = 0; /* Device status. */
2032	break;
2033
2034	case BUSLOGICCOMMAND_INQUIRE_HOST_ADAPTER_MODEL_NUMBER:
2035	{
2036	/* Not supported on AHA-154x. */
2037	if (pThis->uDevType == DEV_AHA_1540B)
2038	{
2039	Log(("Command %#x not valid for this adapter\n", pThis->uOperationCode));
2040	pThis->cbReplyParametersLeft = 0;
2041	pThis->regStatus \|= BL_STAT_CMDINV;
2042	break;
2043	}
2044
2045	/* The reply length is set by the guest and is found in the first byte of the command buffer. */
2046	if (pThis->aCommandBuffer[0] > sizeof(pThis->aReplyBuffer))
2047	{
2048	Log(("Requested too much adapter model number data (%u)!\n", pThis->aCommandBuffer[0]));
2049	pThis->regStatus \|= BL_STAT_CMDINV;
2050	break;
2051	}
2052	pThis->cbReplyParametersLeft = pThis->aCommandBuffer[0];
2053	memset(pThis->aReplyBuffer, 0, sizeof(pThis->aReplyBuffer));
2054	const char aModelName[] = "958D "; /* Trailing \0 is fine, that's the filler anyway. */
2055	int cCharsToTransfer = pThis->cbReplyParametersLeft <= sizeof(aModelName)
2056	? pThis->cbReplyParametersLeft
2057	: sizeof(aModelName);
2058
2059	for (int i = 0; i < cCharsToTransfer; i++)
2060	pThis->aReplyBuffer[i] = aModelName[i];
2061
2062	break;
2063	}
2064	case BUSLOGICCOMMAND_INQUIRE_CONFIGURATION:
2065	{
2066	uint8_t uIrq;
2067
2068	if (pThis->uIsaIrq)
2069	uIrq = pThis->uIsaIrq;
2070	else
2071	uIrq = PCIDevGetInterruptLine(pDevIns->apPciDevs[0]);
2072
2073	pThis->cbReplyParametersLeft = sizeof(ReplyInquireConfiguration);
2074	PReplyInquireConfiguration pReply = (PReplyInquireConfiguration)pThis->aReplyBuffer;
2075	memset(pReply, 0, sizeof(ReplyInquireConfiguration));
2076
2077	pReply->uHostAdapterId = 7; /* The controller has always 7 as ID. */
2078	pReply->fDmaChannel6 = 1; /* DMA channel 6 is a good default. */
2079
2080	/* The PCI IRQ is not necessarily representable in this structure.
2081	* If that is the case, the guest likely won't function correctly,
2082	* therefore we log a warning. Note that for ISA configurations, we
2083	* can only allow IRQs that can be supported; for PCI, the HBA
2084	* has no control over IRQ assignment.
2085	*/
2086	switch (uIrq)
2087	{
2088	case 9: pReply->fIrqChannel9 = 1; break;
2089	case 10: pReply->fIrqChannel10 = 1; break;
2090	case 11: pReply->fIrqChannel11 = 1; break;
2091	case 12: pReply->fIrqChannel12 = 1; break;
2092	case 14: pReply->fIrqChannel14 = 1; break;
2093	case 15: pReply->fIrqChannel15 = 1; break;
2094	default:
2095	LogRel(("Warning: PCI IRQ %d cannot be represented as ISA!\n", uIrq));
2096	break;
2097	}
2098	break;
2099	}
2100	case BUSLOGICCOMMAND_INQUIRE_EXTENDED_SETUP_INFORMATION:
2101	{
2102	/* Some Adaptec AHA-154x drivers (e.g. OS/2) execute this command and expect
2103	* it to fail. If it succeeds, the drivers refuse to load. However, some newer
2104	* Adaptec 154x models supposedly support it too??
2105	*/
2106	if (pThis->uDevType == DEV_AHA_1540B)
2107	{
2108	Log(("Command %#x not valid for this adapter\n", pThis->uOperationCode));
2109	pThis->cbReplyParametersLeft = 0;
2110	pThis->regStatus \|= BL_STAT_CMDINV;
2111	break;
2112	}
2113
2114	/* The reply length is set by the guest and is found in the first byte of the command buffer. */
2115	pThis->cbReplyParametersLeft = pThis->aCommandBuffer[0];
2116	PReplyInquireExtendedSetupInformation pReply = (PReplyInquireExtendedSetupInformation)pThis->aReplyBuffer;
2117	memset(pReply, 0, sizeof(ReplyInquireExtendedSetupInformation));
2118
2119	/** @todo should this reflect the RAM contents (AutoSCSIRam)? */
2120	pReply->uBusType = 'E'; /* EISA style */
2121	pReply->u16ScatterGatherLimit = 8192;
2122	pReply->cMailbox = pThis->cMailbox;
2123	pReply->uMailboxAddressBase = (uint32_t)pThis->GCPhysAddrMailboxOutgoingBase;
2124	pReply->fLevelSensitiveInterrupt = true;
2125	pReply->fHostWideSCSI = true;
2126	pReply->fHostUltraSCSI = true;
2127	memcpy(pReply->aFirmwareRevision, "07B", sizeof(pReply->aFirmwareRevision));
2128
2129	break;
2130	}
2131	case BUSLOGICCOMMAND_INQUIRE_SETUP_INFORMATION:
2132	{
2133	/* The reply length is set by the guest and is found in the first byte of the command buffer. */
2134	pThis->cbReplyParametersLeft = pThis->aCommandBuffer[0];
2135	PReplyInquireSetupInformation pReply = (PReplyInquireSetupInformation)pThis->aReplyBuffer;
2136	memset(pReply, 0, sizeof(ReplyInquireSetupInformation));
2137	pReply->fSynchronousInitiationEnabled = true;
2138	pReply->fParityCheckingEnabled = true;
2139	pReply->cMailbox = pThis->cMailbox;
2140	U32_TO_ADDR(pReply->MailboxAddress, pThis->GCPhysAddrMailboxOutgoingBase);
2141	/* The 'D' signature (actually 'SD' for Storage Dimensions, and 'BD' for BusLogic)
2142	* prevents Adaptec's OS/2 drivers from getting too friendly with BusLogic hardware
2143	* and upsetting the HBA state.
2144	*/
2145	if (pThis->uDevType == DEV_AHA_1540B)
2146	{
2147	pReply->uSignature = 0; /* Zeros for Adaptec. */
2148	pReply->uCharacterD = 0;
2149	}
2150	else
2151	{
2152	pReply->uSignature = 'B';
2153	pReply->uCharacterD = 'D'; /* BusLogic model. */
2154	}
2155	pReply->uHostBusType = 'F'; /* PCI bus. */
2156	break;
2157	}
2158	case BUSLOGICCOMMAND_FETCH_HOST_ADAPTER_LOCAL_RAM:
2159	{
2160	/*
2161	* First element in the command buffer contains start offset to read from
2162	* and second one the number of bytes to read.
2163	*/
2164	uint8_t uOffset = pThis->aCommandBuffer[0];
2165	pThis->cbReplyParametersLeft = pThis->aCommandBuffer[1];
2166
2167	pThis->fUseLocalRam = true;
2168	pThis->iReply = uOffset;
2169	break;
2170	}
2171	case BUSLOGICCOMMAND_INITIALIZE_MAILBOX:
2172	{
2173	PRequestInitMbx pRequest = (PRequestInitMbx)pThis->aCommandBuffer;
2174
2175	pThis->cbReplyParametersLeft = 0;
2176	if (!pRequest->cMailbox)
2177	{
2178	Log(("cMailboxes=%u (24-bit mode), fail!\n", pThis->cMailbox));
2179	pThis->regStatus \|= BL_STAT_CMDINV;
2180	break;
2181	}
2182	pThis->fMbxIs24Bit = true;
2183	pThis->cMailbox = pRequest->cMailbox;
2184	pThis->uMailboxOutgoingPositionCurrent = pThis->uMailboxIncomingPositionCurrent = 0;
2185	pThis->GCPhysAddrMailboxOutgoingBase = (RTGCPHYS)ADDR_TO_U32(pRequest->aMailboxBaseAddr);
2186	/* The area for incoming mailboxes is right after the last entry of outgoing mailboxes. */
2187	pThis->GCPhysAddrMailboxIncomingBase = pThis->GCPhysAddrMailboxOutgoingBase + (pThis->cMailbox * sizeof(Mailbox24));
2188
2189	Log(("GCPhysAddrMailboxOutgoingBase=%RGp\n", pThis->GCPhysAddrMailboxOutgoingBase));
2190	Log(("GCPhysAddrMailboxIncomingBase=%RGp\n", pThis->GCPhysAddrMailboxIncomingBase));
2191	Log(("cMailboxes=%u (24-bit mode)\n", pThis->cMailbox));
2192	LogRel(("Initialized 24-bit mailbox, %d entries at %08x\n", pRequest->cMailbox, ADDR_TO_U32(pRequest->aMailboxBaseAddr)));
2193
2194	pThis->regStatus &= ~BL_STAT_INREQ;
2195	break;
2196	}
2197	case BUSLOGICCOMMAND_INITIALIZE_EXTENDED_MAILBOX:
2198	{
2199	if (pThis->uDevType == DEV_AHA_1540B)
2200	{
2201	Log(("Command %#x not valid for this adapter\n", pThis->uOperationCode));
2202	pThis->cbReplyParametersLeft = 0;
2203	pThis->regStatus \|= BL_STAT_CMDINV;
2204	break;
2205	}
2206
2207	PRequestInitializeExtendedMailbox pRequest = (PRequestInitializeExtendedMailbox)pThis->aCommandBuffer;
2208
2209	pThis->cbReplyParametersLeft = 0;
2210	if (!pRequest->cMailbox)
2211	{
2212	Log(("cMailboxes=%u (32-bit mode), fail!\n", pThis->cMailbox));
2213	pThis->regStatus \|= BL_STAT_CMDINV;
2214	break;
2215	}
2216	pThis->fMbxIs24Bit = false;
2217	pThis->cMailbox = pRequest->cMailbox;
2218	pThis->uMailboxOutgoingPositionCurrent = pThis->uMailboxIncomingPositionCurrent = 0;
2219	pThis->GCPhysAddrMailboxOutgoingBase = (RTGCPHYS)pRequest->uMailboxBaseAddress;
2220	/* The area for incoming mailboxes is right after the last entry of outgoing mailboxes. */
2221	pThis->GCPhysAddrMailboxIncomingBase = (RTGCPHYS)pRequest->uMailboxBaseAddress + (pThis->cMailbox * sizeof(Mailbox32));
2222
2223	Log(("GCPhysAddrMailboxOutgoingBase=%RGp\n", pThis->GCPhysAddrMailboxOutgoingBase));
2224	Log(("GCPhysAddrMailboxIncomingBase=%RGp\n", pThis->GCPhysAddrMailboxIncomingBase));
2225	Log(("cMailboxes=%u (32-bit mode)\n", pThis->cMailbox));
2226	LogRel(("Initialized 32-bit mailbox, %d entries at %08x\n", pRequest->cMailbox, pRequest->uMailboxBaseAddress));
2227
2228	pThis->regStatus &= ~BL_STAT_INREQ;
2229	break;
2230	}
2231	case BUSLOGICCOMMAND_ENABLE_STRICT_ROUND_ROBIN_MODE:
2232	{
2233	if (pThis->aCommandBuffer[0] == 0)
2234	pThis->fStrictRoundRobinMode = false;
2235	else if (pThis->aCommandBuffer[0] == 1)
2236	pThis->fStrictRoundRobinMode = true;
2237	else
2238	AssertMsgFailed(("Invalid round robin mode %d\n", pThis->aCommandBuffer[0]));
2239
2240	pThis->cbReplyParametersLeft = 0;
2241	break;
2242	}
2243	case BUSLOGICCOMMAND_SET_CCB_FORMAT:
2244	{
2245	if (pThis->aCommandBuffer[0] == 0)
2246	pThis->fExtendedLunCCBFormat = false;
2247	else if (pThis->aCommandBuffer[0] == 1)
2248	pThis->fExtendedLunCCBFormat = true;
2249	else
2250	AssertMsgFailed(("Invalid CCB format %d\n", pThis->aCommandBuffer[0]));
2251
2252	pThis->cbReplyParametersLeft = 0;
2253	break;
2254	}
2255	case BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_0_TO_7:
2256	/* This is supposed to send TEST UNIT READY to each target/LUN.
2257	* We cheat and skip that, since we already know what's attached
2258	*/
2259	memset(pThis->aReplyBuffer, 0, 8);
2260	for (int i = 0; i < 8; ++i)
2261	{
2262	if (pThis->afDevicePresent[i])
2263	pThis->aReplyBuffer[i] = 1;
2264	}
2265	pThis->aReplyBuffer[7] = 0; /* HA hardcoded at ID 7. */
2266	pThis->cbReplyParametersLeft = 8;
2267	break;
2268	case BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_8_TO_15:
2269	/* See note about cheating above. */
2270	memset(pThis->aReplyBuffer, 0, 8);
2271	for (int i = 0; i < 8; ++i)
2272	{
2273	if (pThis->afDevicePresent[i + 8])
2274	pThis->aReplyBuffer[i] = 1;
2275	}
2276	pThis->cbReplyParametersLeft = 8;
2277	break;
2278	case BUSLOGICCOMMAND_INQUIRE_TARGET_DEVICES:
2279	{
2280	/* Each bit which is set in the 16bit wide variable means a present device. */
2281	uint16_t u16TargetsPresentMask = 0;
2282
2283	for (uint8_t i = 0; i < RT_ELEMENTS(pThis->afDevicePresent); i++)
2284	{
2285	if (pThis->afDevicePresent[i])
2286	u16TargetsPresentMask \|= (1 << i);
2287	}
2288	pThis->aReplyBuffer[0] = (uint8_t)u16TargetsPresentMask;
2289	pThis->aReplyBuffer[1] = (uint8_t)(u16TargetsPresentMask >> 8);
2290	pThis->cbReplyParametersLeft = 2;
2291	break;
2292	}
2293	case BUSLOGICCOMMAND_INQUIRE_SYNCHRONOUS_PERIOD:
2294	{
2295	if (pThis->aCommandBuffer[0] > sizeof(pThis->aReplyBuffer))
2296	{
2297	Log(("Requested too much synch period inquiry (%u)!\n", pThis->aCommandBuffer[0]));
2298	pThis->regStatus \|= BL_STAT_CMDINV;
2299	break;
2300	}
2301	pThis->cbReplyParametersLeft = pThis->aCommandBuffer[0];
2302	for (uint8_t i = 0; i < pThis->cbReplyParametersLeft; i++)
2303	pThis->aReplyBuffer[i] = 0; /** @todo Figure if we need something other here. It's not needed for the linux driver */
2304
2305	break;
2306	}
2307	case BUSLOGICCOMMAND_DISABLE_HOST_ADAPTER_INTERRUPT:
2308	{
2309	/* Not supported on AHA-154x HBAs. */
2310	if (pThis->uDevType == DEV_AHA_1540B)
2311	{
2312	Log(("Command %#x not valid for this adapter\n", pThis->uOperationCode));
2313	pThis->cbReplyParametersLeft = 0;
2314	pThis->regStatus \|= BL_STAT_CMDINV;
2315	break;
2316	}
2317
2318	pThis->cbReplyParametersLeft = 0;
2319	if (pThis->aCommandBuffer[0] == 0)
2320	pThis->fIRQEnabled = false;
2321	else
2322	pThis->fIRQEnabled = true;
2323	/* No interrupt signaled regardless of enable/disable. NB: CMDC is still signaled! */
2324	fSuppressIrq = true;
2325	break;
2326	}
2327	case BUSLOGICCOMMAND_ECHO_COMMAND_DATA:
2328	{
2329	pThis->aReplyBuffer[0] = pThis->aCommandBuffer[0];
2330	pThis->cbReplyParametersLeft = 1;
2331	break;
2332	}
2333	case BUSLOGICCOMMAND_ENABLE_OUTGOING_MAILBOX_AVAILABLE_INTERRUPT:
2334	{
2335	uint8_t uEnable = pThis->aCommandBuffer[0];
2336
2337	pThis->cbReplyParametersLeft = 0;
2338	Log(("Enable OMBR: %u\n", uEnable));
2339	/* Only 0/1 are accepted. */
2340	if (uEnable > 1)
2341	pThis->regStatus \|= BL_STAT_CMDINV;
2342	else
2343	{
2344	pThis->LocalRam.structured.autoSCSIData.uReserved6 = uEnable;
2345	fSuppressIrq = true;
2346	fSuppressCMDC = true;
2347	}
2348	break;
2349	}
2350	case BUSLOGICCOMMAND_SET_PREEMPT_TIME_ON_BUS:
2351	{
2352	pThis->cbReplyParametersLeft = 0;
2353	pThis->LocalRam.structured.autoSCSIData.uBusOnDelay = pThis->aCommandBuffer[0];
2354	Log(("Bus-on time: %d\n", pThis->aCommandBuffer[0]));
2355	break;
2356	}
2357	case BUSLOGICCOMMAND_SET_TIME_OFF_BUS:
2358	{
2359	pThis->cbReplyParametersLeft = 0;
2360	pThis->LocalRam.structured.autoSCSIData.uBusOffDelay = pThis->aCommandBuffer[0];
2361	Log(("Bus-off time: %d\n", pThis->aCommandBuffer[0]));
2362	break;
2363	}
2364	case BUSLOGICCOMMAND_SET_BUS_TRANSFER_RATE:
2365	{
2366	pThis->cbReplyParametersLeft = 0;
2367	pThis->LocalRam.structured.autoSCSIData.uDMATransferRate = pThis->aCommandBuffer[0];
2368	Log(("Bus transfer rate: %02X\n", pThis->aCommandBuffer[0]));
2369	break;
2370	}
2371	case BUSLOGICCOMMAND_WRITE_BUSMASTER_CHIP_FIFO:
2372	{
2373	RTGCPHYS GCPhysFifoBuf;
2374	Addr24 addr;
2375
2376	pThis->cbReplyParametersLeft = 0;
2377	addr.hi = pThis->aCommandBuffer[0];
2378	addr.mid = pThis->aCommandBuffer[1];
2379	addr.lo = pThis->aCommandBuffer[2];
2380	GCPhysFifoBuf = (RTGCPHYS)ADDR_TO_U32(addr);
2381	Log(("Write busmaster FIFO at: %04X\n", ADDR_TO_U32(addr)));
2382	blPhysReadMeta(pDevIns, pThis, GCPhysFifoBuf, &pThis->LocalRam.u8View[64], 64);
2383	break;
2384	}
2385	case BUSLOGICCOMMAND_READ_BUSMASTER_CHIP_FIFO:
2386	{
2387	RTGCPHYS GCPhysFifoBuf;
2388	Addr24 addr;
2389
2390	pThis->cbReplyParametersLeft = 0;
2391	addr.hi = pThis->aCommandBuffer[0];
2392	addr.mid = pThis->aCommandBuffer[1];
2393	addr.lo = pThis->aCommandBuffer[2];
2394	GCPhysFifoBuf = (RTGCPHYS)ADDR_TO_U32(addr);
2395	Log(("Read busmaster FIFO at: %04X\n", ADDR_TO_U32(addr)));
2396	blPhysWriteMeta(pDevIns, pThis, GCPhysFifoBuf, &pThis->LocalRam.u8View[64], 64);
2397	break;
2398	}
2399	default:
2400	AssertMsgFailed(("Invalid command %#x\n", pThis->uOperationCode));
2401	RT_FALL_THRU();
2402	case BUSLOGICCOMMAND_EXT_BIOS_INFO:
2403	case BUSLOGICCOMMAND_UNLOCK_MAILBOX:
2404	/* Commands valid for Adaptec 154xC which we don't handle since
2405	* we pretend being 154xB compatible. Just mark the command as invalid.
2406	*/
2407	Log(("Command %#x not valid for this adapter\n", pThis->uOperationCode));
2408	pThis->cbReplyParametersLeft = 0;
2409	pThis->regStatus \|= BL_STAT_CMDINV;
2410	break;
2411	case BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND: /* Should be handled already. */
2412	AssertMsgFailed(("Invalid mailbox execute state!\n"));
2413	}
2414
2415	Log(("uOperationCode=%#x, cbReplyParametersLeft=%d\n", pThis->uOperationCode, pThis->cbReplyParametersLeft));
2416
2417	/* Fail command if too much parameter data requested. */
2418	if ((pThis->cbCommandParametersLeft + pThis->iParameter) > sizeof(pThis->aCommandBuffer))
2419	{
2420	Log(("Invalid command parameter length (%u)\n", pThis->cbCommandParametersLeft));
2421	pThis->cbReplyParametersLeft = 0;
2422	pThis->cbCommandParametersLeft = 0;
2423	pThis->regStatus \|= BL_STAT_CMDINV;
2424	}
2425
2426	/* Set the data in ready bit in the status register in case the command has a reply. */
2427	if (pThis->cbReplyParametersLeft)
2428	pThis->regStatus \|= BL_STAT_DIRRDY;
2429	else if (!pThis->cbCommandParametersLeft)
2430	buslogicCommandComplete(pDevIns, pThis, fSuppressIrq, fSuppressCMDC);
2431
2432	return rc;
2433	}
2434
2435	/**
2436	* Read a register from the BusLogic adapter.
2437	*
2438	* @returns VBox status code.
2439	* @param pDevIns The device instance.
2440	* @param pThis Pointer to the shared BusLogic instance data.
2441	* @param iRegister The index of the register to read.
2442	* @param pu32 Where to store the register content.
2443	*/
2444	static int buslogicRegisterRead(PPDMDEVINS pDevIns, PBUSLOGIC pThis, unsigned iRegister, uint32_t *pu32)
2445	{
2446	static const char s_szAhaSig[] = "ADAP";
2447	int rc = VINF_SUCCESS;
2448
2449	switch (iRegister)
2450	{
2451	case BUSLOGIC_REGISTER_STATUS:
2452	{
2453	*pu32 = pThis->regStatus;
2454
2455	/* If the diagnostic active bit is set, we are in a guest-initiated
2456	* hard reset. If the guest reads the status register and waits for
2457	* the host adapter ready bit to be set, we terminate the reset right
2458	* away. However, guests may also expect the reset condition to clear
2459	* automatically after a period of time, in which case we can't show
2460	* the DIAG bit at all.
2461	*/
2462	if (pThis->regStatus & BL_STAT_DACT)
2463	{
2464	uint64_t u64AccessTime = PDMDevHlpTMTimeVirtGetNano(pDevIns);
2465
2466	pThis->regStatus &= ~BL_STAT_DACT;
2467	pThis->regStatus \|= BL_STAT_HARDY;
2468
2469	if (u64AccessTime - pThis->u64ResetTime > BUSLOGIC_RESET_DURATION_NS)
2470	{
2471	/* If reset already expired, let the guest see that right away. */
2472	*pu32 = pThis->regStatus;
2473	pThis->u64ResetTime = 0;
2474	}
2475	}
2476	break;
2477	}
2478	case BUSLOGIC_REGISTER_DATAIN:
2479	{
2480	AssertCompileSize(pThis->LocalRam, 256);
2481	AssertCompileSize(pThis->iReply, sizeof(uint8_t));
2482	AssertCompileSize(pThis->cbReplyParametersLeft, sizeof(uint8_t));
2483
2484	if (pThis->fUseLocalRam)
2485	*pu32 = pThis->LocalRam.u8View[pThis->iReply];
2486	else
2487	{
2488	/*
2489	* Real adapters seem to pad the reply with zeroes and allow up to 255 bytes even
2490	* if the real reply is shorter.
2491	*/
2492	if (pThis->iReply >= sizeof(pThis->aReplyBuffer))
2493	*pu32 = 0;
2494	else
2495	*pu32 = pThis->aReplyBuffer[pThis->iReply];
2496	}
2497
2498	/* Careful about underflow - guest can read data register even if
2499	* no data is available.
2500	*/
2501	if (pThis->cbReplyParametersLeft)
2502	{
2503	pThis->iReply++;
2504	pThis->cbReplyParametersLeft--;
2505	if (!pThis->cbReplyParametersLeft)
2506	{
2507	/*
2508	* Reply finished, set command complete bit, unset data-in ready bit and
2509	* interrupt the guest if enabled.
2510	* NB: Some commands do not set the CMDC bit / raise completion interrupt.
2511	*/
2512	if (pThis->uOperationCode == BUSLOGICCOMMAND_FETCH_HOST_ADAPTER_LOCAL_RAM)
2513	buslogicCommandComplete(pDevIns, pThis, true /* fSuppressIrq /, true / fSuppressCMDC */);
2514	else
2515	buslogicCommandComplete(pDevIns, pThis, false, false);
2516	}
2517	}
2518	LogFlowFunc(("data=%02x, iReply=%d, cbReplyParametersLeft=%u\n", *pu32,
2519	pThis->iReply, pThis->cbReplyParametersLeft));
2520	break;
2521	}
2522	case BUSLOGIC_REGISTER_INTERRUPT:
2523	{
2524	*pu32 = pThis->regInterrupt;
2525	break;
2526	}
2527	case BUSLOGIC_REGISTER_GEOMETRY:
2528	{
2529	if (pThis->uDevType == DEV_AHA_1540B)
2530	{
2531	uint8_t off = pThis->uAhaSigIdx & 3;
2532	*pu32 = s_szAhaSig[off];
2533	pThis->uAhaSigIdx = (off + 1) & 3;
2534	}
2535	else
2536	*pu32 = pThis->regGeometry;
2537	break;
2538	}
2539	default:
2540	*pu32 = UINT32_C(0xffffffff);
2541	}
2542
2543	Log2(("%s: pu32=%p:{%.*Rhxs} iRegister=%d rc=%Rrc\n",
2544	__FUNCTION__, pu32, 1, pu32, iRegister, rc));
2545
2546	return rc;
2547	}
2548
2549	/**
2550	* Write a value to a register.
2551	*
2552	* @returns VBox status code.
2553	* @param pDevIns The PDM device instance.
2554	* @param pThis Pointer to the shared BusLogic instance data.
2555	* @param iRegister The index of the register to read.
2556	* @param uVal The value to write.
2557	*/
2558	static int buslogicRegisterWrite(PPDMDEVINS pDevIns, PBUSLOGIC pThis, unsigned iRegister, uint8_t uVal)
2559	{
2560	int rc = VINF_SUCCESS;
2561
2562	switch (iRegister)
2563	{
2564	case BUSLOGIC_REGISTER_CONTROL:
2565	{
2566	if ((uVal & BL_CTRL_RHARD) \|\| (uVal & BL_CTRL_RSOFT))
2567	{
2568	#ifdef IN_RING3
2569	bool fHardReset = !!(uVal & BL_CTRL_RHARD);
2570
2571	LogRel(("BusLogic: %s reset\n", fHardReset ? "hard" : "soft"));
2572	buslogicR3InitiateReset(pDevIns, pThis, fHardReset);
2573	#else
2574	rc = VINF_IOM_R3_IOPORT_WRITE;
2575	#endif
2576	break;
2577	}
2578
2579	rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIntr, VINF_IOM_R3_IOPORT_WRITE);
2580	if (rc != VINF_SUCCESS)
2581	return rc;
2582
2583	#ifdef LOG_ENABLED
2584	uint32_t cMailboxesReady = ASMAtomicXchgU32(&pThis->cInMailboxesReadyIfLogEnabled, 0);
2585	Log(("%u incoming mailboxes were ready when this interrupt was cleared\n", cMailboxesReady));
2586	#endif
2587
2588	if (uVal & BL_CTRL_RINT)
2589	buslogicClearInterrupt(pDevIns, pThis);
2590
2591	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSectIntr);
2592
2593	break;
2594	}
2595	case BUSLOGIC_REGISTER_COMMAND:
2596	{
2597	/* Fast path for mailbox execution command. */
2598	if ((uVal == BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND) && (pThis->uOperationCode == 0xff))
2599	{
2600	/// @todo Should fail if BL_STAT_INREQ is set
2601	/* If there are no mailboxes configured, don't even try to do anything. */
2602	if (pThis->cMailbox)
2603	{
2604	ASMAtomicIncU32(&pThis->cMailboxesReady);
2605	if (!ASMAtomicXchgBool(&pThis->fNotificationSent, true))
2606	{
2607	/* Wake up the worker thread. */
2608	int rc2 = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hEvtProcess);
2609	AssertRC(rc2);
2610	}
2611	}
2612
2613	return rc;
2614	}
2615
2616	/*
2617	* Check if we are already fetch command parameters from the guest.
2618	* If not we initialize executing a new command.
2619	*/
2620	if (pThis->uOperationCode == 0xff)
2621	{
2622	pThis->uOperationCode = uVal;
2623	pThis->iParameter = 0;
2624
2625	/* Mark host adapter as busy and clear the invalid status bit. */
2626	pThis->regStatus &= ~(BL_STAT_HARDY \| BL_STAT_CMDINV);
2627
2628	/* Get the number of bytes for parameters from the command code. */
2629	switch (pThis->uOperationCode)
2630	{
2631	case BUSLOGICCOMMAND_TEST_CMDC_INTERRUPT:
2632	case BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_LETTER:
2633	case BUSLOGICCOMMAND_INQUIRE_BOARD_ID:
2634	case BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_3RD_LETTER:
2635	case BUSLOGICCOMMAND_INQUIRE_PCI_HOST_ADAPTER_INFORMATION:
2636	case BUSLOGICCOMMAND_INQUIRE_CONFIGURATION:
2637	case BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_0_TO_7:
2638	case BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_8_TO_15:
2639	case BUSLOGICCOMMAND_INQUIRE_TARGET_DEVICES:
2640	pThis->cbCommandParametersLeft = 0;
2641	break;
2642	case BUSLOGICCOMMAND_MODIFY_IO_ADDRESS:
2643	case BUSLOGICCOMMAND_INQUIRE_EXTENDED_SETUP_INFORMATION:
2644	case BUSLOGICCOMMAND_DISABLE_HOST_ADAPTER_INTERRUPT:
2645	case BUSLOGICCOMMAND_INQUIRE_HOST_ADAPTER_MODEL_NUMBER:
2646	/* These commands are not on AHA-154x, some Adaptec drivers (ASPI4DOS.SYS) test them. */
2647	if (pThis->uDevType == DEV_AHA_1540B)
2648	{
2649	pThis->cbCommandParametersLeft = 0;
2650	break;
2651	}
2652	RT_FALL_THRU();
2653	case BUSLOGICCOMMAND_INQUIRE_SETUP_INFORMATION:
2654	case BUSLOGICCOMMAND_ENABLE_STRICT_ROUND_ROBIN_MODE:
2655	case BUSLOGICCOMMAND_SET_CCB_FORMAT:
2656	case BUSLOGICCOMMAND_INQUIRE_SYNCHRONOUS_PERIOD:
2657	case BUSLOGICCOMMAND_ECHO_COMMAND_DATA:
2658	case BUSLOGICCOMMAND_ENABLE_OUTGOING_MAILBOX_AVAILABLE_INTERRUPT:
2659	case BUSLOGICCOMMAND_SET_PREEMPT_TIME_ON_BUS:
2660	case BUSLOGICCOMMAND_SET_TIME_OFF_BUS:
2661	case BUSLOGICCOMMAND_SET_BUS_TRANSFER_RATE:
2662	pThis->cbCommandParametersLeft = 1;
2663	break;
2664	case BUSLOGICCOMMAND_FETCH_HOST_ADAPTER_LOCAL_RAM:
2665	pThis->cbCommandParametersLeft = 2;
2666	break;
2667	case BUSLOGICCOMMAND_READ_BUSMASTER_CHIP_FIFO:
2668	case BUSLOGICCOMMAND_WRITE_BUSMASTER_CHIP_FIFO:
2669	pThis->cbCommandParametersLeft = 3;
2670	break;
2671	case BUSLOGICCOMMAND_SET_SCSI_SELECTION_TIMEOUT:
2672	pThis->cbCommandParametersLeft = 4;
2673	break;
2674	case BUSLOGICCOMMAND_INITIALIZE_MAILBOX:
2675	pThis->cbCommandParametersLeft = sizeof(RequestInitMbx);
2676	break;
2677	case BUSLOGICCOMMAND_INITIALIZE_EXTENDED_MAILBOX:
2678	/* Some Adaptec drivers (ASPI4DOS.SYS) test this command. */
2679	if (pThis->uDevType == DEV_AHA_1540B)
2680	{
2681	pThis->cbCommandParametersLeft = 0;
2682	break;
2683	}
2684	pThis->cbCommandParametersLeft = sizeof(RequestInitializeExtendedMailbox);
2685	break;
2686	case BUSLOGICCOMMAND_SET_ADAPTER_OPTIONS:
2687	/* There must be at least one byte following this command. */
2688	pThis->cbCommandParametersLeft = 1;
2689	break;
2690	case BUSLOGICCOMMAND_EXECUTE_SCSI_COMMAND:
2691	/* 12 bytes + variable-length CDB. */
2692	pThis->cbCommandParametersLeft = 12;
2693	break;
2694	case BUSLOGICCOMMAND_EXT_BIOS_INFO:
2695	case BUSLOGICCOMMAND_UNLOCK_MAILBOX:
2696	/* Invalid commands. */
2697	pThis->cbCommandParametersLeft = 0;
2698	break;
2699	case BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND: /* Should not come here anymore. */
2700	default:
2701	AssertMsgFailed(("Invalid operation code %#x\n", uVal));
2702	}
2703	}
2704	else if (pThis->cbCommandParametersLeft)
2705	{
2706	#ifndef IN_RING3
2707	/* This command must be executed in R3 as it rehooks the ISA I/O port. */
2708	if (pThis->uOperationCode == BUSLOGICCOMMAND_MODIFY_IO_ADDRESS)
2709	{
2710	rc = VINF_IOM_R3_IOPORT_WRITE;
2711	break;
2712	}
2713	#endif
2714	/*
2715	* The real adapter would set the Command register busy bit in the status register.
2716	* The guest has to wait until it is unset.
2717	* We don't need to do it because the guest does not continue execution while we are in this
2718	* function.
2719	*/
2720	pThis->aCommandBuffer[pThis->iParameter] = uVal;
2721	pThis->iParameter++;
2722	pThis->cbCommandParametersLeft--;
2723	}
2724
2725	/* Start execution of command if there are no parameters left. */
2726	if (!pThis->cbCommandParametersLeft)
2727	{
2728	rc = buslogicProcessCommand(pDevIns, pThis);
2729	AssertMsgRC(rc, ("Processing command failed rc=%Rrc\n", rc));
2730	}
2731	break;
2732	}
2733
2734	/* On BusLogic adapters, the interrupt and geometry registers are R/W.
2735	* That is different from Adaptec 154x where those are read only.
2736	*/
2737	case BUSLOGIC_REGISTER_INTERRUPT:
2738	if (pThis->uDevType == DEV_AHA_1540B)
2739	break;
2740	pThis->regInterrupt = uVal;
2741	break;
2742
2743	case BUSLOGIC_REGISTER_GEOMETRY:
2744	if (pThis->uDevType == DEV_AHA_1540B)
2745	break;
2746	pThis->regGeometry = uVal;
2747	break;
2748
2749	default:
2750	AssertMsgFailed(("Register not available\n"));
2751	rc = VERR_IOM_IOPORT_UNUSED;
2752	}
2753
2754	return rc;
2755	}
2756
2757	/**
2758	* @callback_method_impl{FNIOMMMIONEWREAD}
2759	*/
2760	static DECLCALLBACK(VBOXSTRICTRC) buslogicMMIORead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS off, void pv, unsigned cb)
2761	{
2762	RT_NOREF(pDevIns, pvUser, off, pv, cb);
2763
2764	/* the linux driver does not make use of the MMIO area. */
2765	ASSERT_GUEST_MSG_FAILED(("MMIO Read: %RGp LB %u\n", off, cb));
2766	return VINF_SUCCESS;
2767	}
2768
2769	/**
2770	* @callback_method_impl{FNIOMMMIONEWWRITE}
2771	*/
2772	static DECLCALLBACK(VBOXSTRICTRC) buslogicMMIOWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS off, void const pv, unsigned cb)
2773	{
2774	RT_NOREF(pDevIns, pvUser, off, pv, cb);
2775
2776	/* the linux driver does not make use of the MMIO area. */
2777	ASSERT_GUEST_MSG_FAILED(("MMIO Write: %RGp LB %u: %.*Rhxs\n", off, cb, cb, pv));
2778	return VINF_SUCCESS;
2779	}
2780
2781	/**
2782	* @callback_method_impl{FNIOMIOPORTNEWIN}
2783	*/
2784	static DECLCALLBACK(VBOXSTRICTRC)
2785	buslogicIOPortRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT offPort, uint32_t pu32, unsigned cb)
2786	{
2787	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
2788	unsigned iRegister = offPort % 4;
2789	RT_NOREF(pvUser, cb);
2790
2791	ASSERT_GUEST(cb == 1);
2792
2793	return buslogicRegisterRead(pDevIns, pThis, iRegister, pu32);
2794	}
2795
2796	/**
2797	* @callback_method_impl{FNIOMIOPORTNEWOUT}
2798	*/
2799	static DECLCALLBACK(VBOXSTRICTRC)
2800	buslogicIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
2801	{
2802	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
2803	unsigned iRegister = offPort % 4;
2804	RT_NOREF(pvUser, cb);
2805
2806	ASSERT_GUEST(cb == 1);
2807
2808	int rc = buslogicRegisterWrite(pDevIns, pThis, iRegister, (uint8_t)u32);
2809
2810	Log2(("#%d %s: pvUser=%#p cb=%d u32=%#x offPort=%#x rc=%Rrc\n",
2811	pDevIns->iInstance, __FUNCTION__, pvUser, cb, u32, offPort, rc));
2812
2813	return rc;
2814	}
2815
2816	#ifdef IN_RING3
2817
2818	/**
2819	* Update the ISA I/O range.
2820	*
2821	* @returns nothing.
2822	* @param pDevIns The device instance.
2823	* @param pThis Pointer to the shared BusLogic instance data.
2824	* @param uBaseCode Encoded ISA I/O base; only low 3 bits are used.
2825	*/
2826	static int buslogicR3RegisterISARange(PPDMDEVINS pDevIns, PBUSLOGIC pThis, uint8_t uBaseCode)
2827	{
2828	uint8_t uCode = uBaseCode & MAX_ISA_BASE;
2829	uint16_t uNewBase = g_aISABases[uCode];
2830	int rc = VINF_SUCCESS;
2831
2832	LogFlowFunc(("ISA I/O code %02X, new base %X\n", uBaseCode, uNewBase));
2833
2834	/* Check if the same port range actually changed. */
2835	if (uNewBase != pThis->IOISABase)
2836	{
2837	/* Unmap the old range, if necessary. */
2838	if (pThis->IOISABase)
2839	{
2840	rc = PDMDevHlpIoPortUnmap(pDevIns, pThis->hIoPortsIsa);
2841	AssertRC(rc);
2842	}
2843	if (RT_SUCCESS(rc))
2844	{
2845	pThis->IOISABase = 0; /* First mark as unregistered. */
2846	pThis->uISABaseCode = ISA_BASE_DISABLED;
2847
2848	if (uNewBase)
2849	{
2850	/* Register the new range if requested. */
2851	rc = PDMDevHlpIoPortMap(pDevIns, pThis->hIoPortsIsa, uNewBase);
2852	if (RT_SUCCESS(rc))
2853	{
2854	pThis->IOISABase = uNewBase;
2855	pThis->uISABaseCode = uCode;
2856	}
2857	}
2858	}
2859	if (RT_SUCCESS(rc))
2860	{
2861	if (uNewBase)
2862	{
2863	Log(("ISA I/O base: %x\n", uNewBase));
2864	LogRel(("BusLogic: ISA I/O base: %x\n", uNewBase));
2865	}
2866	else
2867	{
2868	Log(("Disabling ISA I/O ports.\n"));
2869	LogRel(("BusLogic: ISA I/O disabled\n"));
2870	}
2871	}
2872
2873	}
2874	return rc;
2875	}
2876
2877
2878	static int buslogicR3ReqComplete(PPDMDEVINS pDevIns, PBUSLOGIC pThis, PBUSLOGICCC pThisCC, PBUSLOGICREQ pReq, int rcReq)
2879	{
2880	RT_NOREF(rcReq);
2881	PBUSLOGICDEVICE pTgtDev = pReq->pTargetDevice;
2882
2883	LogFlowFunc(("before decrement %u\n", pTgtDev->cOutstandingRequests));
2884	ASMAtomicDecU32(&pTgtDev->cOutstandingRequests);
2885	LogFlowFunc(("after decrement %u\n", pTgtDev->cOutstandingRequests));
2886
2887	if (pReq->pbSenseBuffer)
2888	buslogicR3SenseBufferFree(pReq, (pReq->u8ScsiSts != SCSI_STATUS_OK));
2889
2890	/* Update residual data length. */
2891	if ( (pReq->CCBGuest.c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_DATA_LENGTH)
2892	\|\| (pReq->CCBGuest.c.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_SCATTER_GATHER))
2893	{
2894	size_t cbResidual = 0;
2895	int rc = pTgtDev->pDrvMediaEx->pfnIoReqQueryResidual(pTgtDev->pDrvMediaEx, pReq->hIoReq, &cbResidual);
2896	AssertRC(rc); Assert(cbResidual == (uint32_t)cbResidual);
2897
2898	if (pReq->fIs24Bit)
2899	U32_TO_LEN(pReq->CCBGuest.o.acbData, (uint32_t)cbResidual);
2900	else
2901	pReq->CCBGuest.n.cbData = (uint32_t)cbResidual;
2902	}
2903
2904	/*
2905	* Save vital things from the request and free it before posting completion
2906	* to avoid that the guest submits a new request with the same ID as the still
2907	* allocated one.
2908	*/
2909	#ifdef LOG_ENABLED
2910	bool fIs24Bit = pReq->fIs24Bit;
2911	#endif
2912	uint8_t u8ScsiSts = pReq->u8ScsiSts;
2913	RTGCPHYS GCPhysAddrCCB = pReq->GCPhysAddrCCB;
2914	CCBU CCBGuest;
2915	memcpy(&CCBGuest, &pReq->CCBGuest, sizeof(CCBU));
2916
2917	pTgtDev->pDrvMediaEx->pfnIoReqFree(pTgtDev->pDrvMediaEx, pReq->hIoReq);
2918	if (u8ScsiSts == SCSI_STATUS_OK)
2919	buslogicR3SendIncomingMailbox(pDevIns, pThis, GCPhysAddrCCB, &CCBGuest,
2920	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_CMD_COMPLETED,
2921	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD,
2922	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITHOUT_ERROR);
2923	else if (u8ScsiSts == SCSI_STATUS_CHECK_CONDITION)
2924	buslogicR3SendIncomingMailbox(pDevIns, pThis, GCPhysAddrCCB, &CCBGuest,
2925	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_CMD_COMPLETED,
2926	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_CHECK_CONDITION,
2927	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITH_ERROR);
2928	else
2929	AssertMsgFailed(("invalid completion status %u\n", u8ScsiSts));
2930
2931	#ifdef LOG_ENABLED
2932	buslogicR3DumpCCBInfo(&CCBGuest, fIs24Bit);
2933	#endif
2934
2935	if (pTgtDev->cOutstandingRequests == 0 && pThisCC->fSignalIdle)
2936	PDMDevHlpAsyncNotificationCompleted(pDevIns);
2937
2938	return VINF_SUCCESS;
2939	}
2940
2941	/**
2942	* @interface_method_impl{PDMIMEDIAPORT,pfnQueryDeviceLocation}
2943	*/
2944	static DECLCALLBACK(int) buslogicR3QueryDeviceLocation(PPDMIMEDIAPORT pInterface, const char **ppcszController,
2945	uint32_t piInstance, uint32_t piLUN)
2946	{
2947	PBUSLOGICDEVICE pTgtDev = RT_FROM_MEMBER(pInterface, BUSLOGICDEVICE, IMediaPort);
2948	PPDMDEVINS pDevIns = pTgtDev->pDevIns;
2949
2950	AssertPtrReturn(ppcszController, VERR_INVALID_POINTER);
2951	AssertPtrReturn(piInstance, VERR_INVALID_POINTER);
2952	AssertPtrReturn(piLUN, VERR_INVALID_POINTER);
2953
2954	*ppcszController = pDevIns->pReg->szName;
2955	*piInstance = pDevIns->iInstance;
2956	*piLUN = pTgtDev->iLUN;
2957
2958	return VINF_SUCCESS;
2959	}
2960
2961	/**
2962	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyFromBuf}
2963	*/
2964	static DECLCALLBACK(int) buslogicR3IoReqCopyFromBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
2965	void *pvIoReqAlloc, uint32_t offDst, PRTSGBUF pSgBuf,
2966	size_t cbCopy)
2967	{
2968	PBUSLOGICDEVICE pTgtDev = RT_FROM_MEMBER(pInterface, BUSLOGICDEVICE, IMediaExPort);
2969	PPDMDEVINS pDevIns = pTgtDev->pDevIns;
2970	PBUSLOGICREQ pReq = (PBUSLOGICREQ)pvIoReqAlloc;
2971	RT_NOREF(hIoReq);
2972
2973	size_t cbCopied = buslogicR3CopySgBufToGuest(pDevIns, PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC), pReq, pSgBuf, offDst, cbCopy);
2974	return cbCopied == cbCopy ? VINF_SUCCESS : VERR_PDM_MEDIAEX_IOBUF_OVERFLOW;
2975	}
2976
2977	/**
2978	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyToBuf}
2979	*/
2980	static DECLCALLBACK(int) buslogicR3IoReqCopyToBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
2981	void *pvIoReqAlloc, uint32_t offSrc, PRTSGBUF pSgBuf,
2982	size_t cbCopy)
2983	{
2984	RT_NOREF(hIoReq);
2985	PBUSLOGICDEVICE pTgtDev = RT_FROM_MEMBER(pInterface, BUSLOGICDEVICE, IMediaExPort);
2986	PPDMDEVINS pDevIns = pTgtDev->pDevIns;
2987	PBUSLOGICREQ pReq = (PBUSLOGICREQ)pvIoReqAlloc;
2988
2989	size_t cbCopied = buslogicR3CopySgBufFromGuest(pDevIns, PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC), pReq, pSgBuf, offSrc, cbCopy);
2990	return cbCopied == cbCopy ? VINF_SUCCESS : VERR_PDM_MEDIAEX_IOBUF_UNDERRUN;
2991	}
2992
2993	/**
2994	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCompleteNotify}
2995	*/
2996	static DECLCALLBACK(int) buslogicR3IoReqCompleteNotify(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
2997	void *pvIoReqAlloc, int rcReq)
2998	{
2999	RT_NOREF(hIoReq);
3000	PBUSLOGICDEVICE pTgtDev = RT_FROM_MEMBER(pInterface, BUSLOGICDEVICE, IMediaExPort);
3001	PPDMDEVINS pDevIns = pTgtDev->pDevIns;
3002	buslogicR3ReqComplete(pDevIns, PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC), PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC),
3003	(PBUSLOGICREQ)pvIoReqAlloc, rcReq);
3004	return VINF_SUCCESS;
3005	}
3006
3007	/**
3008	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqStateChanged}
3009	*/
3010	static DECLCALLBACK(void) buslogicR3IoReqStateChanged(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
3011	void *pvIoReqAlloc, PDMMEDIAEXIOREQSTATE enmState)
3012	{
3013	RT_NOREF(hIoReq, pvIoReqAlloc, enmState);
3014	PBUSLOGICDEVICE pTgtDev = RT_FROM_MEMBER(pInterface, BUSLOGICDEVICE, IMediaExPort);
3015
3016	switch (enmState)
3017	{
3018	case PDMMEDIAEXIOREQSTATE_SUSPENDED:
3019	{
3020	PPDMDEVINS pDevIns = pTgtDev->pDevIns;
3021	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3022
3023	/* Make sure the request is not accounted for so the VM can suspend successfully. */
3024	uint32_t cTasksActive = ASMAtomicDecU32(&pTgtDev->cOutstandingRequests);
3025	if (!cTasksActive && pThisCC->fSignalIdle)
3026	PDMDevHlpAsyncNotificationCompleted(pDevIns);
3027	break;
3028	}
3029	case PDMMEDIAEXIOREQSTATE_ACTIVE:
3030	/* Make sure the request is accounted for so the VM suspends only when the request is complete. */
3031	ASMAtomicIncU32(&pTgtDev->cOutstandingRequests);
3032	break;
3033	default:
3034	AssertMsgFailed(("Invalid request state given %u\n", enmState));
3035	}
3036	}
3037
3038	/**
3039	* @interface_method_impl{PDMIMEDIAEXPORT,pfnMediumEjected}
3040	*/
3041	static DECLCALLBACK(void) buslogicR3MediumEjected(PPDMIMEDIAEXPORT pInterface)
3042	{
3043	PBUSLOGICDEVICE pTgtDev = RT_FROM_MEMBER(pInterface, BUSLOGICDEVICE, IMediaExPort);
3044	PPDMDEVINS pDevIns = pTgtDev->pDevIns;
3045	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3046
3047	if (pThisCC->pMediaNotify)
3048	{
3049	int rc = VMR3ReqCallNoWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
3050	(PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
3051	pThisCC->pMediaNotify, pTgtDev->iLUN);
3052	AssertRC(rc);
3053	}
3054	}
3055
3056	static int buslogicR3DeviceSCSIRequestSetup(PPDMDEVINS pDevIns, PBUSLOGIC pThis, PBUSLOGICCC pThisCC, RTGCPHYS GCPhysAddrCCB)
3057	{
3058	int rc = VINF_SUCCESS;
3059	uint8_t uTargetIdCCB;
3060	CCBU CCBGuest;
3061
3062	/* Fetch the CCB from guest memory. */
3063	/** @todo How much do we really have to read? */
3064	blPhysReadMeta(pDevIns, pThis, GCPhysAddrCCB, &CCBGuest, sizeof(CCB32));
3065
3066	uTargetIdCCB = pThis->fMbxIs24Bit ? CCBGuest.o.uTargetId : CCBGuest.n.uTargetId;
3067	if (RT_LIKELY(uTargetIdCCB < RT_ELEMENTS(pThisCC->aDeviceStates)))
3068	{
3069	PBUSLOGICDEVICE pTgtDev = &pThisCC->aDeviceStates[uTargetIdCCB];
3070
3071	#ifdef LOG_ENABLED
3072	buslogicR3DumpCCBInfo(&CCBGuest, pThis->fMbxIs24Bit);
3073	#endif
3074
3075	/* Check if device is present on bus. If not return error immediately and don't process this further. */
3076	if (RT_LIKELY(pTgtDev->fPresent))
3077	{
3078	PDMMEDIAEXIOREQ hIoReq;
3079	PBUSLOGICREQ pReq;
3080	rc = pTgtDev->pDrvMediaEx->pfnIoReqAlloc(pTgtDev->pDrvMediaEx, &hIoReq, (void **)&pReq,
3081	GCPhysAddrCCB, PDMIMEDIAEX_F_SUSPEND_ON_RECOVERABLE_ERR);
3082	if (RT_SUCCESS(rc))
3083	{
3084	pReq->pTargetDevice = pTgtDev;
3085	pReq->GCPhysAddrCCB = GCPhysAddrCCB;
3086	pReq->fBIOS = false;
3087	pReq->hIoReq = hIoReq;
3088	pReq->fIs24Bit = pThis->fMbxIs24Bit;
3089
3090	/* Make a copy of the CCB */
3091	memcpy(&pReq->CCBGuest, &CCBGuest, sizeof(CCBGuest));
3092
3093	/* Alloc required buffers. */
3094	rc = buslogicR3SenseBufferAlloc(pReq);
3095	AssertMsgRC(rc, ("Mapping sense buffer failed rc=%Rrc\n", rc));
3096
3097	size_t cbBuf = 0;
3098	rc = buslogicR3QueryDataBufferSize(pDevIns, &pReq->CCBGuest, pReq->fIs24Bit, &cbBuf);
3099	AssertRC(rc);
3100
3101	uint32_t uLun = pReq->fIs24Bit ? pReq->CCBGuest.o.uLogicalUnit
3102	: pReq->CCBGuest.n.uLogicalUnit;
3103
3104	PDMMEDIAEXIOREQSCSITXDIR enmXferDir = PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN;
3105	size_t cbSense = buslogicR3ConvertSenseBufferLength(CCBGuest.c.cbSenseData);
3106
3107	if (CCBGuest.c.uDataDirection == BUSLOGIC_CCB_DIRECTION_NO_DATA)
3108	enmXferDir = PDMMEDIAEXIOREQSCSITXDIR_NONE;
3109	else if (CCBGuest.c.uDataDirection == BUSLOGIC_CCB_DIRECTION_OUT)
3110	enmXferDir = PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE;
3111	else if (CCBGuest.c.uDataDirection == BUSLOGIC_CCB_DIRECTION_IN)
3112	enmXferDir = PDMMEDIAEXIOREQSCSITXDIR_FROM_DEVICE;
3113
3114	ASMAtomicIncU32(&pTgtDev->cOutstandingRequests);
3115	rc = pTgtDev->pDrvMediaEx->pfnIoReqSendScsiCmd(pTgtDev->pDrvMediaEx, pReq->hIoReq, uLun,
3116	&pReq->CCBGuest.c.abCDB[0], pReq->CCBGuest.c.cbCDB,
3117	enmXferDir, NULL, cbBuf, pReq->pbSenseBuffer, cbSense, NULL,
3118	&pReq->u8ScsiSts, 30 * RT_MS_1SEC);
3119	if (rc != VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS)
3120	buslogicR3ReqComplete(pDevIns, pThis, pThisCC, pReq, rc);
3121	}
3122	else
3123	buslogicR3SendIncomingMailbox(pDevIns, pThis, GCPhysAddrCCB, &CCBGuest,
3124	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_SCSI_SELECTION_TIMEOUT,
3125	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD,
3126	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITH_ERROR);
3127	}
3128	else
3129	buslogicR3SendIncomingMailbox(pDevIns, pThis, GCPhysAddrCCB, &CCBGuest,
3130	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_SCSI_SELECTION_TIMEOUT,
3131	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD,
3132	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITH_ERROR);
3133	}
3134	else
3135	buslogicR3SendIncomingMailbox(pDevIns, pThis, GCPhysAddrCCB, &CCBGuest,
3136	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_COMMAND_PARAMETER,
3137	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD,
3138	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITH_ERROR);
3139
3140	return rc;
3141	}
3142
3143	static int buslogicR3DeviceSCSIRequestAbort(PPDMDEVINS pDevIns, PBUSLOGIC pThis, RTGCPHYS GCPhysAddrCCB)
3144	{
3145	uint8_t uTargetIdCCB;
3146	CCBU CCBGuest;
3147
3148	blPhysReadMeta(pDevIns, pThis, GCPhysAddrCCB, &CCBGuest, sizeof(CCB32));
3149
3150	uTargetIdCCB = pThis->fMbxIs24Bit ? CCBGuest.o.uTargetId : CCBGuest.n.uTargetId;
3151	if (RT_LIKELY(uTargetIdCCB < RT_ELEMENTS(pThis->afDevicePresent)))
3152	buslogicR3SendIncomingMailbox(pDevIns, pThis, GCPhysAddrCCB, &CCBGuest,
3153	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_ABORT_QUEUE_GENERATED,
3154	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD,
3155	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_ABORTED_NOT_FOUND);
3156	else
3157	buslogicR3SendIncomingMailbox(pDevIns, pThis, GCPhysAddrCCB, &CCBGuest,
3158	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_COMMAND_PARAMETER,
3159	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD,
3160	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITH_ERROR);
3161
3162	return VINF_SUCCESS;
3163	}
3164
3165	/**
3166	* Read a mailbox from guest memory. Convert 24-bit mailboxes to
3167	* 32-bit format.
3168	*
3169	* @returns Mailbox guest physical address.
3170	* @param pDevIns The device instance.
3171	* @param pThis Pointer to the shared BusLogic instance data.
3172	* @param pMbx Pointer to the mailbox to read into.
3173	*/
3174	static RTGCPHYS buslogicR3ReadOutgoingMailbox(PPDMDEVINS pDevIns, PBUSLOGIC pThis, PMailbox32 pMbx)
3175	{
3176	RTGCPHYS GCMailbox;
3177
3178	if (pThis->fMbxIs24Bit)
3179	{
3180	Mailbox24 Mbx24;
3181
3182	GCMailbox = pThis->GCPhysAddrMailboxOutgoingBase + (pThis->uMailboxOutgoingPositionCurrent * sizeof(Mailbox24));
3183	blPhysReadMeta(pDevIns, pThis, GCMailbox, &Mbx24, sizeof(Mailbox24));
3184	pMbx->u32PhysAddrCCB = ADDR_TO_U32(Mbx24.aPhysAddrCCB);
3185	pMbx->u.out.uActionCode = Mbx24.uCmdState;
3186	}
3187	else
3188	{
3189	GCMailbox = pThis->GCPhysAddrMailboxOutgoingBase + (pThis->uMailboxOutgoingPositionCurrent * sizeof(Mailbox32));
3190	blPhysReadMeta(pDevIns, pThis, GCMailbox, pMbx, sizeof(Mailbox32));
3191	}
3192
3193	return GCMailbox;
3194	}
3195
3196	/**
3197	* Read mailbox from the guest and execute command.
3198	*
3199	* @returns VBox status code.
3200	* @param pDevIns The device instance.
3201	* @param pThis Pointer to the shared BusLogic instance data.
3202	* @param pThisCC Pointer to the ring-3 BusLogic instance data.
3203	*/
3204	static int buslogicR3ProcessMailboxNext(PPDMDEVINS pDevIns, PBUSLOGIC pThis, PBUSLOGICCC pThisCC)
3205	{
3206	RTGCPHYS GCPhysAddrMailboxCurrent;
3207	Mailbox32 MailboxGuest;
3208	int rc = VINF_SUCCESS;
3209
3210	if (!pThis->fStrictRoundRobinMode)
3211	{
3212	/* Search for a filled mailbox - stop if we have scanned all mailboxes. */
3213	uint8_t uMailboxPosCur = pThis->uMailboxOutgoingPositionCurrent;
3214
3215	do
3216	{
3217	/* Fetch mailbox from guest memory. */
3218	GCPhysAddrMailboxCurrent = buslogicR3ReadOutgoingMailbox(pDevIns, pThis, &MailboxGuest);
3219
3220	/* Check the next mailbox. */
3221	buslogicR3OutgoingMailboxAdvance(pThis);
3222	} while ( MailboxGuest.u.out.uActionCode == BUSLOGIC_MAILBOX_OUTGOING_ACTION_FREE
3223	&& uMailboxPosCur != pThis->uMailboxOutgoingPositionCurrent);
3224	}
3225	else
3226	{
3227	/* Fetch mailbox from guest memory. */
3228	GCPhysAddrMailboxCurrent = buslogicR3ReadOutgoingMailbox(pDevIns, pThis, &MailboxGuest);
3229	}
3230
3231	/*
3232	* Check if the mailbox is actually loaded.
3233	* It might be possible that the guest notified us without
3234	* a loaded mailbox. Do nothing in that case but leave a
3235	* log entry.
3236	*/
3237	if (MailboxGuest.u.out.uActionCode == BUSLOGIC_MAILBOX_OUTGOING_ACTION_FREE)
3238	{
3239	Log(("No loaded mailbox left\n"));
3240	return VERR_NO_DATA;
3241	}
3242
3243	LogFlow(("Got loaded mailbox at slot %u, CCB phys %RGp\n", pThis->uMailboxOutgoingPositionCurrent, (RTGCPHYS)MailboxGuest.u32PhysAddrCCB));
3244	#ifdef LOG_ENABLED
3245	buslogicR3DumpMailboxInfo(&MailboxGuest, true);
3246	#endif
3247
3248	/* We got the mailbox, mark it as free in the guest. */
3249	uint8_t uActionCode = BUSLOGIC_MAILBOX_OUTGOING_ACTION_FREE;
3250	unsigned uCodeOffs = pThis->fMbxIs24Bit ? RT_OFFSETOF(Mailbox24, uCmdState) : RT_OFFSETOF(Mailbox32, u.out.uActionCode);
3251	blPhysWriteMeta(pDevIns, pThis, GCPhysAddrMailboxCurrent + uCodeOffs, &uActionCode, sizeof(uActionCode));
3252
3253	if (MailboxGuest.u.out.uActionCode == BUSLOGIC_MAILBOX_OUTGOING_ACTION_START_COMMAND)
3254	rc = buslogicR3DeviceSCSIRequestSetup(pDevIns, pThis, pThisCC, (RTGCPHYS)MailboxGuest.u32PhysAddrCCB);
3255	else if (MailboxGuest.u.out.uActionCode == BUSLOGIC_MAILBOX_OUTGOING_ACTION_ABORT_COMMAND)
3256	{
3257	LogFlow(("Aborting mailbox\n"));
3258	rc = buslogicR3DeviceSCSIRequestAbort(pDevIns, pThis, (RTGCPHYS)MailboxGuest.u32PhysAddrCCB);
3259	}
3260	else
3261	AssertMsgFailed(("Invalid outgoing mailbox action code %u\n", MailboxGuest.u.out.uActionCode));
3262
3263	AssertRC(rc);
3264
3265	/* Advance to the next mailbox. */
3266	if (pThis->fStrictRoundRobinMode)
3267	buslogicR3OutgoingMailboxAdvance(pThis);
3268
3269	return rc;
3270	}
3271
3272	/** @callback_method_impl{FNSSMDEVLIVEEXEC} */
3273	static DECLCALLBACK(int) buslogicR3LiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
3274	{
3275	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3276	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
3277	RT_NOREF(uPass);
3278
3279	/* Save the device config. */
3280	for (unsigned i = 0; i < RT_ELEMENTS(pThisCC->aDeviceStates); i++)
3281	pHlp->pfnSSMPutBool(pSSM, pThisCC->aDeviceStates[i].fPresent);
3282
3283	return VINF_SSM_DONT_CALL_AGAIN;
3284	}
3285
3286	/** @callback_method_impl{FNSSMDEVSAVEEXEC} */
3287	static DECLCALLBACK(int) buslogicR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
3288	{
3289	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3290	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3291	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
3292	uint32_t cReqsSuspended = 0;
3293
3294	/* Every device first. */
3295	for (unsigned i = 0; i < RT_ELEMENTS(pThisCC->aDeviceStates); i++)
3296	{
3297	PBUSLOGICDEVICE pDevice = &pThisCC->aDeviceStates[i];
3298
3299	AssertMsg(!pDevice->cOutstandingRequests,
3300	("There are still outstanding requests on this device\n"));
3301	pHlp->pfnSSMPutBool(pSSM, pDevice->fPresent);
3302	pHlp->pfnSSMPutU32(pSSM, pDevice->cOutstandingRequests);
3303
3304	if (pDevice->fPresent)
3305	cReqsSuspended += pDevice->pDrvMediaEx->pfnIoReqGetSuspendedCount(pDevice->pDrvMediaEx);
3306	}
3307	/* Now the main device state. */
3308	pHlp->pfnSSMPutU8 (pSSM, pThis->regStatus);
3309	pHlp->pfnSSMPutU8 (pSSM, pThis->regInterrupt);
3310	pHlp->pfnSSMPutU8 (pSSM, pThis->regGeometry);
3311	pHlp->pfnSSMPutMem (pSSM, &pThis->LocalRam, sizeof(pThis->LocalRam));
3312	pHlp->pfnSSMPutU8 (pSSM, pThis->uOperationCode);
3313	pHlp->pfnSSMPutMem (pSSM, &pThis->aCommandBuffer, sizeof(pThis->aCommandBuffer));
3314	pHlp->pfnSSMPutU8 (pSSM, pThis->iParameter);
3315	pHlp->pfnSSMPutU8 (pSSM, pThis->cbCommandParametersLeft);
3316	pHlp->pfnSSMPutBool (pSSM, pThis->fUseLocalRam);
3317	pHlp->pfnSSMPutMem (pSSM, pThis->aReplyBuffer, sizeof(pThis->aReplyBuffer));
3318	pHlp->pfnSSMPutU8 (pSSM, pThis->iReply);
3319	pHlp->pfnSSMPutU8 (pSSM, pThis->cbReplyParametersLeft);
3320	pHlp->pfnSSMPutBool (pSSM, pThis->fIRQEnabled);
3321	pHlp->pfnSSMPutU8 (pSSM, pThis->uISABaseCode);
3322	pHlp->pfnSSMPutU32 (pSSM, pThis->cMailbox);
3323	pHlp->pfnSSMPutBool (pSSM, pThis->fMbxIs24Bit);
3324	pHlp->pfnSSMPutGCPhys(pSSM, pThis->GCPhysAddrMailboxOutgoingBase);
3325	pHlp->pfnSSMPutU32 (pSSM, pThis->uMailboxOutgoingPositionCurrent);
3326	pHlp->pfnSSMPutU32 (pSSM, pThis->cMailboxesReady);
3327	pHlp->pfnSSMPutBool (pSSM, pThis->fNotificationSent);
3328	pHlp->pfnSSMPutGCPhys(pSSM, pThis->GCPhysAddrMailboxIncomingBase);
3329	pHlp->pfnSSMPutU32 (pSSM, pThis->uMailboxIncomingPositionCurrent);
3330	pHlp->pfnSSMPutBool (pSSM, pThis->fStrictRoundRobinMode);
3331	pHlp->pfnSSMPutBool (pSSM, pThis->fExtendedLunCCBFormat);
3332
3333	pHlp->pfnSSMPutU32(pSSM, cReqsSuspended);
3334
3335	/* Save the physical CCB address of all suspended requests. */
3336	for (unsigned i = 0; i < RT_ELEMENTS(pThisCC->aDeviceStates) && cReqsSuspended; i++)
3337	{
3338	PBUSLOGICDEVICE pDevice = &pThisCC->aDeviceStates[i];
3339	if (pDevice->fPresent)
3340	{
3341	uint32_t cThisReqsSuspended = pDevice->pDrvMediaEx->pfnIoReqGetSuspendedCount(pDevice->pDrvMediaEx);
3342
3343	cReqsSuspended -= cThisReqsSuspended;
3344	if (cThisReqsSuspended)
3345	{
3346	PDMMEDIAEXIOREQ hIoReq;
3347	PBUSLOGICREQ pReq;
3348	int rc = pDevice->pDrvMediaEx->pfnIoReqQuerySuspendedStart(pDevice->pDrvMediaEx, &hIoReq,
3349	(void **)&pReq);
3350	AssertRCBreak(rc);
3351
3352	for (;;)
3353	{
3354	pHlp->pfnSSMPutU32(pSSM, (uint32_t)pReq->GCPhysAddrCCB);
3355
3356	cThisReqsSuspended--;
3357	if (!cThisReqsSuspended)
3358	break;
3359
3360	rc = pDevice->pDrvMediaEx->pfnIoReqQuerySuspendedNext(pDevice->pDrvMediaEx, hIoReq,
3361	&hIoReq, (void **)&pReq);
3362	AssertRCBreak(rc);
3363	}
3364	}
3365	}
3366	}
3367
3368	return pHlp->pfnSSMPutU32(pSSM, UINT32_MAX);
3369	}
3370
3371	/** @callback_method_impl{FNSSMDEVLOADDONE} */
3372	static DECLCALLBACK(int) buslogicR3LoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
3373	{
3374	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3375	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3376	RT_NOREF(pSSM);
3377
3378	buslogicR3RegisterISARange(pDevIns, pThis, pThis->uISABaseCode);
3379
3380	/* Kick of any requests we might need to redo. */
3381	if (pThisCC->cReqsRedo)
3382	{
3383	for (unsigned i = 0; i < pThisCC->cReqsRedo; i++)
3384	{
3385	int rc = buslogicR3DeviceSCSIRequestSetup(pDevIns, pThis, pThisCC, pThisCC->paGCPhysAddrCCBRedo[i]);
3386	AssertRC(rc);
3387	}
3388
3389	RTMemFree(pThisCC->paGCPhysAddrCCBRedo);
3390	pThisCC->paGCPhysAddrCCBRedo = NULL;
3391	pThisCC->cReqsRedo = 0;
3392	}
3393
3394	return VINF_SUCCESS;
3395	}
3396
3397	/** @callback_method_impl{FNSSMDEVLOADEXEC} */
3398	static DECLCALLBACK(int) buslogicR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
3399	{
3400	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3401	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3402	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
3403	int rc = VINF_SUCCESS;
3404
3405	/* We support saved states only from this and older versions. */
3406	if (uVersion > BUSLOGIC_SAVED_STATE_MINOR_VERSION)
3407	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
3408
3409	/* Every device first. */
3410	for (unsigned i = 0; i < RT_ELEMENTS(pThisCC->aDeviceStates); i++)
3411	{
3412	PBUSLOGICDEVICE pDevice = &pThisCC->aDeviceStates[i];
3413
3414	AssertMsg(!pDevice->cOutstandingRequests,
3415	("There are still outstanding requests on this device\n"));
3416	bool fPresent;
3417	rc = pHlp->pfnSSMGetBool(pSSM, &fPresent);
3418	AssertRCReturn(rc, rc);
3419	if (pDevice->fPresent != fPresent)
3420	return pHlp->pfnSSMSetCfgError(pSSM, RT_SRC_POS, N_("Target %u config mismatch: config=%RTbool state=%RTbool"), i, pDevice->fPresent, fPresent);
3421
3422	if (uPass == SSM_PASS_FINAL)
3423	pHlp->pfnSSMGetU32V(pSSM, &pDevice->cOutstandingRequests);
3424	}
3425
3426	if (uPass != SSM_PASS_FINAL)
3427	return VINF_SUCCESS;
3428
3429	/* Now the main device state. */
3430	pHlp->pfnSSMGetU8V (pSSM, &pThis->regStatus);
3431	pHlp->pfnSSMGetU8V (pSSM, &pThis->regInterrupt);
3432	pHlp->pfnSSMGetU8V (pSSM, &pThis->regGeometry);
3433	pHlp->pfnSSMGetMem (pSSM, &pThis->LocalRam, sizeof(pThis->LocalRam));
3434	pHlp->pfnSSMGetU8 (pSSM, &pThis->uOperationCode);
3435	if (uVersion > BUSLOGIC_SAVED_STATE_MINOR_PRE_CMDBUF_RESIZE)
3436	pHlp->pfnSSMGetMem(pSSM, &pThis->aCommandBuffer, sizeof(pThis->aCommandBuffer));
3437	else
3438	pHlp->pfnSSMGetMem(pSSM, &pThis->aCommandBuffer, BUSLOGIC_COMMAND_SIZE_OLD);
3439	pHlp->pfnSSMGetU8 (pSSM, &pThis->iParameter);
3440	pHlp->pfnSSMGetU8 (pSSM, &pThis->cbCommandParametersLeft);
3441	pHlp->pfnSSMGetBool (pSSM, &pThis->fUseLocalRam);
3442	pHlp->pfnSSMGetMem (pSSM, pThis->aReplyBuffer, sizeof(pThis->aReplyBuffer));
3443	pHlp->pfnSSMGetU8 (pSSM, &pThis->iReply);
3444	pHlp->pfnSSMGetU8 (pSSM, &pThis->cbReplyParametersLeft);
3445	pHlp->pfnSSMGetBool (pSSM, &pThis->fIRQEnabled);
3446	pHlp->pfnSSMGetU8 (pSSM, &pThis->uISABaseCode);
3447	pHlp->pfnSSMGetU32 (pSSM, &pThis->cMailbox);
3448	if (uVersion > BUSLOGIC_SAVED_STATE_MINOR_PRE_24BIT_MBOX)
3449	pHlp->pfnSSMGetBool(pSSM, &pThis->fMbxIs24Bit);
3450	pHlp->pfnSSMGetGCPhys(pSSM, &pThis->GCPhysAddrMailboxOutgoingBase);
3451	pHlp->pfnSSMGetU32 (pSSM, &pThis->uMailboxOutgoingPositionCurrent);
3452	pHlp->pfnSSMGetU32V (pSSM, &pThis->cMailboxesReady);
3453	pHlp->pfnSSMGetBoolV (pSSM, &pThis->fNotificationSent);
3454	pHlp->pfnSSMGetGCPhys(pSSM, &pThis->GCPhysAddrMailboxIncomingBase);
3455	pHlp->pfnSSMGetU32 (pSSM, &pThis->uMailboxIncomingPositionCurrent);
3456	pHlp->pfnSSMGetBool (pSSM, &pThis->fStrictRoundRobinMode);
3457	pHlp->pfnSSMGetBool (pSSM, &pThis->fExtendedLunCCBFormat);
3458
3459	if (uVersion <= BUSLOGIC_SAVED_STATE_MINOR_PRE_VBOXSCSI_REMOVAL)
3460	{
3461	rc = vboxscsiR3LoadExecLegacy(pDevIns->pHlpR3, pSSM);
3462	if (RT_FAILURE(rc))
3463	{
3464	LogRel(("BusLogic: Failed to restore BIOS state: %Rrc.\n", rc));
3465	return PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic: Failed to restore BIOS state\n"));
3466	}
3467	}
3468
3469	if (uVersion > BUSLOGIC_SAVED_STATE_MINOR_PRE_ERROR_HANDLING)
3470	{
3471	/* Check if there are pending tasks saved. */
3472	uint32_t cTasks = 0;
3473
3474	pHlp->pfnSSMGetU32(pSSM, &cTasks);
3475
3476	if (cTasks)
3477	{
3478	pThisCC->paGCPhysAddrCCBRedo = (PRTGCPHYS)RTMemAllocZ(cTasks * sizeof(RTGCPHYS));
3479	if (RT_LIKELY(pThisCC->paGCPhysAddrCCBRedo))
3480	{
3481	pThisCC->cReqsRedo = cTasks;
3482
3483	for (uint32_t i = 0; i < cTasks; i++)
3484	{
3485	uint32_t u32PhysAddrCCB;
3486
3487	rc = pHlp->pfnSSMGetU32(pSSM, &u32PhysAddrCCB);
3488	AssertRCBreak(rc);
3489
3490	pThisCC->paGCPhysAddrCCBRedo[i] = u32PhysAddrCCB;
3491	}
3492	}
3493	else
3494	rc = VERR_NO_MEMORY;
3495	}
3496	}
3497
3498	if (RT_SUCCESS(rc))
3499	{
3500	uint32_t u32;
3501	rc = pHlp->pfnSSMGetU32(pSSM, &u32);
3502	if (RT_SUCCESS(rc))
3503	AssertMsgReturn(u32 == UINT32_MAX, ("%#x\n", u32), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
3504	}
3505
3506	return rc;
3507	}
3508
3509	/**
3510	* Gets the pointer to the status LED of a device - called from the SCSI driver.
3511	*
3512	* @returns VBox status code.
3513	* @param pInterface Pointer to the interface structure containing the called function pointer.
3514	* @param iLUN The unit which status LED we desire. Always 0 here as the driver
3515	* doesn't know about other LUN's.
3516	* @param ppLed Where to store the LED pointer.
3517	*/
3518	static DECLCALLBACK(int) buslogicR3DeviceQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
3519	{
3520	PBUSLOGICDEVICE pDevice = RT_FROM_MEMBER(pInterface, BUSLOGICDEVICE, ILed);
3521	if (iLUN == 0)
3522	{
3523	*ppLed = &pDevice->Led;
3524	Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
3525	return VINF_SUCCESS;
3526	}
3527	return VERR_PDM_LUN_NOT_FOUND;
3528	}
3529
3530	/**
3531	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
3532	*/
3533	static DECLCALLBACK(void ) buslogicR3DeviceQueryInterface(PPDMIBASE pInterface, const char pszIID)
3534	{
3535	PBUSLOGICDEVICE pDevice = RT_FROM_MEMBER(pInterface, BUSLOGICDEVICE, IBase);
3536	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDevice->IBase);
3537	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAPORT, &pDevice->IMediaPort);
3538	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAEXPORT, &pDevice->IMediaExPort);
3539	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pDevice->ILed);
3540	return NULL;
3541	}
3542
3543	/**
3544	* Gets the pointer to the status LED of a unit.
3545	*
3546	* @returns VBox status code.
3547	* @param pInterface Pointer to the interface structure containing the called function pointer.
3548	* @param iLUN The unit which status LED we desire.
3549	* @param ppLed Where to store the LED pointer.
3550	*/
3551	static DECLCALLBACK(int) buslogicR3StatusQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
3552	{
3553	PBUSLOGICCC pThisCC = RT_FROM_MEMBER(pInterface, BUSLOGICCC, ILeds);
3554	if (iLUN < BUSLOGIC_MAX_DEVICES)
3555	{
3556	*ppLed = &pThisCC->aDeviceStates[iLUN].Led;
3557	Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
3558	return VINF_SUCCESS;
3559	}
3560	return VERR_PDM_LUN_NOT_FOUND;
3561	}
3562
3563	/**
3564	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
3565	*/
3566	static DECLCALLBACK(void ) buslogicR3StatusQueryInterface(PPDMIBASE pInterface, const char pszIID)
3567	{
3568	PBUSLOGICCC pThisCC = RT_FROM_MEMBER(pInterface, BUSLOGICCC, IBase);
3569	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
3570	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
3571	return NULL;
3572	}
3573
3574	/**
3575	* @callback_method_impl{FNPDMTHREADWAKEUPDEV}
3576	*/
3577	static DECLCALLBACK(int) buslogicR3Worker(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
3578	{
3579	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3580	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3581
3582	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
3583	return VINF_SUCCESS;
3584
3585	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
3586	{
3587	int rc;
3588
3589	ASMAtomicWriteBool(&pThisCC->fWrkThreadSleeping, true);
3590	bool fNotificationSent = ASMAtomicXchgBool(&pThis->fNotificationSent, false);
3591	if (!fNotificationSent)
3592	{
3593	Assert(ASMAtomicReadBool(&pThisCC->fWrkThreadSleeping));
3594	rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pThis->hEvtProcess, RT_INDEFINITE_WAIT);
3595	AssertLogRelMsgReturn(RT_SUCCESS(rc) \|\| rc == VERR_INTERRUPTED, ("%Rrc\n", rc), rc);
3596	if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
3597	break;
3598	LogFlowFunc(("Woken up with rc=%Rrc\n", rc));
3599	ASMAtomicWriteBool(&pThis->fNotificationSent, false);
3600	}
3601
3602	ASMAtomicWriteBool(&pThisCC->fWrkThreadSleeping, false);
3603
3604
3605	ASMAtomicXchgU32(&pThis->cMailboxesReady, 0); /** @todo Actually not required anymore but to stay compatible with older saved states. */
3606
3607	/* Process mailboxes. */
3608	do
3609	{
3610	rc = buslogicR3ProcessMailboxNext(pDevIns, pThis, pThisCC);
3611	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_NO_DATA, ("Processing mailbox failed rc=%Rrc\n", rc));
3612	} while (RT_SUCCESS(rc));
3613	} /* While running */
3614
3615	return VINF_SUCCESS;
3616	}
3617
3618
3619	/**
3620	* @callback_method_impl{FNPDMTHREADWAKEUPDEV}
3621	*/
3622	static DECLCALLBACK(int) buslogicR3WorkerWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
3623	{
3624	RT_NOREF(pThread);
3625	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3626	return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hEvtProcess);
3627	}
3628
3629	/**
3630	* BusLogic debugger info callback.
3631	*
3632	* @param pDevIns The device instance.
3633	* @param pHlp The output helpers.
3634	* @param pszArgs The arguments.
3635	*/
3636	static DECLCALLBACK(void) buslogicR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
3637	{
3638	static const char *apszModels[] = { "BusLogic BT-958D", "BusLogic BT-545C", "Adaptec AHA-1540B" };
3639	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3640	unsigned i;
3641	bool fVerbose = false;
3642
3643	/* Parse arguments. */
3644	if (pszArgs)
3645	fVerbose = strstr(pszArgs, "verbose") != NULL;
3646
3647	/* Show basic information. */
3648	pHlp->pfnPrintf(pHlp, "%s#%d: %s ",
3649	pDevIns->pReg->szName,
3650	pDevIns->iInstance,
3651	pThis->uDevType >= RT_ELEMENTS(apszModels) ? "Unknown model" : apszModels[pThis->uDevType]);
3652	if (pThis->uIsaIrq)
3653	pHlp->pfnPrintf(pHlp, "ISA I/O=%RTiop IRQ=%u ",
3654	pThis->IOISABase,
3655	pThis->uIsaIrq);
3656	else
3657	pHlp->pfnPrintf(pHlp, "PCI I/O=%04x ISA I/O=%RTiop MMIO=%RGp IRQ=%u ",
3658	PDMDevHlpIoPortGetMappingAddress(pDevIns, pThis->hIoPortsPci), pThis->IOISABase,
3659	PDMDevHlpMmioGetMappingAddress(pDevIns, pThis->hMmio),
3660	PCIDevGetInterruptLine(pDevIns->apPciDevs[0]));
3661	pHlp->pfnPrintf(pHlp, "RC=%RTbool R0=%RTbool\n", pDevIns->fRCEnabled, pDevIns->fR0Enabled);
3662
3663	/* Print mailbox state. */
3664	if (pThis->regStatus & BL_STAT_INREQ)
3665	pHlp->pfnPrintf(pHlp, "Mailbox not initialized\n");
3666	else
3667	pHlp->pfnPrintf(pHlp, "%u-bit mailbox with %u entries at %RGp (%d LUN CCBs)\n",
3668	pThis->fMbxIs24Bit ? 24 : 32, pThis->cMailbox,
3669	pThis->GCPhysAddrMailboxOutgoingBase,
3670	pThis->fMbxIs24Bit ? 8 : pThis->fExtendedLunCCBFormat ? 64 : 8);
3671
3672	/* Print register contents. */
3673	pHlp->pfnPrintf(pHlp, "Registers: STAT=%02x INTR=%02x GEOM=%02x\n",
3674	pThis->regStatus, pThis->regInterrupt, pThis->regGeometry);
3675
3676	/* Print miscellaneous state. */
3677	pHlp->pfnPrintf(pHlp, "HAC interrupts: %s\n",
3678	pThis->fIRQEnabled ? "on" : "off");
3679
3680	/* Print the current command, if any. */
3681	if (pThis->uOperationCode != 0xff )
3682	pHlp->pfnPrintf(pHlp, "Current command: %02X\n", pThis->uOperationCode);
3683
3684	/* Print the previous command, if any. */
3685	if (pThis->uPrevCmd != 0xff )
3686	pHlp->pfnPrintf(pHlp, "Last completed command: %02X\n", pThis->uPrevCmd);
3687
3688	if (fVerbose && (pThis->regStatus & BL_STAT_INREQ) == 0)
3689	{
3690	RTGCPHYS GCMailbox;
3691
3692	/* Dump the mailbox contents. */
3693	if (pThis->fMbxIs24Bit)
3694	{
3695	Mailbox24 Mbx24;
3696
3697	/* Outgoing mailbox, 24-bit format. */
3698	GCMailbox = pThis->GCPhysAddrMailboxOutgoingBase;
3699	pHlp->pfnPrintf(pHlp, " Outgoing mailbox entries (24-bit) at %06X:\n", GCMailbox);
3700	for (i = 0; i < pThis->cMailbox; ++i)
3701	{
3702	blPhysReadMeta(pDevIns, pThis, GCMailbox, &Mbx24, sizeof(Mailbox24));
3703	pHlp->pfnPrintf(pHlp, " slot %03d: CCB at %06X action code %02X", i, ADDR_TO_U32(Mbx24.aPhysAddrCCB), Mbx24.uCmdState);
3704	pHlp->pfnPrintf(pHlp, "%s\n", pThis->uMailboxOutgoingPositionCurrent == i ? " *" : "");
3705	GCMailbox += sizeof(Mailbox24);
3706	}
3707
3708	/* Incoming mailbox, 24-bit format. */
3709	GCMailbox = pThis->GCPhysAddrMailboxOutgoingBase + (pThis->cMailbox * sizeof(Mailbox24));
3710	pHlp->pfnPrintf(pHlp, " Incoming mailbox entries (24-bit) at %06X:\n", GCMailbox);
3711	for (i = 0; i < pThis->cMailbox; ++i)
3712	{
3713	blPhysReadMeta(pDevIns, pThis, GCMailbox, &Mbx24, sizeof(Mailbox24));
3714	pHlp->pfnPrintf(pHlp, " slot %03d: CCB at %06X completion code %02X", i, ADDR_TO_U32(Mbx24.aPhysAddrCCB), Mbx24.uCmdState);
3715	pHlp->pfnPrintf(pHlp, "%s\n", pThis->uMailboxIncomingPositionCurrent == i ? " *" : "");
3716	GCMailbox += sizeof(Mailbox24);
3717	}
3718
3719	}
3720	else
3721	{
3722	Mailbox32 Mbx32;
3723
3724	/* Outgoing mailbox, 32-bit format. */
3725	GCMailbox = pThis->GCPhysAddrMailboxOutgoingBase;
3726	pHlp->pfnPrintf(pHlp, " Outgoing mailbox entries (32-bit) at %08X:\n", (uint32_t)GCMailbox);
3727	for (i = 0; i < pThis->cMailbox; ++i)
3728	{
3729	blPhysReadMeta(pDevIns, pThis, GCMailbox, &Mbx32, sizeof(Mailbox32));
3730	pHlp->pfnPrintf(pHlp, " slot %03d: CCB at %08X action code %02X", i, Mbx32.u32PhysAddrCCB, Mbx32.u.out.uActionCode);
3731	pHlp->pfnPrintf(pHlp, "%s\n", pThis->uMailboxOutgoingPositionCurrent == i ? " *" : "");
3732	GCMailbox += sizeof(Mailbox32);
3733	}
3734
3735	/* Incoming mailbox, 32-bit format. */
3736	GCMailbox = pThis->GCPhysAddrMailboxOutgoingBase + (pThis->cMailbox * sizeof(Mailbox32));
3737	pHlp->pfnPrintf(pHlp, " Incoming mailbox entries (32-bit) at %08X:\n", (uint32_t)GCMailbox);
3738	for (i = 0; i < pThis->cMailbox; ++i)
3739	{
3740	blPhysReadMeta(pDevIns, pThis, GCMailbox, &Mbx32, sizeof(Mailbox32));
3741	pHlp->pfnPrintf(pHlp, " slot %03d: CCB at %08X completion code %02X BTSTAT %02X SDSTAT %02X", i,
3742	Mbx32.u32PhysAddrCCB, Mbx32.u.in.uCompletionCode, Mbx32.u.in.uHostAdapterStatus, Mbx32.u.in.uTargetDeviceStatus);
3743	pHlp->pfnPrintf(pHlp, "%s\n", pThis->uMailboxIncomingPositionCurrent == i ? " *" : "");
3744	GCMailbox += sizeof(Mailbox32);
3745	}
3746
3747	}
3748	}
3749	}
3750
3751	/* -=-=-=-=- Helper -=-=-=-=- */
3752
3753	/**
3754	* Checks if all asynchronous I/O is finished.
3755	*
3756	* Used by buslogicR3Reset, buslogicR3Suspend and buslogicR3PowerOff.
3757	*
3758	* @returns true if quiesced, false if busy.
3759	* @param pDevIns The device instance.
3760	*/
3761	static bool buslogicR3AllAsyncIOIsFinished(PPDMDEVINS pDevIns)
3762	{
3763	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3764
3765	for (uint32_t i = 0; i < RT_ELEMENTS(pThisCC->aDeviceStates); i++)
3766	{
3767	PBUSLOGICDEVICE pThisDevice = &pThisCC->aDeviceStates[i];
3768	if (pThisDevice->pDrvBase)
3769	{
3770	if (pThisDevice->cOutstandingRequests != 0)
3771	return false;
3772	}
3773	}
3774
3775	return true;
3776	}
3777
3778	/**
3779	* Callback employed by buslogicR3Suspend and buslogicR3PowerOff.
3780	*
3781	* @returns true if we've quiesced, false if we're still working.
3782	* @param pDevIns The device instance.
3783	*/
3784	static DECLCALLBACK(bool) buslogicR3IsAsyncSuspendOrPowerOffDone(PPDMDEVINS pDevIns)
3785	{
3786	if (!buslogicR3AllAsyncIOIsFinished(pDevIns))
3787	return false;
3788
3789	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3790	ASMAtomicWriteBool(&pThisCC->fSignalIdle, false);
3791	return true;
3792	}
3793
3794	/**
3795	* Common worker for buslogicR3Suspend and buslogicR3PowerOff.
3796	*/
3797	static void buslogicR3SuspendOrPowerOff(PPDMDEVINS pDevIns)
3798	{
3799	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3800	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3801
3802	ASMAtomicWriteBool(&pThisCC->fSignalIdle, true);
3803	if (!buslogicR3AllAsyncIOIsFinished(pDevIns))
3804	PDMDevHlpSetAsyncNotification(pDevIns, buslogicR3IsAsyncSuspendOrPowerOffDone);
3805	else
3806	{
3807	ASMAtomicWriteBool(&pThisCC->fSignalIdle, false);
3808	AssertMsg(!pThis->fNotificationSent, ("The PDM Queue should be empty at this point\n"));
3809	RT_NOREF(pThis);
3810	}
3811
3812	for (uint32_t i = 0; i < RT_ELEMENTS(pThisCC->aDeviceStates); i++)
3813	{
3814	PBUSLOGICDEVICE pThisDevice = &pThisCC->aDeviceStates[i];
3815	if (pThisDevice->pDrvMediaEx)
3816	pThisDevice->pDrvMediaEx->pfnNotifySuspend(pThisDevice->pDrvMediaEx);
3817	}
3818	}
3819
3820	/**
3821	* Suspend notification.
3822	*
3823	* @param pDevIns The device instance data.
3824	*/
3825	static DECLCALLBACK(void) buslogicR3Suspend(PPDMDEVINS pDevIns)
3826	{
3827	Log(("buslogicR3Suspend\n"));
3828	buslogicR3SuspendOrPowerOff(pDevIns);
3829	}
3830
3831	/**
3832	* Detach notification.
3833	*
3834	* One harddisk at one port has been unplugged.
3835	* The VM is suspended at this point.
3836	*
3837	* @param pDevIns The device instance.
3838	* @param iLUN The logical unit which is being detached.
3839	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
3840	*/
3841	static DECLCALLBACK(void) buslogicR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
3842	{
3843	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3844	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3845	PBUSLOGICDEVICE pDevice = &pThisCC->aDeviceStates[iLUN];
3846	Log(("%s:\n", __FUNCTION__));
3847	RT_NOREF(fFlags);
3848
3849
3850	AssertMsg(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
3851	("BusLogic: Device does not support hotplugging\n"));
3852
3853	/*
3854	* Zero some important members.
3855	*/
3856	pThis->afDevicePresent[iLUN] = false;
3857	pDevice->fPresent = false;
3858	pDevice->pDrvBase = NULL;
3859	pDevice->pDrvMedia = NULL;
3860	pDevice->pDrvMediaEx = NULL;
3861	}
3862
3863	/**
3864	* Attach command.
3865	*
3866	* This is called when we change block driver.
3867	*
3868	* @returns VBox status code.
3869	* @param pDevIns The device instance.
3870	* @param iLUN The logical unit which is being detached.
3871	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
3872	*/
3873	static DECLCALLBACK(int) buslogicR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
3874	{
3875	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3876	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3877	PBUSLOGICDEVICE pDevice = &pThisCC->aDeviceStates[iLUN];
3878	int rc;
3879
3880	AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
3881	("BusLogic: Device does not support hotplugging\n"),
3882	VERR_INVALID_PARAMETER);
3883
3884	/* the usual paranoia */
3885	AssertRelease(!pDevice->pDrvBase);
3886	AssertRelease(!pDevice->pDrvMedia);
3887	AssertRelease(!pDevice->pDrvMediaEx);
3888	Assert(pDevice->iLUN == iLUN);
3889
3890	/*
3891	* Try attach the SCSI driver and get the interfaces,
3892	* required as well as optional.
3893	*/
3894	rc = PDMDevHlpDriverAttach(pDevIns, pDevice->iLUN, &pDevice->IBase, &pDevice->pDrvBase, NULL);
3895	if (RT_SUCCESS(rc))
3896	{
3897	/* Query the media interface. */
3898	pDevice->pDrvMedia = PDMIBASE_QUERY_INTERFACE(pDevice->pDrvBase, PDMIMEDIA);
3899	AssertMsgReturn(VALID_PTR(pDevice->pDrvMedia),
3900	("BusLogic configuration error: LUN#%d misses the basic media interface!\n", pDevice->iLUN),
3901	VERR_PDM_MISSING_INTERFACE);
3902
3903	/* Get the extended media interface. */
3904	pDevice->pDrvMediaEx = PDMIBASE_QUERY_INTERFACE(pDevice->pDrvBase, PDMIMEDIAEX);
3905	AssertMsgReturn(VALID_PTR(pDevice->pDrvMediaEx),
3906	("BusLogic configuration error: LUN#%d misses the extended media interface!\n", pDevice->iLUN),
3907	VERR_PDM_MISSING_INTERFACE);
3908
3909	rc = pDevice->pDrvMediaEx->pfnIoReqAllocSizeSet(pDevice->pDrvMediaEx, sizeof(BUSLOGICREQ));
3910	AssertMsgRCReturn(rc, ("BusLogic configuration error: LUN#%u: Failed to set I/O request size!", pDevice->iLUN),
3911	rc);
3912
3913	pThis->afDevicePresent[iLUN] = true;
3914	pDevice->fPresent = true;
3915	}
3916	else
3917	AssertMsgFailed(("Failed to attach LUN#%d. rc=%Rrc\n", pDevice->iLUN, rc));
3918
3919	if (RT_FAILURE(rc))
3920	{
3921	pThis->afDevicePresent[iLUN] = false;
3922	pDevice->fPresent = false;
3923	pDevice->pDrvBase = NULL;
3924	pDevice->pDrvMedia = NULL;
3925	pDevice->pDrvMediaEx = NULL;
3926	}
3927	return rc;
3928	}
3929
3930	/**
3931	* Callback employed by buslogicR3Reset.
3932	*
3933	* @returns true if we've quiesced, false if we're still working.
3934	* @param pDevIns The device instance.
3935	*/
3936	static DECLCALLBACK(bool) buslogicR3IsAsyncResetDone(PPDMDEVINS pDevIns)
3937	{
3938	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3939	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3940
3941	if (!buslogicR3AllAsyncIOIsFinished(pDevIns))
3942	return false;
3943	ASMAtomicWriteBool(&pThisCC->fSignalIdle, false);
3944
3945	buslogicR3HwReset(pDevIns, pThis, true);
3946	return true;
3947	}
3948
3949	/**
3950	* @copydoc FNPDMDEVRESET
3951	*/
3952	static DECLCALLBACK(void) buslogicR3Reset(PPDMDEVINS pDevIns)
3953	{
3954	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3955	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
3956
3957	ASMAtomicWriteBool(&pThisCC->fSignalIdle, true);
3958	if (!buslogicR3AllAsyncIOIsFinished(pDevIns))
3959	PDMDevHlpSetAsyncNotification(pDevIns, buslogicR3IsAsyncResetDone);
3960	else
3961	{
3962	ASMAtomicWriteBool(&pThisCC->fSignalIdle, false);
3963	buslogicR3HwReset(pDevIns, pThis, true);
3964	}
3965	}
3966
3967	/**
3968	* Poweroff notification.
3969	*
3970	* @param pDevIns Pointer to the device instance
3971	*/
3972	static DECLCALLBACK(void) buslogicR3PowerOff(PPDMDEVINS pDevIns)
3973	{
3974	Log(("buslogicR3PowerOff\n"));
3975	buslogicR3SuspendOrPowerOff(pDevIns);
3976	}
3977
3978	/**
3979	* Destroy a driver instance.
3980	*
3981	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
3982	* resources can be freed correctly.
3983	*
3984	* @param pDevIns The device instance data.
3985	*/
3986	static DECLCALLBACK(int) buslogicR3Destruct(PPDMDEVINS pDevIns)
3987	{
3988	PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
3989	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
3990
3991	PDMDevHlpCritSectDelete(pDevIns, &pThis->CritSectIntr);
3992
3993	if (pThis->hEvtProcess != NIL_SUPSEMEVENT)
3994	{
3995	PDMDevHlpSUPSemEventClose(pDevIns, pThis->hEvtProcess);
3996	pThis->hEvtProcess = NIL_SUPSEMEVENT;
3997	}
3998
3999	return VINF_SUCCESS;
4000	}
4001
4002	/**
4003	* @interface_method_impl{PDMDEVREG,pfnConstruct}
4004	*/
4005	static DECLCALLBACK(int) buslogicR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
4006	{
4007	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
4008	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
4009	PBUSLOGICCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PBUSLOGICCC);
4010	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
4011
4012	/*
4013	* Init instance data (do early because of constructor).
4014	*/
4015	pThis->hMmio = NIL_IOMMMIOHANDLE;
4016	pThis->hIoPortsIsa = NIL_IOMIOPORTHANDLE;
4017	pThis->hIoPortsPci = NIL_IOMIOPORTHANDLE;
4018	pThisCC->pDevIns = pDevIns;
4019	pThisCC->IBase.pfnQueryInterface = buslogicR3StatusQueryInterface;
4020	pThisCC->ILeds.pfnQueryStatusLed = buslogicR3StatusQueryStatusLed;
4021
4022	PPDMPCIDEV pPciDev = pDevIns->apPciDevs[0];
4023	PDMPCIDEV_ASSERT_VALID(pDevIns, pPciDev);
4024
4025	PDMPciDevSetVendorId(pPciDev, 0x104b); /* BusLogic */
4026	PDMPciDevSetDeviceId(pPciDev, 0x1040); /* BT-958 */
4027	PDMPciDevSetCommand(pPciDev, PCI_COMMAND_IOACCESS \| PCI_COMMAND_MEMACCESS);
4028	PDMPciDevSetRevisionId(pPciDev, 0x01);
4029	PDMPciDevSetClassProg(pPciDev, 0x00); /* SCSI */
4030	PDMPciDevSetClassSub(pPciDev, 0x00); /* SCSI */
4031	PDMPciDevSetClassBase(pPciDev, 0x01); /* Mass storage */
4032	PDMPciDevSetBaseAddress(pPciDev, 0, true /IO/, false /Pref/, false /64-bit/, 0x00000000);
4033	PDMPciDevSetBaseAddress(pPciDev, 1, false /IO/, false /Pref/, false /64-bit/, 0x00000000);
4034	PDMPciDevSetSubSystemVendorId(pPciDev, 0x104b);
4035	PDMPciDevSetSubSystemId(pPciDev, 0x1040);
4036	PDMPciDevSetInterruptLine(pPciDev, 0x00);
4037	PDMPciDevSetInterruptPin(pPciDev, 0x01);
4038
4039	/*
4040	* Validate and read configuration.
4041	*/
4042	PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "Bootable\|" /* Keep it for legacy configs, even though it doesn't do anything anymore, see @bugref{4841}. */
4043	"AdapterType\|"
4044	"ISACompat",
4045	"");
4046
4047	/* Figure out the emulated device type. */
4048	char szCfgStr[16];
4049	int rc = pHlp->pfnCFGMQueryStringDef(pCfg, "AdapterType", szCfgStr, sizeof(szCfgStr), "BT-958D");
4050	if (RT_FAILURE(rc))
4051	return PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic configuration error: failed to read AdapterType as string"));
4052	Log(("%s: AdapterType=%s\n", __FUNCTION__, szCfgStr));
4053
4054	/* Grok the AdapterType setting. */
4055	if (!strcmp(szCfgStr, "BT-958D")) /* Default PCI device, 32-bit and 24-bit addressing. */
4056	{
4057	pThis->uDevType = DEV_BT_958D;
4058	pThis->uDefaultISABaseCode = ISA_BASE_DISABLED;
4059	}
4060	else if (!strcmp(szCfgStr, "BT-545C")) /* ISA device, 24-bit addressing only. */
4061	{
4062	pThis->uDevType = DEV_BT_545C;
4063	pThis->uIsaIrq = 11;
4064	}
4065	else if (!strcmp(szCfgStr, "AHA-1540B")) /* Competitor ISA device. */
4066	{
4067	pThis->uDevType = DEV_AHA_1540B;
4068	pThis->uIsaIrq = 11;
4069	}
4070	else
4071	return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
4072	N_("BusLogic configuration error: invalid AdapterType setting"));
4073
4074	/* Only the first instance defaults to having the ISA compatibility ports enabled. */
4075	if (iInstance == 0)
4076	rc = pHlp->pfnCFGMQueryStringDef(pCfg, "ISACompat", szCfgStr, sizeof(szCfgStr), "Alternate");
4077	else
4078	rc = pHlp->pfnCFGMQueryStringDef(pCfg, "ISACompat", szCfgStr, sizeof(szCfgStr), "Disabled");
4079	if (RT_FAILURE(rc))
4080	return PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic configuration error: failed to read ISACompat as string"));
4081	Log(("%s: ISACompat=%s\n", __FUNCTION__, szCfgStr));
4082
4083	/* Grok the ISACompat setting. */
4084	if (!strcmp(szCfgStr, "Disabled"))
4085	pThis->uDefaultISABaseCode = ISA_BASE_DISABLED;
4086	else if (!strcmp(szCfgStr, "Primary"))
4087	pThis->uDefaultISABaseCode = 0; /* I/O base at 330h. */
4088	else if (!strcmp(szCfgStr, "Alternate"))
4089	pThis->uDefaultISABaseCode = 1; /* I/O base at 334h. */
4090	else
4091	return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
4092	N_("BusLogic configuration error: invalid ISACompat setting"));
4093
4094	/*
4095	* Register the PCI device and its I/O regions if applicable.
4096	*/
4097	if (!pThis->uIsaIrq)
4098	{
4099	rc = PDMDevHlpPCIRegister(pDevIns, pPciDev);
4100	AssertRCReturn(rc, rc);
4101
4102	rc = PDMDevHlpPCIIORegionCreateIo(pDevIns, 0 /iPciRegion/, 32 /cPorts/,
4103	buslogicIOPortWrite, buslogicIOPortRead, NULL /pvUser/,
4104	"BusLogic PCI", NULL /paExtDescs/, &pThis->hIoPortsPci);
4105	AssertRCReturn(rc, rc);
4106
4107	rc = PDMDevHlpPCIIORegionCreateMmio(pDevIns, 1 /iPciRegion/, 32 /cbRegion/, PCI_ADDRESS_SPACE_MEM,
4108	buslogicMMIOWrite, buslogicMMIORead, NULL /pvUser/,
4109	IOMMMIO_FLAGS_READ_PASSTHRU \| IOMMMIO_FLAGS_WRITE_PASSTHRU,
4110	"BusLogic MMIO", &pThis->hMmio);
4111	AssertRCReturn(rc, rc);
4112	}
4113
4114	/* Set up the compatibility I/O range. */
4115	rc = PDMDevHlpIoPortCreate(pDevIns, 4 /cPorts/, NULL /pPciDev/, UINT32_MAX /iPciRegion/,
4116	buslogicIOPortWrite, buslogicIOPortRead, NULL /pvUser/,
4117	"BusLogic ISA", NULL /paExtDescs/, &pThis->hIoPortsIsa);
4118	AssertRCReturn(rc, rc);
4119
4120	rc = buslogicR3RegisterISARange(pDevIns, pThis, pThis->uDefaultISABaseCode);
4121	if (RT_FAILURE(rc))
4122	return PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic cannot register ISA I/O handlers"));
4123
4124
4125	/* Init the interrupt critsect. */
4126	rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSectIntr, RT_SRC_POS, "BusLogic-Intr#%u", pDevIns->iInstance);
4127	if (RT_FAILURE(rc))
4128	return PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic: cannot create critical section"));
4129
4130	/*
4131	* Create event semaphore and worker thread.
4132	*/
4133	rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->hEvtProcess);
4134	if (RT_FAILURE(rc))
4135	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
4136	N_("BusLogic: Failed to create SUP event semaphore"));
4137
4138	char szDevTag[20];
4139	RTStrPrintf(szDevTag, sizeof(szDevTag), "BUSLOGIC-%u", iInstance);
4140
4141	rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->pThreadWrk, pThis, buslogicR3Worker,
4142	buslogicR3WorkerWakeUp, 0, RTTHREADTYPE_IO, szDevTag);
4143	if (RT_FAILURE(rc))
4144	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
4145	N_("BusLogic: Failed to create worker thread %s"), szDevTag);
4146
4147	/* Initialize per device state. */
4148	for (unsigned i = 0; i < RT_ELEMENTS(pThisCC->aDeviceStates); i++)
4149	{
4150	PBUSLOGICDEVICE pDevice = &pThisCC->aDeviceStates[i];
4151
4152	/* Initialize static parts of the device. */
4153	pDevice->iLUN = i;
4154	pDevice->pDevIns = pDevIns;
4155	pDevice->Led.u32Magic = PDMLED_MAGIC;
4156	pDevice->IBase.pfnQueryInterface = buslogicR3DeviceQueryInterface;
4157	pDevice->IMediaPort.pfnQueryDeviceLocation = buslogicR3QueryDeviceLocation;
4158	pDevice->IMediaExPort.pfnIoReqCompleteNotify = buslogicR3IoReqCompleteNotify;
4159	pDevice->IMediaExPort.pfnIoReqCopyFromBuf = buslogicR3IoReqCopyFromBuf;
4160	pDevice->IMediaExPort.pfnIoReqCopyToBuf = buslogicR3IoReqCopyToBuf;
4161	pDevice->IMediaExPort.pfnIoReqQueryBuf = NULL;
4162	pDevice->IMediaExPort.pfnIoReqQueryDiscardRanges = NULL;
4163	pDevice->IMediaExPort.pfnIoReqStateChanged = buslogicR3IoReqStateChanged;
4164	pDevice->IMediaExPort.pfnMediumEjected = buslogicR3MediumEjected;
4165	pDevice->ILed.pfnQueryStatusLed = buslogicR3DeviceQueryStatusLed;
4166	RTStrPrintf(pDevice->szName, sizeof(pDevice->szName), "Device%u", i);
4167
4168	/* Attach SCSI driver. */
4169	rc = PDMDevHlpDriverAttach(pDevIns, pDevice->iLUN, &pDevice->IBase, &pDevice->pDrvBase, pDevice->szName);
4170	if (RT_SUCCESS(rc))
4171	{
4172	/* Query the media interface. */
4173	pDevice->pDrvMedia = PDMIBASE_QUERY_INTERFACE(pDevice->pDrvBase, PDMIMEDIA);
4174	AssertMsgReturn(VALID_PTR(pDevice->pDrvMedia),
4175	("Buslogic configuration error: LUN#%d misses the basic media interface!\n", pDevice->iLUN),
4176	VERR_PDM_MISSING_INTERFACE);
4177
4178	/* Get the extended media interface. */
4179	pDevice->pDrvMediaEx = PDMIBASE_QUERY_INTERFACE(pDevice->pDrvBase, PDMIMEDIAEX);
4180	AssertMsgReturn(VALID_PTR(pDevice->pDrvMediaEx),
4181	("Buslogic configuration error: LUN#%d misses the extended media interface!\n", pDevice->iLUN),
4182	VERR_PDM_MISSING_INTERFACE);
4183
4184	rc = pDevice->pDrvMediaEx->pfnIoReqAllocSizeSet(pDevice->pDrvMediaEx, sizeof(BUSLOGICREQ));
4185	if (RT_FAILURE(rc))
4186	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
4187	N_("Buslogic configuration error: LUN#%u: Failed to set I/O request size!"),
4188	pDevice->iLUN);
4189
4190	pThis->afDevicePresent[i] = true;
4191	pDevice->fPresent = true;
4192	}
4193	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
4194	{
4195	pThis->afDevicePresent[i] = false;
4196	pDevice->fPresent = false;
4197	pDevice->pDrvBase = NULL;
4198	pDevice->pDrvMedia = NULL;
4199	pDevice->pDrvMediaEx = NULL;
4200	rc = VINF_SUCCESS;
4201	Log(("BusLogic: no driver attached to device %s\n", pDevice->szName));
4202	}
4203	else
4204	{
4205	AssertLogRelMsgFailed(("BusLogic: Failed to attach %s\n", pDevice->szName));
4206	return rc;
4207	}
4208	}
4209
4210	/*
4211	* Attach status driver (optional).
4212	*/
4213	PPDMIBASE pBase;
4214	rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pBase, "Status Port");
4215	if (RT_SUCCESS(rc))
4216	{
4217	pThisCC->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
4218	pThisCC->pMediaNotify = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIANOTIFY);
4219	}
4220	else
4221	AssertMsgReturn(rc == VERR_PDM_NO_ATTACHED_DRIVER, ("Failed to attach to status driver. rc=%Rrc\n", rc),
4222	PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic cannot attach to status driver")));
4223
4224	rc = PDMDevHlpSSMRegisterEx(pDevIns, BUSLOGIC_SAVED_STATE_MINOR_VERSION, sizeof(*pThis), NULL,
4225	NULL, buslogicR3LiveExec, NULL,
4226	NULL, buslogicR3SaveExec, NULL,
4227	NULL, buslogicR3LoadExec, buslogicR3LoadDone);
4228	if (RT_FAILURE(rc))
4229	return PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic cannot register save state handlers"));
4230
4231	/*
4232	* Register the debugger info callback.
4233	*/
4234	char szTmp[128];
4235	RTStrPrintf(szTmp, sizeof(szTmp), "%s%d", pDevIns->pReg->szName, pDevIns->iInstance);
4236	PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "BusLogic HBA info", buslogicR3Info);
4237
4238	rc = buslogicR3HwReset(pDevIns, pThis, true);
4239	AssertMsgRC(rc, ("hardware reset of BusLogic host adapter failed rc=%Rrc\n", rc));
4240
4241	return rc;
4242	}
4243
4244	#else /* !IN_RING3 */
4245
4246	/**
4247	* @callback_method_impl{PDMDEVREGR0,pfnConstruct}
4248	*/
4249	static DECLCALLBACK(int) buslogicRZConstruct(PPDMDEVINS pDevIns)
4250	{
4251	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
4252	PBUSLOGIC pThis = PDMDEVINS_2_DATA(pDevIns, PBUSLOGIC);
4253
4254	if (!pThis->uIsaIrq)
4255	{
4256	int rc = PDMDevHlpIoPortSetUpContext(pDevIns, pThis->hIoPortsPci, buslogicIOPortWrite, buslogicIOPortRead, NULL /pvUser/);
4257	AssertRCReturn(rc, rc);
4258
4259	rc = PDMDevHlpMmioSetUpContext(pDevIns, pThis->hMmio, buslogicMMIOWrite, buslogicMMIORead, NULL /pvUser/);
4260	AssertRCReturn(rc, rc);
4261	}
4262
4263	int rc = PDMDevHlpIoPortSetUpContext(pDevIns, pThis->hIoPortsIsa, buslogicIOPortWrite, buslogicIOPortRead, NULL /pvUser/);
4264	AssertRCReturn(rc, rc);
4265
4266	return VINF_SUCCESS;
4267	}
4268
4269
4270	#endif /* !IN_RING3 */
4271
4272	/**
4273	* The device registration structure.
4274	*/
4275	const PDMDEVREG g_DeviceBusLogic =
4276	{
4277	/* .u32Version = */ PDM_DEVREG_VERSION,
4278	/* .uReserved0 = */ 0,
4279	/* .szName = */ "buslogic",
4280	/* .fFlags = */ PDM_DEVREG_FLAGS_DEFAULT_BITS \| PDM_DEVREG_FLAGS_RZ \| PDM_DEVREG_FLAGS_NEW_STYLE
4281	\| PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION \| PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION
4282	\| PDM_DEVREG_FLAGS_FIRST_RESET_NOTIFICATION,
4283	/* .fClass = */ PDM_DEVREG_CLASS_STORAGE,
4284	/* .cMaxInstances = */ ~0U,
4285	/* .uSharedVersion = */ 42,
4286	/* .cbInstanceShared = */ sizeof(BUSLOGIC),
4287	/* .cbInstanceCC = */ sizeof(BUSLOGICCC),
4288	/* .cbInstanceRC = */ sizeof(BUSLOGICRC),
4289	/* .cMaxPciDevices = */ 1,
4290	/* .cMaxMsixVectors = */ 0,
4291	/* .pszDescription = */ "BusLogic BT-958 SCSI host adapter.\n",
4292	#if defined(IN_RING3)
4293	/* .pszRCMod = */ "VBoxDDRC.rc",
4294	/* .pszR0Mod = */ "VBoxDDR0.r0",
4295	/* .pfnConstruct = */ buslogicR3Construct,
4296	/* .pfnDestruct = */ buslogicR3Destruct,
4297	/* .pfnRelocate = */ NULL,
4298	/* .pfnMemSetup = */ NULL,
4299	/* .pfnPowerOn = */ NULL,
4300	/* .pfnReset = */ buslogicR3Reset,
4301	/* .pfnSuspend = */ buslogicR3Suspend,
4302	/* .pfnResume = */ NULL,
4303	/* .pfnAttach = */ buslogicR3Attach,
4304	/* .pfnDetach = */ buslogicR3Detach,
4305	/* .pfnQueryInterface = */ NULL,
4306	/* .pfnInitComplete = */ NULL,
4307	/* .pfnPowerOff = */ buslogicR3PowerOff,
4308	/* .pfnSoftReset = */ NULL,
4309	/* .pfnReserved0 = */ NULL,
4310	/* .pfnReserved1 = */ NULL,
4311	/* .pfnReserved2 = */ NULL,
4312	/* .pfnReserved3 = */ NULL,
4313	/* .pfnReserved4 = */ NULL,
4314	/* .pfnReserved5 = */ NULL,
4315	/* .pfnReserved6 = */ NULL,
4316	/* .pfnReserved7 = */ NULL,
4317	#elif defined(IN_RING0)
4318	/* .pfnEarlyConstruct = */ NULL,
4319	/* .pfnConstruct = */ buslogicRZConstruct,
4320	/* .pfnDestruct = */ NULL,
4321	/* .pfnFinalDestruct = */ NULL,
4322	/* .pfnRequest = */ NULL,
4323	/* .pfnReserved0 = */ NULL,
4324	/* .pfnReserved1 = */ NULL,
4325	/* .pfnReserved2 = */ NULL,
4326	/* .pfnReserved3 = */ NULL,
4327	/* .pfnReserved4 = */ NULL,
4328	/* .pfnReserved5 = */ NULL,
4329	/* .pfnReserved6 = */ NULL,
4330	/* .pfnReserved7 = */ NULL,
4331	#elif defined(IN_RC)
4332	/* .pfnConstruct = */ buslogicRZConstruct,
4333	/* .pfnReserved0 = */ NULL,
4334	/* .pfnReserved1 = */ NULL,
4335	/* .pfnReserved2 = */ NULL,
4336	/* .pfnReserved3 = */ NULL,
4337	/* .pfnReserved4 = */ NULL,
4338	/* .pfnReserved5 = */ NULL,
4339	/* .pfnReserved6 = */ NULL,
4340	/* .pfnReserved7 = */ NULL,
4341	#else
4342	# error "Not in IN_RING3, IN_RING0 or IN_RC!"
4343	#endif
4344	/* .u32VersionEnd = */ PDM_DEVREG_VERSION
4345	};
4346
4347	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */

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

source: vbox/trunk/src/VBox/Devices/Storage/DevBusLogic.cpp@ 89197

Download in other formats: