DevBusLogic.cpp@ 43329

Last change on this file since 43329 was 43329, checked in by vboxsync, 13 years ago
BusLogic: Minor emulation improvements (see #5112).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 130.5 KB

Line
1	/* $Id: DevBusLogic.cpp 43329 2012-09-14 15:55:26Z vboxsync $ */
2	/** @file
3	* VBox storage devices: BusLogic SCSI host adapter BT-958.
4	*/
5
6	/*
7	* Copyright (C) 2006-2009 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.215389.xyz. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/* Implemented looking at the driver source in the linux kernel (drivers/scsi/BusLogic.[ch]).
19	* See also: http://www.drdobbs.com/184410111
20	*/
21
22	/*******************************************************************************
23	* Header Files *
24	*******************************************************************************/
25	//#define DEBUG
26	#define LOG_GROUP LOG_GROUP_DEV_BUSLOGIC
27	#include <VBox/vmm/pdmdev.h>
28	#include <VBox/vmm/pdmifs.h>
29	#include <VBox/vmm/pdmcritsect.h>
30	#include <VBox/scsi.h>
31	#include <iprt/asm.h>
32	#include <iprt/assert.h>
33	#include <iprt/string.h>
34	#include <iprt/log.h>
35	#ifdef IN_RING3
36	# include <iprt/alloc.h>
37	# include <iprt/memcache.h>
38	# include <iprt/param.h>
39	# include <iprt/uuid.h>
40	#endif
41
42	#include "VBoxSCSI.h"
43	#include "VBoxDD.h"
44
45	/* Maximum number of attached devices the adapter can handle. */
46	#define BUSLOGIC_MAX_DEVICES 16
47
48	/* Maximum number of scatter gather elements this device can handle. */
49	#define BUSLOGIC_MAX_SCATTER_GATHER_LIST_SIZE 128
50
51	/* Size of the command buffer. */
52	#define BUSLOGIC_COMMAND_SIZE_MAX 5
53
54	/* Size of the reply buffer. */
55	#define BUSLOGIC_REPLY_SIZE_MAX 64
56
57	/*
58	* Custom fixed I/O ports for BIOS controller access. Note that these should
59	* not be in the ISA range (below 400h) to avoid conflicts with ISA device
60	* probing. Addresses in the 300h-340h range should be especially avoided.
61	*/
62
63	#define BUSLOGIC_BIOS_IO_PORT 0x330
64
65	/** State saved version. */
66	#define BUSLOGIC_SAVED_STATE_MINOR_VERSION 2
67
68	/** Saved state version before the suspend on error feature was implemented. */
69	#define BUSLOGIC_SAVED_STATE_MINOR_PRE_ERROR_HANDLING 1
70
71	/** The duration of software-initiated reset. Not documented, set to 500 us. */
72	#define BUSLOGIC_RESET_DURATION_NS (500*1000)
73
74	/**
75	* State of a device attached to the buslogic host adapter.
76	*
77	* @implements PDMIBASE
78	* @implements PDMISCSIPORT
79	* @implements PDMILEDPORTS
80	*/
81	typedef struct BUSLOGICDEVICE
82	{
83	/** Pointer to the owning buslogic device instance. - R3 pointer */
84	R3PTRTYPE(struct BUSLOGIC *) pBusLogicR3;
85	/** Pointer to the owning buslogic device instance. - R0 pointer */
86	R0PTRTYPE(struct BUSLOGIC *) pBusLogicR0;
87	/** Pointer to the owning buslogic device instance. - RC pointer */
88	RCPTRTYPE(struct BUSLOGIC *) pBusLogicRC;
89
90	/** Flag whether device is present. */
91	bool fPresent;
92	/** LUN of the device. */
93	RTUINT iLUN;
94
95	#if HC_ARCH_BITS == 64
96	uint32_t Alignment0;
97	#endif
98
99	/** Our base interface. */
100	PDMIBASE IBase;
101	/** SCSI port interface. */
102	PDMISCSIPORT ISCSIPort;
103	/** Led interface. */
104	PDMILEDPORTS ILed;
105	/** Pointer to the attached driver's base interface. */
106	R3PTRTYPE(PPDMIBASE) pDrvBase;
107	/** Pointer to the underlying SCSI connector interface. */
108	R3PTRTYPE(PPDMISCSICONNECTOR) pDrvSCSIConnector;
109	/** The status LED state for this device. */
110	PDMLED Led;
111
112	#if HC_ARCH_BITS == 64
113	uint32_t Alignment1;
114	#endif
115
116	/** Number of outstanding tasks on the port. */
117	volatile uint32_t cOutstandingRequests;
118
119	} BUSLOGICDEVICE, *PBUSLOGICDEVICE;
120
121	/*
122	* Commands the BusLogic adapter supports.
123	*/
124	enum BUSLOGICCOMMAND
125	{
126	BUSLOGICCOMMAND_TEST_CMDC_INTERRUPT = 0x00,
127	BUSLOGICCOMMAND_INITIALIZE_MAILBOX = 0x01,
128	BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND = 0x02,
129	BUSLOGICCOMMAND_EXECUTE_BIOS_COMMAND = 0x03,
130	BUSLOGICCOMMAND_INQUIRE_BOARD_ID = 0x04,
131	BUSLOGICCOMMAND_ENABLE_OUTGOING_MAILBOX_AVAILABLE_INTERRUPT = 0x05,
132	BUSLOGICCOMMAND_SET_SCSI_SELECTION_TIMEOUT = 0x06,
133	BUSLOGICCOMMAND_SET_PREEMPT_TIME_ON_BUS = 0x07,
134	BUSLOGICCOMMAND_SET_TIME_OFF_BUS = 0x08,
135	BUSLOGICCOMMAND_SET_BUS_TRANSFER_RATE = 0x09,
136	BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_0_TO_7 = 0x0a,
137	BUSLOGICCOMMAND_INQUIRE_CONFIGURATION = 0x0b,
138	BUSLOGICCOMMAND_ENABLE_TARGET_MODE = 0x0c,
139	BUSLOGICCOMMAND_INQUIRE_SETUP_INFORMATION = 0x0d,
140	BUSLOGICCOMMAND_WRITE_ADAPTER_LOCAL_RAM = 0x1a,
141	BUSLOGICCOMMAND_READ_ADAPTER_LOCAL_RAM = 0x1b,
142	BUSLOGICCOMMAND_WRITE_BUSMASTER_CHIP_FIFO = 0x1c,
143	BUSLOGICCOMMAND_READ_BUSMASTER_CHIP_FIFO = 0x1d,
144	BUSLOGICCOMMAND_ECHO_COMMAND_DATA = 0x1f,
145	BUSLOGICCOMMAND_HOST_ADAPTER_DIAGNOSTIC = 0x20,
146	BUSLOGICCOMMAND_SET_ADAPTER_OPTIONS = 0x21,
147	BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_8_TO_15 = 0x23,
148	BUSLOGICCOMMAND_INQUIRE_TARGET_DEVICES = 0x24,
149	BUSLOGICCOMMAND_DISABLE_HOST_ADAPTER_INTERRUPT = 0x25,
150	BUSLOGICCOMMAND_EXT_BIOS_INFO = 0x28,
151	BUSLOGICCOMMAND_UNLOCK_MAILBOX = 0x29,
152	BUSLOGICCOMMAND_INITIALIZE_EXTENDED_MAILBOX = 0x81,
153	BUSLOGICCOMMAND_EXECUTE_SCSI_COMMAND = 0x83,
154	BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_3RD_LETTER = 0x84,
155	BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_LETTER = 0x85,
156	BUSLOGICCOMMAND_INQUIRE_PCI_HOST_ADAPTER_INFORMATION = 0x86,
157	BUSLOGICCOMMAND_INQUIRE_HOST_ADAPTER_MODEL_NUMBER = 0x8b,
158	BUSLOGICCOMMAND_INQUIRE_SYNCHRONOUS_PERIOD = 0x8c,
159	BUSLOGICCOMMAND_INQUIRE_EXTENDED_SETUP_INFORMATION = 0x8d,
160	BUSLOGICCOMMAND_ENABLE_STRICT_ROUND_ROBIN_MODE = 0x8f,
161	BUSLOGICCOMMAND_STORE_HOST_ADAPTER_LOCAL_RAM = 0x90,
162	BUSLOGICCOMMAND_FETCH_HOST_ADAPTER_LOCAL_RAM = 0x91,
163	BUSLOGICCOMMAND_STORE_LOCAL_DATA_IN_EEPROM = 0x92,
164	BUSLOGICCOMMAND_UPLOAD_AUTO_SCSI_CODE = 0x94,
165	BUSLOGICCOMMAND_MODIFY_IO_ADDRESS = 0x95,
166	BUSLOGICCOMMAND_SET_CCB_FORMAT = 0x96,
167	BUSLOGICCOMMAND_WRITE_INQUIRY_BUFFER = 0x9a,
168	BUSLOGICCOMMAND_READ_INQUIRY_BUFFER = 0x9b,
169	BUSLOGICCOMMAND_FLASH_ROM_UPLOAD_DOWNLOAD = 0xa7,
170	BUSLOGICCOMMAND_READ_SCAM_DATA = 0xa8,
171	BUSLOGICCOMMAND_WRITE_SCAM_DATA = 0xa9
172	} BUSLOGICCOMMAND;
173
174	#pragma pack(1)
175	/**
176	* Auto SCSI structure which is located
177	* in host adapter RAM and contains several
178	* configuration parameters.
179	*/
180	typedef struct AutoSCSIRam
181	{
182	uint8_t aInternalSignature[2];
183	uint8_t cbInformation;
184	uint8_t aHostAdaptertype[6];
185	uint8_t uReserved1;
186	bool fFloppyEnabled: 1;
187	bool fFloppySecondary: 1;
188	bool fLevelSensitiveInterrupt: 1;
189	unsigned char uReserved2: 2;
190	unsigned char uSystemRAMAreForBIOS: 3;
191	unsigned char uDMAChannel: 7;
192	bool fDMAAutoConfiguration: 1;
193	unsigned char uIrqChannel: 7;
194	bool fIrqAutoConfiguration: 1;
195	uint8_t uDMATransferRate;
196	uint8_t uSCSIId;
197	bool fLowByteTerminated: 1;
198	bool fParityCheckingEnabled: 1;
199	bool fHighByteTerminated: 1;
200	bool fNoisyCablingEnvironment: 1;
201	bool fFastSynchronousNeogtiation: 1;
202	bool fBusResetEnabled: 1;
203	bool fReserved3: 1;
204	bool fActiveNegotiationEnabled: 1;
205	uint8_t uBusOnDelay;
206	uint8_t uBusOffDelay;
207	bool fHostAdapterBIOSEnabled: 1;
208	bool fBIOSRedirectionOfInt19: 1;
209	bool fExtendedTranslation: 1;
210	bool fMapRemovableAsFixed: 1;
211	bool fReserved4: 1;
212	bool fBIOSSupportsMoreThan2Drives: 1;
213	bool fBIOSInterruptMode: 1;
214	bool fFlopticalSupport: 1;
215	uint16_t u16DeviceEnabledMask;
216	uint16_t u16WidePermittedMask;
217	uint16_t u16FastPermittedMask;
218	uint16_t u16SynchronousPermittedMask;
219	uint16_t u16DisconnectPermittedMask;
220	uint16_t u16SendStartUnitCommandMask;
221	uint16_t u16IgnoreInBIOSScanMask;
222	unsigned char uPCIInterruptPin: 2;
223	unsigned char uHostAdapterIoPortAddress: 2;
224	bool fStrictRoundRobinMode: 1;
225	bool fVesaBusSpeedGreaterThan33MHz: 1;
226	bool fVesaBurstWrite: 1;
227	bool fVesaBurstRead: 1;
228	uint16_t u16UltraPermittedMask;
229	uint32_t uReserved5;
230	uint8_t uReserved6;
231	uint8_t uAutoSCSIMaximumLUN;
232	bool fReserved7: 1;
233	bool fSCAMDominant: 1;
234	bool fSCAMenabled: 1;
235	bool fSCAMLevel2: 1;
236	unsigned char uReserved8: 4;
237	bool fInt13Extension: 1;
238	bool fReserved9: 1;
239	bool fCDROMBoot: 1;
240	unsigned char uReserved10: 5;
241	unsigned char uBootTargetId: 4;
242	unsigned char uBootChannel: 4;
243	bool fForceBusDeviceScanningOrder: 1;
244	unsigned char uReserved11: 7;
245	uint16_t u16NonTaggedToAlternateLunPermittedMask;
246	uint16_t u16RenegotiateSyncAfterCheckConditionMask;
247	uint8_t aReserved12[10];
248	uint8_t aManufacturingDiagnostic[2];
249	uint16_t u16Checksum;
250	} AutoSCSIRam, *PAutoSCSIRam;
251	AssertCompileSize(AutoSCSIRam, 64);
252	#pragma pack()
253
254	/**
255	* The local Ram.
256	*/
257	typedef union HostAdapterLocalRam
258	{
259	/* Byte view. */
260	uint8_t u8View[256];
261	/* Structured view. */
262	struct
263	{
264	/** Offset 0 - 63 is for BIOS. */
265	uint8_t u8Bios[64];
266	/** Auto SCSI structure. */
267	AutoSCSIRam autoSCSIData;
268	} structured;
269	} HostAdapterLocalRam, *PHostAdapterLocalRam;
270	AssertCompileSize(HostAdapterLocalRam, 256);
271
272	/** Pointer to a task state structure. */
273	typedef struct BUSLOGICTASKSTATE *PBUSLOGICTASKSTATE;
274
275	/**
276	* Main BusLogic device state.
277	*
278	* @extends PCIDEVICE
279	* @implements PDMILEDPORTS
280	*/
281	typedef struct BUSLOGIC
282	{
283	/** The PCI device structure. */
284	PCIDEVICE dev;
285	/** Pointer to the device instance - HC ptr */
286	PPDMDEVINSR3 pDevInsR3;
287	/** Pointer to the device instance - R0 ptr */
288	PPDMDEVINSR0 pDevInsR0;
289	/** Pointer to the device instance - RC ptr. */
290	PPDMDEVINSRC pDevInsRC;
291
292	/** Whether R0 is enabled. */
293	bool fR0Enabled;
294	/** Whether RC is enabled. */
295	bool fGCEnabled;
296
297	/** Base address of the I/O ports. */
298	RTIOPORT IOPortBase;
299	/** Base address of the memory mapping. */
300	RTGCPHYS MMIOBase;
301	/** Status register - Readonly. */
302	volatile uint8_t regStatus;
303	/** Interrupt register - Readonly. */
304	volatile uint8_t regInterrupt;
305	/** Geometry register - Readonly. */
306	volatile uint8_t regGeometry;
307	/** Pending (delayed) interrupt. */
308	uint8_t uPendingIntr;
309
310	/** Local RAM for the fetch hostadapter local RAM request.
311	* I don't know how big the buffer really is but the maximum
312	* seems to be 256 bytes because the offset and count field in the command request
313	* are only one byte big.
314	*/
315	HostAdapterLocalRam LocalRam;
316
317	/** Command code the guest issued. */
318	uint8_t uOperationCode;
319	/** Buffer for the command parameters the adapter is currently receiving from the guest.
320	* Size of the largest command which is possible.
321	*/
322	uint8_t aCommandBuffer[BUSLOGIC_COMMAND_SIZE_MAX]; /* Size of the biggest request. */
323	/** Current position in the command buffer. */
324	uint8_t iParameter;
325	/** Parameters left until the command is complete. */
326	uint8_t cbCommandParametersLeft;
327
328	/** Whether we are using the RAM or reply buffer. */
329	bool fUseLocalRam;
330	/** Buffer to store reply data from the controller to the guest. */
331	uint8_t aReplyBuffer[BUSLOGIC_REPLY_SIZE_MAX]; /* Size of the biggest reply. */
332	/** Position in the buffer we are reading next. */
333	uint8_t iReply;
334	/** Bytes left until the reply buffer is empty. */
335	uint8_t cbReplyParametersLeft;
336
337	/** Flag whether IRQs are enabled. */
338	bool fIRQEnabled;
339	/** Flag whether the ISA I/O port range is disabled
340	* to prevent the BIOs to access the device. */
341	bool fISAEnabled;
342
343	/** Number of mailboxes the guest set up. */
344	uint32_t cMailbox;
345
346	#if HC_ARCH_BITS == 64
347	uint32_t Alignment0;
348	#endif
349
350	/** Time when HBA reset was last initiated. */ //@todo: does this need to be saved?
351	uint64_t u64ResetTime;
352	/** Physical base address of the outgoing mailboxes. */
353	RTGCPHYS GCPhysAddrMailboxOutgoingBase;
354	/** Current outgoing mailbox position. */
355	uint32_t uMailboxOutgoingPositionCurrent;
356	/** Number of mailboxes ready. */
357	volatile uint32_t cMailboxesReady;
358	/** Whether a notification to R3 was send. */
359	volatile bool fNotificationSend;
360
361	#if HC_ARCH_BITS == 64
362	uint32_t Alignment1;
363	#endif
364
365	/** Physical base address of the incoming mailboxes. */
366	RTGCPHYS GCPhysAddrMailboxIncomingBase;
367	/** Current incoming mailbox position. */
368	uint32_t uMailboxIncomingPositionCurrent;
369
370	/** Whether strict round robin is enabled. */
371	bool fStrictRoundRobinMode;
372	/** Whether the extended LUN CCB format is enabled for 32 possible logical units. */
373	bool fExtendedLunCCBFormat;
374
375	/** Queue to send tasks to R3. - HC ptr */
376	R3PTRTYPE(PPDMQUEUE) pNotifierQueueR3;
377	/** Queue to send tasks to R3. - HC ptr */
378	R0PTRTYPE(PPDMQUEUE) pNotifierQueueR0;
379	/** Queue to send tasks to R3. - RC ptr */
380	RCPTRTYPE(PPDMQUEUE) pNotifierQueueRC;
381
382	uint32_t Alignment2;
383
384	/** Critical section protecting access to the interrupt status register. */
385	PDMCRITSECT CritSectIntr;
386
387	/** Cache for task states. */
388	R3PTRTYPE(RTMEMCACHE) hTaskCache;
389
390	/** Device state for BIOS access. */
391	VBOXSCSI VBoxSCSI;
392
393	/** BusLogic device states. */
394	BUSLOGICDEVICE aDeviceStates[BUSLOGIC_MAX_DEVICES];
395
396	/** The base interface.
397	* @todo use PDMDEVINS::IBase */
398	PDMIBASE IBase;
399	/** Status Port - Leds interface. */
400	PDMILEDPORTS ILeds;
401	/** Partner of ILeds. */
402	R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
403
404	#if HC_ARCH_BITS == 64
405	uint32_t Alignment3;
406	#endif
407
408	/** Indicates that PDMDevHlpAsyncNotificationCompleted should be called when
409	* a port is entering the idle state. */
410	bool volatile fSignalIdle;
411	/** Flag whether we have tasks which need to be processed again. */
412	bool volatile fRedo;
413	/** List of tasks which can be redone. */
414	R3PTRTYPE(volatile PBUSLOGICTASKSTATE) pTasksRedoHead;
415
416	#ifdef LOG_ENABLED
417	# if HC_ARCH_BITS == 64
418	uint32_t Alignment4;
419	# endif
420
421	volatile uint32_t cInMailboxesReady;
422	#endif
423
424	} BUSLOGIC, *PBUSLOGIC;
425
426	/** Register offsets in the I/O port space. */
427	#define BUSLOGIC_REGISTER_CONTROL 0 /* Writeonly */
428	/** Fields for the control register. */
429	# define BUSLOGIC_REGISTER_CONTROL_SCSI_BUSRESET RT_BIT(4)
430	# define BUSLOGIC_REGISTER_CONTROL_INTERRUPT_RESET RT_BIT(5)
431	# define BUSLOGIC_REGISTER_CONTROL_SOFT_RESET RT_BIT(6)
432	# define BUSLOGIC_REGISTER_CONTROL_HARD_RESET RT_BIT(7)
433
434	#define BUSLOGIC_REGISTER_STATUS 0 /* Readonly */
435	/** Fields for the status register. */
436	# define BUSLOGIC_REGISTER_STATUS_COMMAND_INVALID RT_BIT(0)
437	# define BUSLOGIC_REGISTER_STATUS_DATA_IN_REGISTER_READY RT_BIT(2)
438	# define BUSLOGIC_REGISTER_STATUS_COMMAND_PARAMETER_REGISTER_BUSY RT_BIT(3)
439	# define BUSLOGIC_REGISTER_STATUS_HOST_ADAPTER_READY RT_BIT(4)
440	# define BUSLOGIC_REGISTER_STATUS_INITIALIZATION_REQUIRED RT_BIT(5)
441	# define BUSLOGIC_REGISTER_STATUS_DIAGNOSTIC_FAILURE RT_BIT(6)
442	# define BUSLOGIC_REGISTER_STATUS_DIAGNOSTIC_ACTIVE RT_BIT(7)
443
444	#define BUSLOGIC_REGISTER_COMMAND 1 /* Writeonly */
445	#define BUSLOGIC_REGISTER_DATAIN 1 /* Readonly */
446	#define BUSLOGIC_REGISTER_INTERRUPT 2 /* Readonly */
447	/** Fields for the interrupt register. */
448	# define BUSLOGIC_REGISTER_INTERRUPT_INCOMING_MAILBOX_LOADED RT_BIT(0)
449	# define BUSLOGIC_REGISTER_INTERRUPT_OUTGOING_MAILBOX_AVAILABLE RT_BIT(1)
450	# define BUSLOGIC_REGISTER_INTERRUPT_COMMAND_COMPLETE RT_BIT(2)
451	# define BUSLOGIC_REGISTER_INTERRUPT_EXTERNAL_BUS_RESET RT_BIT(3)
452	# define BUSLOGIC_REGISTER_INTERRUPT_INTERRUPT_VALID RT_BIT(7)
453
454	#define BUSLOGIC_REGISTER_GEOMETRY 3 /* Readonly */
455	# define BUSLOGIC_REGISTER_GEOMETRY_EXTENTED_TRANSLATION_ENABLED RT_BIT(7)
456
457	/* Structure for the INQUIRE_PCI_HOST_ADAPTER_INFORMATION reply. */
458	typedef struct ReplyInquirePCIHostAdapterInformation
459	{
460	uint8_t IsaIOPort;
461	uint8_t IRQ;
462	unsigned char LowByteTerminated:1;
463	unsigned char HighByteTerminated:1;
464	unsigned char uReserved:2; /* Reserved. */
465	unsigned char JP1:1; /* Whatever that means. */
466	unsigned char JP2:1; /* Whatever that means. */
467	unsigned char JP3:1; /* Whatever that means. */
468	/** Whether the provided info is valid. */
469	unsigned char InformationIsValid: 1;
470	uint8_t uReserved2; /* Reserved. */
471	} ReplyInquirePCIHostAdapterInformation, *PReplyInquirePCIHostAdapterInformation;
472	AssertCompileSize(ReplyInquirePCIHostAdapterInformation, 4);
473
474	/* Structure for the INQUIRE_CONFIGURATION reply. */
475	typedef struct ReplyInquireConfiguration
476	{
477	unsigned char uReserved1: 5;
478	bool fDmaChannel5: 1;
479	bool fDmaChannel6: 1;
480	bool fDmaChannel7: 1;
481	bool fIrqChannel9: 1;
482	bool fIrqChannel10: 1;
483	bool fIrqChannel11: 1;
484	bool fIrqChannel12: 1;
485	unsigned char uReserved2: 1;
486	bool fIrqChannel14: 1;
487	bool fIrqChannel15: 1;
488	unsigned char uReserved3: 1;
489	unsigned char uHostAdapterId: 4;
490	unsigned char uReserved4: 4;
491	} ReplyInquireConfiguration, *PReplyInquireConfiguration;
492	AssertCompileSize(ReplyInquireConfiguration, 3);
493
494	/* Structure for the INQUIRE_SETUP_INFORMATION reply. */
495	typedef struct ReplyInquireSetupInformationSynchronousValue
496	{
497	unsigned char uOffset: 4;
498	unsigned char uTransferPeriod: 3;
499	bool fSynchronous: 1;
500	}ReplyInquireSetupInformationSynchronousValue, *PReplyInquireSetupInformationSynchronousValue;
501	AssertCompileSize(ReplyInquireSetupInformationSynchronousValue, 1);
502
503	typedef struct ReplyInquireSetupInformation
504	{
505	bool fSynchronousInitiationEnabled: 1;
506	bool fParityCheckingEnabled: 1;
507	unsigned char uReserved1: 6;
508	uint8_t uBusTransferRate;
509	uint8_t uPreemptTimeOnBus;
510	uint8_t uTimeOffBus;
511	uint8_t cMailbox;
512	uint8_t MailboxAddress[3];
513	ReplyInquireSetupInformationSynchronousValue SynchronousValuesId0To7[8];
514	uint8_t uDisconnectPermittedId0To7;
515	uint8_t uSignature;
516	uint8_t uCharacterD;
517	uint8_t uHostBusType;
518	uint8_t uWideTransferPermittedId0To7;
519	uint8_t uWideTransfersActiveId0To7;
520	ReplyInquireSetupInformationSynchronousValue SynchronousValuesId8To15[8];
521	uint8_t uDisconnectPermittedId8To15;
522	uint8_t uReserved2;
523	uint8_t uWideTransferPermittedId8To15;
524	uint8_t uWideTransfersActiveId8To15;
525	} ReplyInquireSetupInformation, *PReplyInquireSetupInformation;
526	AssertCompileSize(ReplyInquireSetupInformation, 34);
527
528	/* Structure for the INQUIRE_EXTENDED_SETUP_INFORMATION. */
529	#pragma pack(1)
530	typedef struct ReplyInquireExtendedSetupInformation
531	{
532	uint8_t uBusType;
533	uint8_t uBiosAddress;
534	uint16_t u16ScatterGatherLimit;
535	uint8_t cMailbox;
536	uint32_t uMailboxAddressBase;
537	unsigned char uReserved1: 2;
538	bool fFastEISA: 1;
539	unsigned char uReserved2: 3;
540	bool fLevelSensitiveInterrupt: 1;
541	unsigned char uReserved3: 1;
542	unsigned char aFirmwareRevision[3];
543	bool fHostWideSCSI: 1;
544	bool fHostDifferentialSCSI: 1;
545	bool fHostSupportsSCAM: 1;
546	bool fHostUltraSCSI: 1;
547	bool fHostSmartTermination: 1;
548	unsigned char uReserved4: 3;
549	} ReplyInquireExtendedSetupInformation, *PReplyInquireExtendedSetupInformation;
550	AssertCompileSize(ReplyInquireExtendedSetupInformation, 14);
551	#pragma pack()
552
553	/* Structure for the INITIALIZE EXTENDED MAILBOX request. */
554	#pragma pack(1)
555	typedef struct RequestInitializeExtendedMailbox
556	{
557	/** Number of mailboxes in guest memory. */
558	uint8_t cMailbox;
559	/** Physical address of the first mailbox. */
560	uint32_t uMailboxBaseAddress;
561	} RequestInitializeExtendedMailbox, *PRequestInitializeExtendedMailbox;
562	AssertCompileSize(RequestInitializeExtendedMailbox, 5);
563	#pragma pack()
564
565	/*
566	* Structure of a mailbox in guest memory.
567	* The incoming and outgoing mailbox have the same size
568	* but the incoming one has some more fields defined which
569	* are marked as reserved in the outgoing one.
570	* The last field is also different from the type.
571	* For outgoing mailboxes it is the action and
572	* for incoming ones the completion status code for the task.
573	* We use one structure for both types.
574	*/
575	#pragma pack(1)
576	typedef struct Mailbox
577	{
578	/** Physical address of the CCB structure in the guest memory. */
579	uint32_t u32PhysAddrCCB;
580	/** Type specific data. */
581	union
582	{
583	/** For outgoing mailboxes. */
584	struct
585	{
586	/** Reserved */
587	uint8_t uReserved[3];
588	/** Action code. */
589	uint8_t uActionCode;
590	} out;
591	/** For incoming mailboxes. */
592	struct
593	{
594	/** The host adapter status after finishing the request. */
595	uint8_t uHostAdapterStatus;
596	/** The status of the device which executed the request after executing it. */
597	uint8_t uTargetDeviceStatus;
598	/** Reserved. */
599	uint8_t uReserved;
600	/** The completion status code of the request. */
601	uint8_t uCompletionCode;
602	} in;
603	} u;
604	} Mailbox, *PMailbox;
605	AssertCompileSize(Mailbox, 8);
606	#pragma pack()
607
608	/*
609	* Action codes for outgoing mailboxes.
610	*/
611	enum BUSLOGIC_MAILBOX_OUTGOING_ACTION
612	{
613	BUSLOGIC_MAILBOX_OUTGOING_ACTION_FREE = 0x00,
614	BUSLOGIC_MAILBOX_OUTGOING_ACTION_START_COMMAND = 0x01,
615	BUSLOGIC_MAILBOX_OUTGOING_ACTION_ABORT_COMMAND = 0x02
616	};
617
618	/*
619	* Completion codes for incoming mailboxes.
620	*/
621	enum BUSLOGIC_MAILBOX_INCOMING_COMPLETION
622	{
623	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_FREE = 0x00,
624	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITHOUT_ERROR = 0x01,
625	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_ABORTED = 0x02,
626	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_ABORTED_NOT_FOUND = 0x03,
627	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITH_ERROR = 0x04,
628	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_INVALID_CCB = 0x05
629	};
630
631	/*
632	* Host adapter status for incoming mailboxes.
633	*/
634	enum BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS
635	{
636	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_CMD_COMPLETED = 0x00,
637	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_LINKED_CMD_COMPLETED = 0x0a,
638	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_LINKED_CMD_COMPLETED_WITH_FLAG = 0x0b,
639	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_DATA_UNDERUN = 0x0c,
640	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_SCSI_SELECTION_TIMEOUT = 0x11,
641	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_DATA_OVERRUN = 0x12,
642	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_UNEXPECTED_BUS_FREE = 0x13,
643	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_BUS_PHASE_REQUESTED = 0x14,
644	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_OUTGOING_MAILBOX_ACTION_CODE = 0x15,
645	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_COMMAND_OPERATION_CODE = 0x16,
646	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_LINKED_CCB_HAS_INVALID_LUN = 0x17,
647	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_INVALID_COMMAND_PARAMETER = 0x1a,
648	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_AUTO_REQUEST_SENSE_FAILED = 0x1b,
649	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_TAGGED_QUEUING_MESSAGE_REJECTED = 0x1c,
650	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_UNSUPPORTED_MESSAGE_RECEIVED = 0x1d,
651	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_HARDWARE_FAILED = 0x20,
652	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_TARGET_FAILED_RESPONSE_TO_ATN = 0x21,
653	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_ASSERTED_RST = 0x22,
654	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_OTHER_DEVICE_ASSERTED_RST = 0x23,
655	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_TARGET_DEVICE_RECONNECTED_IMPROPERLY = 0x24,
656	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_ASSERTED_BUS_DEVICE_RESET = 0x25,
657	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_ABORT_QUEUE_GENERATED = 0x26,
658	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_SOFTWARE_ERROR = 0x27,
659	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_HOST_ADAPTER_HARDWARE_TIMEOUT_ERROR = 0x30,
660	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_SCSI_PARITY_ERROR_DETECTED = 0x34
661	};
662
663	/*
664	* Device status codes for incoming mailboxes.
665	*/
666	enum BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS
667	{
668	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD = 0x00,
669	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_CHECK_CONDITION = 0x02,
670	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_DEVICE_BUSY = 0x08
671	};
672
673	/*
674	* Opcode types for CCB.
675	*/
676	enum BUSLOGIC_CCB_OPCODE
677	{
678	BUSLOGIC_CCB_OPCODE_INITIATOR_CCB = 0x00,
679	BUSLOGIC_CCB_OPCODE_TARGET_CCB = 0x01,
680	BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_SCATTER_GATHER = 0x02,
681	BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_DATA_LENGTH = 0x03,
682	BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_SCATTER_GATHER = 0x04,
683	BUSLOGIC_CCB_OPCODE_BUS_DEVICE_RESET = 0x81
684	};
685
686	/*
687	* Data transfer direction.
688	*/
689	enum BUSLOGIC_CCB_DIRECTION
690	{
691	BUSLOGIC_CCB_DIRECTION_UNKNOWN = 0x00,
692	BUSLOGIC_CCB_DIRECTION_IN = 0x01,
693	BUSLOGIC_CCB_DIRECTION_OUT = 0x02,
694	BUSLOGIC_CCB_DIRECTION_NO_DATA = 0x03
695	};
696
697	/*
698	* The command control block for a SCSI request.
699	*/
700	#pragma pack(1)
701	typedef struct CommandControlBlock
702	{
703	/** Opcode. */
704	uint8_t uOpcode;
705	/** Reserved */
706	unsigned char uReserved1: 3;
707	/** Data direction for the request. */
708	unsigned char uDataDirection: 2;
709	/** Whether the request is tag queued. */
710	bool fTagQueued: 1;
711	/** Queue tag mode. */
712	unsigned char uQueueTag: 2;
713	/** Length of the SCSI CDB. */
714	uint8_t cbCDB;
715	/** Sense data length. */
716	uint8_t cbSenseData;
717	/** Data length. */
718	uint32_t cbData;
719	/** Data pointer.
720	* This points to the data region or a scatter gather list based on the opcode.
721	*/
722	uint32_t u32PhysAddrData;
723	/** Reserved. */
724	uint8_t uReserved2[2];
725	/** Host adapter status. */
726	uint8_t uHostAdapterStatus;
727	/** Device adapter status. */
728	uint8_t uDeviceStatus;
729	/** The device the request is send to. */
730	uint8_t uTargetId;
731	/*The LUN in the device. /
732	unsigned char uLogicalUnit: 5;
733	/** Legacy tag. */
734	bool fLegacyTagEnable: 1;
735	/** Legacy queue tag. */
736	unsigned char uLegacyQueueTag: 2;
737	/** The SCSI CDB. */
738	uint8_t aCDB[12]; /* A CDB can be 12 bytes long. */
739	/** Reserved. */
740	uint8_t uReserved3[6];
741	/** Sense data pointer. */
742	uint32_t u32PhysAddrSenseData;
743	} CommandControlBlock, *PCommandControlBlock;
744	AssertCompileSize(CommandControlBlock, 40);
745	#pragma pack()
746
747	#pragma pack(1)
748	typedef struct ScatterGatherEntry
749	{
750	uint32_t cbSegment;
751	uint32_t u32PhysAddrSegmentBase;
752	} ScatterGatherEntry, *PScatterGatherEntry;
753	AssertCompileSize(ScatterGatherEntry, 8);
754	#pragma pack()
755
756	/*
757	* Task state for a CCB request.
758	*/
759	typedef struct BUSLOGICTASKSTATE
760	{
761	/** Next in the redo list. */
762	PBUSLOGICTASKSTATE pRedoNext;
763	/** Device this task is assigned to. */
764	R3PTRTYPE(PBUSLOGICDEVICE) pTargetDeviceR3;
765	/** The command control block from the guest. */
766	CommandControlBlock CommandControlBlockGuest;
767	/** Mailbox read from guest memory. */
768	Mailbox MailboxGuest;
769	/** The SCSI request we pass to the underlying SCSI engine. */
770	PDMSCSIREQUEST PDMScsiRequest;
771	/** Data buffer segment */
772	RTSGSEG DataSeg;
773	/** Pointer to the R3 sense buffer. */
774	uint8_t *pbSenseBuffer;
775	/** Flag whether this is a request from the BIOS. */
776	bool fBIOS;
777	} BUSLOGICTASKSTATE;
778
779	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
780
781	#define PDMIBASE_2_PBUSLOGICDEVICE(pInterface) ( (PBUSLOGICDEVICE)((uintptr_t)(pInterface) - RT_OFFSETOF(BUSLOGICDEVICE, IBase)) )
782	#define PDMISCSIPORT_2_PBUSLOGICDEVICE(pInterface) ( (PBUSLOGICDEVICE)((uintptr_t)(pInterface) - RT_OFFSETOF(BUSLOGICDEVICE, ISCSIPort)) )
783	#define PDMILEDPORTS_2_PBUSLOGICDEVICE(pInterface) ( (PBUSLOGICDEVICE)((uintptr_t)(pInterface) - RT_OFFSETOF(BUSLOGICDEVICE, ILed)) )
784	#define PDMIBASE_2_PBUSLOGIC(pInterface) ( (PBUSLOGIC)((uintptr_t)(pInterface) - RT_OFFSETOF(BUSLOGIC, IBase)) )
785	#define PDMILEDPORTS_2_PBUSLOGIC(pInterface) ( (PBUSLOGIC)((uintptr_t)(pInterface) - RT_OFFSETOF(BUSLOGIC, ILeds)) )
786
787	/**
788	* Assert IRQ line of the BusLogic adapter.
789	*
790	* @returns nothing.
791	* @param pBusLogic Pointer to the BusLogic device instance.
792	* @param fSuppressIrq Flag to suppress IRQ generation regardless of fIRQEnabled
793	* @param uFlag Type of interrupt being generated.
794	*/
795	static void buslogicSetInterrupt(PBUSLOGIC pBusLogic, bool fSuppressIrq, uint8_t uIrqType)
796	{
797	LogFlowFunc(("pBusLogic=%#p\n", pBusLogic));
798
799	/* The CMDC interrupt has priority over IMBL and MBOR. */
800	if (uIrqType & (BUSLOGIC_REGISTER_INTERRUPT_INCOMING_MAILBOX_LOADED \| BUSLOGIC_REGISTER_INTERRUPT_OUTGOING_MAILBOX_AVAILABLE))
801	{
802	if (!(pBusLogic->regInterrupt & BUSLOGIC_REGISTER_INTERRUPT_COMMAND_COMPLETE))
803	pBusLogic->regInterrupt \|= uIrqType; /* Report now. */
804	else
805	pBusLogic->uPendingIntr \|= uIrqType; /* Report later. */
806	}
807	else if (uIrqType & BUSLOGIC_REGISTER_INTERRUPT_COMMAND_COMPLETE)
808	{
809	Assert(!pBusLogic->regInterrupt);
810	pBusLogic->regInterrupt \|= uIrqType;
811	}
812	else
813	AssertMsgFailed(("Invalid interrupt state!\n"));
814
815	pBusLogic->regInterrupt \|= BUSLOGIC_REGISTER_INTERRUPT_INTERRUPT_VALID;
816	if (pBusLogic->fIRQEnabled && !fSuppressIrq)
817	PDMDevHlpPCISetIrq(pBusLogic->CTX_SUFF(pDevIns), 0, 1);
818	}
819
820	/**
821	* Deasserts the interrupt line of the BusLogic adapter.
822	*
823	* @returns nothing
824	* @param pBuslogic Pointer to the BusLogic device instance.
825	*/
826	static void buslogicClearInterrupt(PBUSLOGIC pBusLogic)
827	{
828	LogFlowFunc(("pBusLogic=%#p\n", pBusLogic));
829	pBusLogic->regInterrupt = 0;
830	PDMDevHlpPCISetIrq(pBusLogic->CTX_SUFF(pDevIns), 0, 0);
831	/* If there's another pending interrupt, report it now. */
832	if (pBusLogic->uPendingIntr)
833	{
834	buslogicSetInterrupt(pBusLogic, false, pBusLogic->uPendingIntr);
835	pBusLogic->uPendingIntr = 0;
836	}
837	}
838
839	#if defined(IN_RING3)
840
841	/**
842	* Advances the mailbox pointer to the next slot.
843	*/
844	DECLINLINE(void) buslogicOutgoingMailboxAdvance(PBUSLOGIC pBusLogic)
845	{
846	pBusLogic->uMailboxOutgoingPositionCurrent = (pBusLogic->uMailboxOutgoingPositionCurrent + 1) % pBusLogic->cMailbox;
847	}
848
849	/**
850	* Returns the physical address of the next outgoing mailbox to process.
851	*/
852	DECLINLINE(RTGCPHYS) buslogicOutgoingMailboxGetGCPhys(PBUSLOGIC pBusLogic)
853	{
854	return pBusLogic->GCPhysAddrMailboxOutgoingBase + (pBusLogic->uMailboxOutgoingPositionCurrent * sizeof(Mailbox));
855	}
856
857	/**
858	* Initialize local RAM of host adapter with default values.
859	*
860	* @returns nothing.
861	* @param pBusLogic.
862	*/
863	static void buslogicInitializeLocalRam(PBUSLOGIC pBusLogic)
864	{
865	/*
866	* These values are mostly from what I think is right
867	* looking at the dmesg output from a Linux guest inside
868	* a VMware server VM.
869	*
870	* So they don't have to be right :)
871	*/
872	memset(pBusLogic->LocalRam.u8View, 0, sizeof(HostAdapterLocalRam));
873	pBusLogic->LocalRam.structured.autoSCSIData.fLevelSensitiveInterrupt = true;
874	pBusLogic->LocalRam.structured.autoSCSIData.fParityCheckingEnabled = true;
875	pBusLogic->LocalRam.structured.autoSCSIData.fExtendedTranslation = true; /* Same as in geometry register. */
876	pBusLogic->LocalRam.structured.autoSCSIData.u16DeviceEnabledMask = ~0; /* All enabled. Maybe mask out non present devices? */
877	pBusLogic->LocalRam.structured.autoSCSIData.u16WidePermittedMask = ~0;
878	pBusLogic->LocalRam.structured.autoSCSIData.u16FastPermittedMask = ~0;
879	pBusLogic->LocalRam.structured.autoSCSIData.u16SynchronousPermittedMask = ~0;
880	pBusLogic->LocalRam.structured.autoSCSIData.u16DisconnectPermittedMask = ~0;
881	pBusLogic->LocalRam.structured.autoSCSIData.fStrictRoundRobinMode = pBusLogic->fStrictRoundRobinMode;
882	pBusLogic->LocalRam.structured.autoSCSIData.u16UltraPermittedMask = ~0;
883	/* @todo calculate checksum? */
884	}
885
886	/**
887	* Do a hardware reset of the buslogic adapter.
888	*
889	* @returns VBox status code.
890	* @param pBusLogic Pointer to the BusLogic device instance.
891	*/
892	static int buslogicHwReset(PBUSLOGIC pBusLogic)
893	{
894	LogFlowFunc(("pBusLogic=%#p\n", pBusLogic));
895
896	/* Reset registers to default value. */
897	pBusLogic->regStatus = BUSLOGIC_REGISTER_STATUS_HOST_ADAPTER_READY \| BUSLOGIC_REGISTER_STATUS_INITIALIZATION_REQUIRED;
898	pBusLogic->regInterrupt = 0;
899	pBusLogic->uPendingIntr = 0;
900	pBusLogic->regGeometry = BUSLOGIC_REGISTER_GEOMETRY_EXTENTED_TRANSLATION_ENABLED;
901	pBusLogic->uOperationCode = 0xff; /* No command executing. */
902	pBusLogic->iParameter = 0;
903	pBusLogic->cbCommandParametersLeft = 0;
904	pBusLogic->fIRQEnabled = true;
905	pBusLogic->fISAEnabled = true;
906	pBusLogic->uMailboxOutgoingPositionCurrent = 0;
907	pBusLogic->uMailboxIncomingPositionCurrent = 0;
908
909	buslogicInitializeLocalRam(pBusLogic);
910	vboxscsiInitialize(&pBusLogic->VBoxSCSI);
911
912	return VINF_SUCCESS;
913	}
914	#endif
915
916	/**
917	* Resets the command state machine for the next command and notifies the guest.
918	*
919	* @returns nothing.
920	* @param pBusLogic Pointer to the BusLogic device instance
921	* @param fSuppressIrq Flag to suppress IRQ generation regardless of current state
922	*/
923	static void buslogicCommandComplete(PBUSLOGIC pBusLogic, bool fSuppressIrq)
924	{
925	LogFlowFunc(("pBusLogic=%#p\n", pBusLogic));
926
927	pBusLogic->fUseLocalRam = false;
928	pBusLogic->regStatus \|= BUSLOGIC_REGISTER_STATUS_HOST_ADAPTER_READY;
929	pBusLogic->iReply = 0;
930
931	/* Modify I/O address does not generate an interrupt. */
932	if (pBusLogic->uOperationCode != BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND)
933	{
934	/* Notify that the command is complete. */
935	pBusLogic->regStatus &= ~BUSLOGIC_REGISTER_STATUS_DATA_IN_REGISTER_READY;
936	buslogicSetInterrupt(pBusLogic, fSuppressIrq, BUSLOGIC_REGISTER_INTERRUPT_COMMAND_COMPLETE);
937	}
938
939	pBusLogic->uOperationCode = 0xff;
940	pBusLogic->iParameter = 0;
941	}
942
943	#if defined(IN_RING3)
944	/**
945	* Initiates a hard reset which was issued from the guest.
946	*
947	* @returns nothing
948	* @param pBusLogic Pointer to the BusLogic device instance.
949	*/
950	static void buslogicIntiateHardReset(PBUSLOGIC pBusLogic)
951	{
952	LogFlowFunc(("pBusLogic=%#p\n", pBusLogic));
953
954	/* Remember when the guest initiated a reset. */
955	pBusLogic->u64ResetTime = PDMDevHlpTMTimeVirtGetNano(pBusLogic->CTX_SUFF(pDevIns));
956
957	buslogicHwReset(pBusLogic);
958
959	/* We set the diagnostic active in the status register. */
960	pBusLogic->regStatus \|= BUSLOGIC_REGISTER_STATUS_DIAGNOSTIC_ACTIVE;
961	}
962
963	/**
964	* Send a mailbox with set status codes to the guest.
965	*
966	* @returns nothing.
967	* @param pBusLogic Pointer to the BusLogic device instance.
968	* @param pTaskState Pointer to the task state with the mailbox to send.
969	* @param uHostAdapterStatus The host adapter status code to set.
970	* @param uDeviceStatus The target device status to set.
971	* @param uMailboxCompletionCode Completion status code to set in the mailbox.
972	*/
973	static void buslogicSendIncomingMailbox(PBUSLOGIC pBusLogic, PBUSLOGICTASKSTATE pTaskState,
974	uint8_t uHostAdapterStatus, uint8_t uDeviceStatus,
975	uint8_t uMailboxCompletionCode)
976	{
977	pTaskState->MailboxGuest.u.in.uHostAdapterStatus = uHostAdapterStatus;
978	pTaskState->MailboxGuest.u.in.uTargetDeviceStatus = uDeviceStatus;
979	pTaskState->MailboxGuest.u.in.uCompletionCode = uMailboxCompletionCode;
980
981	int rc = PDMCritSectEnter(&pBusLogic->CritSectIntr, VINF_SUCCESS);
982	AssertRC(rc);
983	RTGCPHYS GCPhysAddrMailboxIncoming = pBusLogic->GCPhysAddrMailboxIncomingBase + (pBusLogic->uMailboxIncomingPositionCurrent * sizeof(Mailbox));
984	RTGCPHYS GCPhysAddrCCB = (RTGCPHYS)pTaskState->MailboxGuest.u32PhysAddrCCB;
985
986	LogFlowFunc(("Completing CCB %RGp\n", GCPhysAddrCCB));
987
988	/* Update CCB. */
989	pTaskState->CommandControlBlockGuest.uHostAdapterStatus = uHostAdapterStatus;
990	pTaskState->CommandControlBlockGuest.uDeviceStatus = uDeviceStatus;
991	/* @todo: this is wrong - writing too much! */
992	PDMDevHlpPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrCCB, &pTaskState->CommandControlBlockGuest, sizeof(CommandControlBlock));
993
994	#ifdef RT_STRICT
995	Mailbox Tmp;
996	PDMDevHlpPhysRead(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxIncoming, &Tmp, sizeof(Mailbox));
997	Assert(Tmp.u.in.uCompletionCode == BUSLOGIC_MAILBOX_INCOMING_COMPLETION_FREE);
998	#endif
999
1000	/* Update mailbox. */
1001	PDMDevHlpPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxIncoming, &pTaskState->MailboxGuest, sizeof(Mailbox));
1002
1003	/* Advance to next mailbox position. */
1004	pBusLogic->uMailboxIncomingPositionCurrent++;
1005	if (pBusLogic->uMailboxIncomingPositionCurrent >= pBusLogic->cMailbox)
1006	pBusLogic->uMailboxIncomingPositionCurrent = 0;
1007
1008	#ifdef LOG_ENABLED
1009	ASMAtomicIncU32(&pBusLogic->cInMailboxesReady);
1010	#endif
1011
1012	buslogicSetInterrupt(pBusLogic, false, BUSLOGIC_REGISTER_INTERRUPT_INCOMING_MAILBOX_LOADED);
1013
1014	PDMCritSectLeave(&pBusLogic->CritSectIntr);
1015	}
1016
1017	#if defined(DEBUG)
1018	/**
1019	* Dumps the content of a mailbox for debugging purposes.
1020	*
1021	* @return nothing
1022	* @param pMailbox The mailbox to dump.
1023	* @param fOutgoing true if dumping the outgoing state.
1024	* false if dumping the incoming state.
1025	*/
1026	static void buslogicDumpMailboxInfo(PMailbox pMailbox, bool fOutgoing)
1027	{
1028	Log(("%s: Dump for %s mailbox:\n", __FUNCTION__, fOutgoing ? "outgoing" : "incoming"));
1029	Log(("%s: u32PhysAddrCCB=%#x\n", __FUNCTION__, pMailbox->u32PhysAddrCCB));
1030	if (fOutgoing)
1031	{
1032	Log(("%s: uActionCode=%u\n", __FUNCTION__, pMailbox->u.out.uActionCode));
1033	}
1034	else
1035	{
1036	Log(("%s: uHostAdapterStatus=%u\n", __FUNCTION__, pMailbox->u.in.uHostAdapterStatus));
1037	Log(("%s: uTargetDeviceStatus=%u\n", __FUNCTION__, pMailbox->u.in.uTargetDeviceStatus));
1038	Log(("%s: uCompletionCode=%u\n", __FUNCTION__, pMailbox->u.in.uCompletionCode));
1039	}
1040	}
1041
1042	/**
1043	* Dumps the content of a command control block for debugging purposes.
1044	*
1045	* @returns nothing.
1046	* @param pCCB Pointer to the command control block to dump.
1047	*/
1048	static void buslogicDumpCCBInfo(PCommandControlBlock pCCB)
1049	{
1050	Log(("%s: Dump for Command Control Block:\n", __FUNCTION__));
1051	Log(("%s: uOpCode=%#x\n", __FUNCTION__, pCCB->uOpcode));
1052	Log(("%s: uDataDirection=%u\n", __FUNCTION__, pCCB->uDataDirection));
1053	Log(("%s: fTagQueued=%d\n", __FUNCTION__, pCCB->fTagQueued));
1054	Log(("%s: uQueueTag=%u\n", __FUNCTION__, pCCB->uQueueTag));
1055	Log(("%s: cbCDB=%u\n", __FUNCTION__, pCCB->cbCDB));
1056	Log(("%s: cbSenseData=%u\n", __FUNCTION__, pCCB->cbSenseData));
1057	Log(("%s: cbData=%u\n", __FUNCTION__, pCCB->cbData));
1058	Log(("%s: u32PhysAddrData=%#x\n", __FUNCTION__, pCCB->u32PhysAddrData));
1059	Log(("%s: uHostAdapterStatus=%u\n", __FUNCTION__, pCCB->uHostAdapterStatus));
1060	Log(("%s: uDeviceStatus=%u\n", __FUNCTION__, pCCB->uDeviceStatus));
1061	Log(("%s: uTargetId=%u\n", __FUNCTION__, pCCB->uTargetId));
1062	Log(("%s: uLogicalUnit=%u\n", __FUNCTION__, pCCB->uLogicalUnit));
1063	Log(("%s: fLegacyTagEnable=%u\n", __FUNCTION__, pCCB->fLegacyTagEnable));
1064	Log(("%s: uLegacyQueueTag=%u\n", __FUNCTION__, pCCB->uLegacyQueueTag));
1065	Log(("%s: uCDB[0]=%#x\n", __FUNCTION__, pCCB->aCDB[0]));
1066	for (int i = 1; i < pCCB->cbCDB; i++)
1067	Log(("%s: uCDB[%d]=%u\n", __FUNCTION__, i, pCCB->aCDB[i]));
1068	Log(("%s: u32PhysAddrSenseData=%#x\n", __FUNCTION__, pCCB->u32PhysAddrSenseData));
1069	}
1070	#endif
1071
1072	/**
1073	* Allocate data buffer.
1074	*
1075	* @returns VBox status code.
1076	* @param pTaskState Pointer to the task state.
1077	*/
1078	static int buslogicDataBufferAlloc(PBUSLOGICTASKSTATE pTaskState)
1079	{
1080	PPDMDEVINS pDevIns = pTaskState->CTX_SUFF(pTargetDevice)->CTX_SUFF(pBusLogic)->CTX_SUFF(pDevIns);
1081
1082	if ( (pTaskState->CommandControlBlockGuest.uDataDirection != BUSLOGIC_CCB_DIRECTION_NO_DATA)
1083	&& (pTaskState->CommandControlBlockGuest.cbData > 0))
1084	{
1085	/*
1086	* @todo: Check following assumption and what residual means.
1087	*
1088	* The BusLogic adapter can handle two different data buffer formats.
1089	* The first one is that the data pointer entry in the CCB points to
1090	* the buffer directly. In second mode the data pointer points to a
1091	* scatter gather list which describes the buffer.
1092	*/
1093	if ( (pTaskState->CommandControlBlockGuest.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_SCATTER_GATHER)
1094	\|\| (pTaskState->CommandControlBlockGuest.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_SCATTER_GATHER))
1095	{
1096	uint32_t cScatterGatherGCRead;
1097	uint32_t iScatterGatherEntry;
1098	ScatterGatherEntry aScatterGatherReadGC[32]; /* Number of scatter gather list entries read from guest memory. */
1099	uint32_t cScatterGatherGCLeft = pTaskState->CommandControlBlockGuest.cbData / sizeof(ScatterGatherEntry);
1100	RTGCPHYS GCPhysAddrScatterGatherCurrent = (RTGCPHYS)pTaskState->CommandControlBlockGuest.u32PhysAddrData;
1101	size_t cbDataToTransfer = 0;
1102
1103	/* Count number of bytes to transfer. */
1104	do
1105	{
1106	cScatterGatherGCRead = (cScatterGatherGCLeft < RT_ELEMENTS(aScatterGatherReadGC))
1107	? cScatterGatherGCLeft
1108	: RT_ELEMENTS(aScatterGatherReadGC);
1109	cScatterGatherGCLeft -= cScatterGatherGCRead;
1110
1111	/* Read the SG entries. */
1112	PDMDevHlpPhysRead(pDevIns, GCPhysAddrScatterGatherCurrent, &aScatterGatherReadGC[0],
1113	cScatterGatherGCRead * sizeof(ScatterGatherEntry));
1114
1115	for (iScatterGatherEntry = 0; iScatterGatherEntry < cScatterGatherGCRead; iScatterGatherEntry++)
1116	{
1117	RTGCPHYS GCPhysAddrDataBase;
1118
1119	Log(("%s: iScatterGatherEntry=%u\n", __FUNCTION__, iScatterGatherEntry));
1120
1121	GCPhysAddrDataBase = (RTGCPHYS)aScatterGatherReadGC[iScatterGatherEntry].u32PhysAddrSegmentBase;
1122	cbDataToTransfer += aScatterGatherReadGC[iScatterGatherEntry].cbSegment;
1123
1124	Log(("%s: GCPhysAddrDataBase=%RGp cbDataToTransfer=%u\n",
1125	__FUNCTION__, GCPhysAddrDataBase,
1126	aScatterGatherReadGC[iScatterGatherEntry].cbSegment));
1127	}
1128
1129	/* Set address to the next entries to read. */
1130	GCPhysAddrScatterGatherCurrent += cScatterGatherGCRead * sizeof(ScatterGatherEntry);
1131	} while (cScatterGatherGCLeft > 0);
1132
1133	Log(("%s: cbDataToTransfer=%d\n", __FUNCTION__, cbDataToTransfer));
1134
1135	/* Allocate buffer */
1136	pTaskState->DataSeg.cbSeg = cbDataToTransfer;
1137	pTaskState->DataSeg.pvSeg = RTMemAlloc(pTaskState->DataSeg.cbSeg);
1138	if (!pTaskState->DataSeg.pvSeg)
1139	return VERR_NO_MEMORY;
1140
1141	/* Copy the data if needed */
1142	if (pTaskState->CommandControlBlockGuest.uDataDirection == BUSLOGIC_CCB_DIRECTION_OUT)
1143	{
1144	cScatterGatherGCLeft = pTaskState->CommandControlBlockGuest.cbData / sizeof(ScatterGatherEntry);
1145	GCPhysAddrScatterGatherCurrent = (RTGCPHYS)pTaskState->CommandControlBlockGuest.u32PhysAddrData;
1146	uint8_t pbData = (uint8_t )pTaskState->DataSeg.pvSeg;
1147
1148	do
1149	{
1150	cScatterGatherGCRead = (cScatterGatherGCLeft < RT_ELEMENTS(aScatterGatherReadGC))
1151	? cScatterGatherGCLeft
1152	: RT_ELEMENTS(aScatterGatherReadGC);
1153	cScatterGatherGCLeft -= cScatterGatherGCRead;
1154
1155	/* Read the SG entries. */
1156	PDMDevHlpPhysRead(pDevIns, GCPhysAddrScatterGatherCurrent, &aScatterGatherReadGC[0],
1157	cScatterGatherGCRead * sizeof(ScatterGatherEntry));
1158
1159	for (iScatterGatherEntry = 0; iScatterGatherEntry < cScatterGatherGCRead; iScatterGatherEntry++)
1160	{
1161	RTGCPHYS GCPhysAddrDataBase;
1162
1163	Log(("%s: iScatterGatherEntry=%u\n", __FUNCTION__, iScatterGatherEntry));
1164
1165	GCPhysAddrDataBase = (RTGCPHYS)aScatterGatherReadGC[iScatterGatherEntry].u32PhysAddrSegmentBase;
1166	cbDataToTransfer = aScatterGatherReadGC[iScatterGatherEntry].cbSegment;
1167
1168	Log(("%s: GCPhysAddrDataBase=%RGp cbDataToTransfer=%u\n", __FUNCTION__, GCPhysAddrDataBase, cbDataToTransfer));
1169
1170	PDMDevHlpPhysRead(pDevIns, GCPhysAddrDataBase, pbData, cbDataToTransfer);
1171	pbData += cbDataToTransfer;
1172	}
1173
1174	/* Set address to the next entries to read. */
1175	GCPhysAddrScatterGatherCurrent += cScatterGatherGCRead * sizeof(ScatterGatherEntry);
1176	} while (cScatterGatherGCLeft > 0);
1177	}
1178
1179	}
1180	else if ( pTaskState->CommandControlBlockGuest.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB
1181	\|\| pTaskState->CommandControlBlockGuest.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_DATA_LENGTH)
1182	{
1183	/* The buffer is not scattered. */
1184	RTGCPHYS GCPhysAddrDataBase = (RTGCPHYS)pTaskState->CommandControlBlockGuest.u32PhysAddrData;
1185
1186	AssertMsg(GCPhysAddrDataBase != 0, ("Physical address is 0\n"));
1187
1188	pTaskState->DataSeg.cbSeg = pTaskState->CommandControlBlockGuest.cbData;
1189	pTaskState->DataSeg.pvSeg = RTMemAlloc(pTaskState->DataSeg.cbSeg);
1190	if (!pTaskState->DataSeg.pvSeg)
1191	return VERR_NO_MEMORY;
1192
1193	Log(("Non scattered buffer:\n"));
1194	Log(("u32PhysAddrData=%#x\n", pTaskState->CommandControlBlockGuest.u32PhysAddrData));
1195	Log(("cbData=%u\n", pTaskState->CommandControlBlockGuest.cbData));
1196	Log(("GCPhysAddrDataBase=0x%RGp\n", GCPhysAddrDataBase));
1197
1198	/* Copy the data into the buffer. */
1199	PDMDevHlpPhysRead(pDevIns, GCPhysAddrDataBase, pTaskState->DataSeg.pvSeg, pTaskState->DataSeg.cbSeg);
1200	}
1201	}
1202
1203	return VINF_SUCCESS;
1204	}
1205
1206	/**
1207	* Free allocated resources used for the scatter gather list.
1208	*
1209	* @returns nothing.
1210	* @param pTaskState Pointer to the task state.
1211	*/
1212	static void buslogicDataBufferFree(PBUSLOGICTASKSTATE pTaskState)
1213	{
1214	PPDMDEVINS pDevIns = pTaskState->CTX_SUFF(pTargetDevice)->CTX_SUFF(pBusLogic)->CTX_SUFF(pDevIns);
1215
1216	if ( (pTaskState->CommandControlBlockGuest.cbData > 0)
1217	&& ( (pTaskState->CommandControlBlockGuest.uDataDirection == BUSLOGIC_CCB_DIRECTION_IN)
1218	\|\| (pTaskState->CommandControlBlockGuest.uDataDirection == BUSLOGIC_CCB_DIRECTION_UNKNOWN)))
1219	{
1220	if ( (pTaskState->CommandControlBlockGuest.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_SCATTER_GATHER)
1221	\|\| (pTaskState->CommandControlBlockGuest.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_SCATTER_GATHER))
1222	{
1223	uint32_t cScatterGatherGCRead;
1224	uint32_t iScatterGatherEntry;
1225	ScatterGatherEntry aScatterGatherReadGC[32]; /* Number of scatter gather list entries read from guest memory. */
1226	uint32_t cScatterGatherGCLeft = pTaskState->CommandControlBlockGuest.cbData / sizeof(ScatterGatherEntry);
1227	RTGCPHYS GCPhysAddrScatterGatherCurrent = (RTGCPHYS)pTaskState->CommandControlBlockGuest.u32PhysAddrData;
1228	uint8_t pbData = (uint8_t )pTaskState->DataSeg.pvSeg;
1229
1230	do
1231	{
1232	cScatterGatherGCRead = (cScatterGatherGCLeft < RT_ELEMENTS(aScatterGatherReadGC))
1233	? cScatterGatherGCLeft
1234	: RT_ELEMENTS(aScatterGatherReadGC);
1235	cScatterGatherGCLeft -= cScatterGatherGCRead;
1236
1237	/* Read the SG entries. */
1238	PDMDevHlpPhysRead(pDevIns, GCPhysAddrScatterGatherCurrent, &aScatterGatherReadGC[0],
1239	cScatterGatherGCRead * sizeof(ScatterGatherEntry));
1240
1241	for (iScatterGatherEntry = 0; iScatterGatherEntry < cScatterGatherGCRead; iScatterGatherEntry++)
1242	{
1243	RTGCPHYS GCPhysAddrDataBase;
1244	size_t cbDataToTransfer;
1245
1246	Log(("%s: iScatterGatherEntry=%u\n", __FUNCTION__, iScatterGatherEntry));
1247
1248	GCPhysAddrDataBase = (RTGCPHYS)aScatterGatherReadGC[iScatterGatherEntry].u32PhysAddrSegmentBase;
1249	cbDataToTransfer = aScatterGatherReadGC[iScatterGatherEntry].cbSegment;
1250
1251	Log(("%s: GCPhysAddrDataBase=%RGp cbDataToTransfer=%u\n", __FUNCTION__, GCPhysAddrDataBase, cbDataToTransfer));
1252
1253	PDMDevHlpPhysWrite(pDevIns, GCPhysAddrDataBase, pbData, cbDataToTransfer);
1254	pbData += cbDataToTransfer;
1255	}
1256
1257	/* Set address to the next entries to read. */
1258	GCPhysAddrScatterGatherCurrent += cScatterGatherGCRead * sizeof(ScatterGatherEntry);
1259	} while (cScatterGatherGCLeft > 0);
1260
1261	}
1262	else if ( pTaskState->CommandControlBlockGuest.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB
1263	\|\| pTaskState->CommandControlBlockGuest.uOpcode == BUSLOGIC_CCB_OPCODE_INITIATOR_CCB_RESIDUAL_DATA_LENGTH)
1264	{
1265	/* The buffer is not scattered. */
1266	RTGCPHYS GCPhysAddrDataBase = (RTGCPHYS)pTaskState->CommandControlBlockGuest.u32PhysAddrData;
1267
1268	AssertMsg(GCPhysAddrDataBase != 0, ("Physical address is 0\n"));
1269
1270	Log(("Non scattered buffer:\n"));
1271	Log(("u32PhysAddrData=%#x\n", pTaskState->CommandControlBlockGuest.u32PhysAddrData));
1272	Log(("cbData=%u\n", pTaskState->CommandControlBlockGuest.cbData));
1273	Log(("GCPhysAddrDataBase=0x%RGp\n", GCPhysAddrDataBase));
1274
1275	/* Copy the data into the guest memory. */
1276	PDMDevHlpPhysWrite(pDevIns, GCPhysAddrDataBase, pTaskState->DataSeg.pvSeg, pTaskState->DataSeg.cbSeg);
1277	}
1278	}
1279
1280	RTMemFree(pTaskState->DataSeg.pvSeg);
1281	pTaskState->DataSeg.pvSeg = NULL;
1282	pTaskState->DataSeg.cbSeg = 0;
1283	}
1284
1285	/**
1286	* Free the sense buffer.
1287	*
1288	* @returns nothing.
1289	* @param pTaskState Pointer to the task state.
1290	* @param fCopy If sense data should be copied to guest memory.
1291	*/
1292	static void buslogicSenseBufferFree(PBUSLOGICTASKSTATE pTaskState, bool fCopy)
1293	{
1294	PPDMDEVINS pDevIns = pTaskState->CTX_SUFF(pTargetDevice)->CTX_SUFF(pBusLogic)->CTX_SUFF(pDevIns);
1295	RTGCPHYS GCPhysAddrSenseBuffer = (RTGCPHYS)pTaskState->CommandControlBlockGuest.u32PhysAddrSenseData;
1296	uint32_t cbSenseBuffer = pTaskState->CommandControlBlockGuest.cbSenseData;
1297
1298	/* Copy into guest memory. */
1299	if (fCopy)
1300	PDMDevHlpPhysWrite(pDevIns, GCPhysAddrSenseBuffer, pTaskState->pbSenseBuffer, cbSenseBuffer);
1301
1302	RTMemFree(pTaskState->pbSenseBuffer);
1303	pTaskState->pbSenseBuffer = NULL;
1304	}
1305
1306	/**
1307	* Alloc the sense buffer.
1308	*
1309	* @returns VBox status code.
1310	* @param pTaskState Pointer to the task state.
1311	* @note Current assumption is that the sense buffer is not scattered and does not cross a page boundary.
1312	*/
1313	static int buslogicSenseBufferAlloc(PBUSLOGICTASKSTATE pTaskState)
1314	{
1315	PPDMDEVINS pDevIns = pTaskState->CTX_SUFF(pTargetDevice)->CTX_SUFF(pBusLogic)->CTX_SUFF(pDevIns);
1316	uint32_t cbSenseBuffer = pTaskState->CommandControlBlockGuest.cbSenseData;
1317
1318	pTaskState->pbSenseBuffer = (uint8_t *)RTMemAllocZ(cbSenseBuffer);
1319	if (!pTaskState->pbSenseBuffer)
1320	return VERR_NO_MEMORY;
1321
1322	return VINF_SUCCESS;
1323	}
1324	#endif /* IN_RING3 */
1325
1326	/**
1327	* Parses the command buffer and executes it.
1328	*
1329	* @returns VBox status code.
1330	* @param pBusLogic Pointer to the BusLogic device instance.
1331	*/
1332	static int buslogicProcessCommand(PBUSLOGIC pBusLogic)
1333	{
1334	int rc = VINF_SUCCESS;
1335	bool fSuppressIrq = false;
1336
1337	LogFlowFunc(("pBusLogic=%#p\n", pBusLogic));
1338	AssertMsg(pBusLogic->uOperationCode != 0xff, ("There is no command to execute\n"));
1339
1340	switch (pBusLogic->uOperationCode)
1341	{
1342	case BUSLOGICCOMMAND_TEST_CMDC_INTERRUPT:
1343	/* Valid command, no reply. */
1344	pBusLogic->cbReplyParametersLeft = 0;
1345	break;
1346	case BUSLOGICCOMMAND_INQUIRE_PCI_HOST_ADAPTER_INFORMATION:
1347	{
1348	PReplyInquirePCIHostAdapterInformation pReply = (PReplyInquirePCIHostAdapterInformation)pBusLogic->aReplyBuffer;
1349	memset(pReply, 0, sizeof(ReplyInquirePCIHostAdapterInformation));
1350
1351	/* It seems VMware does not provide valid information here too, lets do the same :) */
1352	pReply->InformationIsValid = 0;
1353	pReply->IsaIOPort = 0xff; /* Make it invalid. */
1354	pReply->IRQ = PCIDevGetInterruptLine(&pBusLogic->dev);
1355	pBusLogic->cbReplyParametersLeft = sizeof(ReplyInquirePCIHostAdapterInformation);
1356	break;
1357	}
1358	case BUSLOGICCOMMAND_MODIFY_IO_ADDRESS:
1359	{
1360	pBusLogic->cbReplyParametersLeft = 0;
1361	if (pBusLogic->aCommandBuffer[0] == 0x06)
1362	{
1363	Log(("Disabling ISA I/O ports.\n"));
1364	pBusLogic->fISAEnabled = false;
1365	}
1366	fSuppressIrq = true;
1367	break;
1368	}
1369	case BUSLOGICCOMMAND_INQUIRE_BOARD_ID:
1370	{
1371	/* The special option byte is important: If it is '0' or 'B', Windows NT drivers
1372	* for Adaptec AHA-154x may claim the adapter. The BusLogic drivers will claim
1373	* the adapter only when the byte is not '0' or 'B'.
1374	*/
1375	pBusLogic->aReplyBuffer[0] = 'A'; /* Firmware option bytes */
1376	pBusLogic->aReplyBuffer[1] = 'A'; /* Special option byte */
1377
1378	/* We report version 5.07B. This reply will provide the first two digits. */
1379	pBusLogic->aReplyBuffer[2] = '5'; /* Major version 5 */
1380	pBusLogic->aReplyBuffer[3] = '0'; /* Minor version 0 */
1381	pBusLogic->cbReplyParametersLeft = 4; /* Reply is 4 bytes long */
1382	break;
1383	}
1384	case BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_3RD_LETTER:
1385	{
1386	pBusLogic->aReplyBuffer[0] = '7';
1387	pBusLogic->cbReplyParametersLeft = 1;
1388	break;
1389	}
1390	case BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_LETTER:
1391	{
1392	pBusLogic->aReplyBuffer[0] = 'B';
1393	pBusLogic->cbReplyParametersLeft = 1;
1394	break;
1395	}
1396	case BUSLOGICCOMMAND_SET_ADAPTER_OPTIONS:
1397	/* The parameter list length is determined by the first byte of the command buffer. */
1398	if (pBusLogic->iParameter == 1)
1399	{
1400	/* First pass - set the number of following parameter bytes. */
1401	pBusLogic->cbCommandParametersLeft = pBusLogic->aCommandBuffer[0];
1402	Log(("Set HA options: %u bytes follow\n", pBusLogic->aCommandBuffer[0]));
1403	}
1404	else
1405	{
1406	/* Second pass - process received data. */
1407	Log(("Set HA options: received %u bytes\n", pBusLogic->aCommandBuffer[0]));
1408	/* We ignore the data - it only concerns the SCSI hardware protocol. */
1409	}
1410	pBusLogic->cbReplyParametersLeft = 0;
1411	break;
1412
1413	case BUSLOGICCOMMAND_INQUIRE_HOST_ADAPTER_MODEL_NUMBER:
1414	{
1415	/* The reply length is set by the guest and is found in the first byte of the command buffer. */
1416	pBusLogic->cbReplyParametersLeft = pBusLogic->aCommandBuffer[0];
1417	memset(pBusLogic->aReplyBuffer, ' ', pBusLogic->cbReplyParametersLeft);
1418	const char aModelName[] = "958";
1419	int cCharsToTransfer = (pBusLogic->cbReplyParametersLeft <= (sizeof(aModelName) - 1))
1420	? pBusLogic->cbReplyParametersLeft
1421	: sizeof(aModelName) - 1;
1422
1423	for (int i = 0; i < cCharsToTransfer; i++)
1424	pBusLogic->aReplyBuffer[i] = aModelName[i];
1425
1426	break;
1427	}
1428	case BUSLOGICCOMMAND_INQUIRE_CONFIGURATION:
1429	{
1430	uint8_t uPciIrq = PCIDevGetInterruptLine(&pBusLogic->dev);
1431
1432	pBusLogic->cbReplyParametersLeft = sizeof(ReplyInquireConfiguration);
1433	PReplyInquireConfiguration pReply = (PReplyInquireConfiguration)pBusLogic->aReplyBuffer;
1434	memset(pReply, 0, sizeof(ReplyInquireConfiguration));
1435
1436	pReply->uHostAdapterId = 7; /* The controller has always 7 as ID. */
1437	//@todo: What should the DMA channel be?
1438	pReply->fDmaChannel6 = 1;
1439	/* The IRQ is not necessarily representable in this structure. */
1440	switch (uPciIrq) {
1441	case 9: pReply->fIrqChannel9 = 1; break;
1442	case 10: pReply->fIrqChannel10 = 1; break;
1443	case 11: pReply->fIrqChannel11 = 1; break;
1444	case 12: pReply->fIrqChannel12 = 1; break;
1445	case 14: pReply->fIrqChannel14 = 1; break;
1446	case 15: pReply->fIrqChannel15 = 1; break;
1447	default:
1448	Log(("Inquire configuration: PCI IRQ %d cannot be represented\n", uPciIrq));
1449	break;
1450	}
1451	break;
1452	}
1453	case BUSLOGICCOMMAND_INQUIRE_EXTENDED_SETUP_INFORMATION:
1454	{
1455	/* The reply length is set by the guest and is found in the first byte of the command buffer. */
1456	pBusLogic->cbReplyParametersLeft = pBusLogic->aCommandBuffer[0];
1457	PReplyInquireExtendedSetupInformation pReply = (PReplyInquireExtendedSetupInformation)pBusLogic->aReplyBuffer;
1458	memset(pReply, 0, sizeof(ReplyInquireExtendedSetupInformation));
1459
1460	//@todo: should this reflect the RAM contents (AutoSCSIRam)?
1461	pReply->uBusType = 'E'; /* EISA style */
1462	pReply->u16ScatterGatherLimit = 8192;
1463	pReply->cMailbox = pBusLogic->cMailbox;
1464	pReply->uMailboxAddressBase = (uint32_t)pBusLogic->GCPhysAddrMailboxOutgoingBase;
1465	pReply->fLevelSensitiveInterrupt = true;
1466	pReply->fHostWideSCSI = true;
1467	pReply->fHostUltraSCSI = true;
1468	memcpy(pReply->aFirmwareRevision, "07B", sizeof(pReply->aFirmwareRevision));
1469
1470	break;
1471	}
1472	case BUSLOGICCOMMAND_INQUIRE_SETUP_INFORMATION:
1473	{
1474	/* The reply length is set by the guest and is found in the first byte of the command buffer. */
1475	pBusLogic->cbReplyParametersLeft = pBusLogic->aCommandBuffer[0];
1476	PReplyInquireSetupInformation pReply = (PReplyInquireSetupInformation)pBusLogic->aReplyBuffer;
1477	memset(pReply, 0, sizeof(ReplyInquireSetupInformation));
1478	break;
1479	}
1480	case BUSLOGICCOMMAND_FETCH_HOST_ADAPTER_LOCAL_RAM:
1481	{
1482	/*
1483	* First element in the command buffer contains start offset to read from
1484	* and second one the number of bytes to read.
1485	*/
1486	uint8_t uOffset = pBusLogic->aCommandBuffer[0];
1487	pBusLogic->cbReplyParametersLeft = pBusLogic->aCommandBuffer[1];
1488
1489	pBusLogic->fUseLocalRam = true;
1490	pBusLogic->iReply = uOffset;
1491	break;
1492	}
1493	case BUSLOGICCOMMAND_INITIALIZE_EXTENDED_MAILBOX:
1494	{
1495	PRequestInitializeExtendedMailbox pRequest = (PRequestInitializeExtendedMailbox)pBusLogic->aCommandBuffer;
1496
1497	pBusLogic->cMailbox = pRequest->cMailbox;
1498	pBusLogic->GCPhysAddrMailboxOutgoingBase = (RTGCPHYS)pRequest->uMailboxBaseAddress;
1499	/* The area for incoming mailboxes is right after the last entry of outgoing mailboxes. */
1500	pBusLogic->GCPhysAddrMailboxIncomingBase = (RTGCPHYS)pRequest->uMailboxBaseAddress + (pBusLogic->cMailbox * sizeof(Mailbox));
1501
1502	Log(("GCPhysAddrMailboxOutgoingBase=%RGp\n", pBusLogic->GCPhysAddrMailboxOutgoingBase));
1503	Log(("GCPhysAddrMailboxIncomingBase=%RGp\n", pBusLogic->GCPhysAddrMailboxIncomingBase));
1504	Log(("cMailboxes=%u (32-bit mode)\n", pBusLogic->cMailbox));
1505	LogRel(("Initialized 32-bit mailbox, %d entries at %08x\n", pRequest->cMailbox, pRequest->uMailboxBaseAddress));
1506
1507	pBusLogic->regStatus &= ~BUSLOGIC_REGISTER_STATUS_INITIALIZATION_REQUIRED;
1508	pBusLogic->cbReplyParametersLeft = 0;
1509	break;
1510	}
1511	case BUSLOGICCOMMAND_ENABLE_STRICT_ROUND_ROBIN_MODE:
1512	{
1513	if (pBusLogic->aCommandBuffer[0] == 0)
1514	pBusLogic->fStrictRoundRobinMode = false;
1515	else if (pBusLogic->aCommandBuffer[0] == 1)
1516	pBusLogic->fStrictRoundRobinMode = true;
1517	else
1518	AssertMsgFailed(("Invalid round robin mode %d\n", pBusLogic->aCommandBuffer[0]));
1519
1520	pBusLogic->cbReplyParametersLeft = 0;
1521	break;
1522	}
1523	case BUSLOGICCOMMAND_SET_CCB_FORMAT:
1524	{
1525	if (pBusLogic->aCommandBuffer[0] == 0)
1526	pBusLogic->fExtendedLunCCBFormat = false;
1527	else if (pBusLogic->aCommandBuffer[0] == 1)
1528	pBusLogic->fExtendedLunCCBFormat = true;
1529	else
1530	AssertMsgFailed(("Invalid CCB format %d\n", pBusLogic->aCommandBuffer[0]));
1531
1532	pBusLogic->cbReplyParametersLeft = 0;
1533	break;
1534	}
1535	case BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_0_TO_7:
1536	/* This is supposed to send TEST UNIT READY to each target/LUN.
1537	* We cheat and skip that, since we already know what's attached
1538	*/
1539	memset(pBusLogic->aReplyBuffer, 0, 8);
1540	for (int i = 0; i < 8; ++i)
1541	{
1542	if (pBusLogic->aDeviceStates[i].fPresent)
1543	pBusLogic->aReplyBuffer[i] = 1;
1544	}
1545	pBusLogic->aReplyBuffer[7] = 0; /* HA hardcoded at ID 7. */
1546	pBusLogic->cbReplyParametersLeft = 8;
1547	break;
1548	case BUSLOGICCOMMAND_INQUIRE_TARGET_DEVICES:
1549	{
1550	/* Each bit which is set in the 16bit wide variable means a present device. */
1551	uint16_t u16TargetsPresentMask = 0;
1552
1553	for (uint8_t i = 0; i < RT_ELEMENTS(pBusLogic->aDeviceStates); i++)
1554	{
1555	if (pBusLogic->aDeviceStates[i].fPresent)
1556	u16TargetsPresentMask \|= (1 << i);
1557	}
1558	pBusLogic->aReplyBuffer[0] = (uint8_t)u16TargetsPresentMask;
1559	pBusLogic->aReplyBuffer[1] = (uint8_t)(u16TargetsPresentMask >> 8);
1560	pBusLogic->cbReplyParametersLeft = 2;
1561	break;
1562	}
1563	case BUSLOGICCOMMAND_INQUIRE_SYNCHRONOUS_PERIOD:
1564	{
1565	pBusLogic->cbReplyParametersLeft = pBusLogic->aCommandBuffer[0];
1566
1567	for (uint8_t i = 0; i < pBusLogic->cbReplyParametersLeft; i++)
1568	pBusLogic->aReplyBuffer[i] = 0; /* @todo Figure if we need something other here. It's not needed for the linux driver */
1569
1570	break;
1571	}
1572	case BUSLOGICCOMMAND_DISABLE_HOST_ADAPTER_INTERRUPT:
1573	{
1574	if (pBusLogic->aCommandBuffer[0] == 0)
1575	pBusLogic->fIRQEnabled = false;
1576	else
1577	pBusLogic->fIRQEnabled = true;
1578	/* No interrupt signaled regardless of enable/disable. */
1579	fSuppressIrq = true;
1580	break;
1581	}
1582	case BUSLOGICCOMMAND_ECHO_COMMAND_DATA:
1583	{
1584	pBusLogic->aReplyBuffer[0] = pBusLogic->aCommandBuffer[0];
1585	pBusLogic->cbReplyParametersLeft = 1;
1586	break;
1587	}
1588	case BUSLOGICCOMMAND_SET_PREEMPT_TIME_ON_BUS:
1589	{
1590	pBusLogic->cbReplyParametersLeft = 0;
1591	pBusLogic->LocalRam.structured.autoSCSIData.uBusOnDelay = pBusLogic->aCommandBuffer[0];
1592	Log(("Bus-on time: %d\n", pBusLogic->aCommandBuffer[0]));
1593	break;
1594	}
1595	case BUSLOGICCOMMAND_SET_TIME_OFF_BUS:
1596	{
1597	pBusLogic->cbReplyParametersLeft = 0;
1598	pBusLogic->LocalRam.structured.autoSCSIData.uBusOffDelay = pBusLogic->aCommandBuffer[0];
1599	Log(("Bus-off time: %d\n", pBusLogic->aCommandBuffer[0]));
1600	break;
1601	}
1602	default:
1603	AssertMsgFailed(("Invalid command %#x\n", pBusLogic->uOperationCode));
1604	case BUSLOGICCOMMAND_EXT_BIOS_INFO:
1605	case BUSLOGICCOMMAND_UNLOCK_MAILBOX:
1606	/* Commands valid for Adaptec 154xC which we don't handle since
1607	* we pretend being 154xB compatible. Just mark the command as invalid.
1608	*/
1609	Log(("Command %#x not valid for this adapter\n", pBusLogic->uOperationCode));
1610	pBusLogic->cbReplyParametersLeft = 0;
1611	pBusLogic->regStatus \|= BUSLOGIC_REGISTER_STATUS_COMMAND_INVALID;
1612	break;
1613	case BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND: /* Should be handled already. */
1614	AssertMsgFailed(("Invalid mailbox execute state!\n"));
1615	}
1616
1617	Log(("uOperationCode=%#x, cbReplyParametersLeft=%d\n", pBusLogic->uOperationCode, pBusLogic->cbReplyParametersLeft));
1618
1619	/* Set the data in ready bit in the status register in case the command has a reply. */
1620	if (pBusLogic->cbReplyParametersLeft)
1621	pBusLogic->regStatus \|= BUSLOGIC_REGISTER_STATUS_DATA_IN_REGISTER_READY;
1622	else if (!pBusLogic->cbCommandParametersLeft)
1623	buslogicCommandComplete(pBusLogic, fSuppressIrq);
1624
1625	return rc;
1626	}
1627
1628	/**
1629	* Read a register from the BusLogic adapter.
1630	*
1631	* @returns VBox status code.
1632	* @param pBusLogic Pointer to the BusLogic instance data.
1633	* @param iRegister The index of the register to read.
1634	* @param pu32 Where to store the register content.
1635	*/
1636	static int buslogicRegisterRead(PBUSLOGIC pBusLogic, unsigned iRegister, uint32_t *pu32)
1637	{
1638	int rc = VINF_SUCCESS;
1639
1640	switch (iRegister)
1641	{
1642	case BUSLOGIC_REGISTER_STATUS:
1643	{
1644	*pu32 = pBusLogic->regStatus;
1645
1646	/* If the diagnostic active bit is set, we are in a guest-initiated
1647	* hard or soft reset. If the guest reads the status register and
1648	* waits for the host adapter ready bit to be set, we terminate the
1649	* reset right away. However, guests may also expect the reset
1650	* condition to clear automatically after a period of time.
1651	*/
1652	if (pBusLogic->regStatus & BUSLOGIC_REGISTER_STATUS_DIAGNOSTIC_ACTIVE)
1653	{
1654	uint64_t u64AccessTime = PDMDevHlpTMTimeVirtGetNano(pBusLogic->CTX_SUFF(pDevIns));
1655
1656	pBusLogic->regStatus &= ~BUSLOGIC_REGISTER_STATUS_DIAGNOSTIC_ACTIVE;
1657	pBusLogic->regStatus \|= BUSLOGIC_REGISTER_STATUS_HOST_ADAPTER_READY;
1658	if (u64AccessTime - pBusLogic->u64ResetTime > BUSLOGIC_RESET_DURATION_NS)
1659	{
1660	/* Let the guest see the ready condition right away. */
1661	*pu32 &= ~BUSLOGIC_REGISTER_STATUS_DIAGNOSTIC_ACTIVE;
1662	*pu32 \|= BUSLOGIC_REGISTER_STATUS_HOST_ADAPTER_READY;
1663	pBusLogic->u64ResetTime = 0;
1664	}
1665	}
1666	break;
1667	}
1668	case BUSLOGIC_REGISTER_DATAIN:
1669	{
1670	if (pBusLogic->fUseLocalRam)
1671	*pu32 = pBusLogic->LocalRam.u8View[pBusLogic->iReply];
1672	else
1673	*pu32 = pBusLogic->aReplyBuffer[pBusLogic->iReply];
1674
1675	/* Careful about underflow - guest can read data register even if
1676	* no data is available.
1677	*/
1678	if (pBusLogic->cbReplyParametersLeft)
1679	{
1680	pBusLogic->iReply++;
1681	pBusLogic->cbReplyParametersLeft--;
1682	if (!pBusLogic->cbReplyParametersLeft)
1683	{
1684	/*
1685	* Reply finished, set command complete bit, unset data-in ready bit and
1686	* interrupt the guest if enabled.
1687	*/
1688	buslogicCommandComplete(pBusLogic, false);
1689	}
1690	}
1691	LogFlowFunc(("data=%02x, iReply=%d, cbReplyParametersLeft=%u\n", *pu32,
1692	pBusLogic->iReply, pBusLogic->cbReplyParametersLeft));
1693	break;
1694	}
1695	case BUSLOGIC_REGISTER_INTERRUPT:
1696	{
1697	*pu32 = pBusLogic->regInterrupt;
1698	break;
1699	}
1700	case BUSLOGIC_REGISTER_GEOMETRY:
1701	{
1702	*pu32 = pBusLogic->regGeometry;
1703	break;
1704	}
1705	default:
1706	*pu32 = UINT32_C(0xffffffff);
1707	}
1708
1709	Log2(("%s: pu32=%p:{%.*Rhxs} iRegister=%d rc=%Rrc\n",
1710	__FUNCTION__, pu32, 1, pu32, iRegister, rc));
1711
1712	return rc;
1713	}
1714
1715	/**
1716	* Write a value to a register.
1717	*
1718	* @returns VBox status code.
1719	* @param pBusLogic Pointer to the BusLogic instance data.
1720	* @param iRegister The index of the register to read.
1721	* @param uVal The value to write.
1722	*/
1723	static int buslogicRegisterWrite(PBUSLOGIC pBusLogic, unsigned iRegister, uint8_t uVal)
1724	{
1725	int rc = VINF_SUCCESS;
1726
1727	switch (iRegister)
1728	{
1729	case BUSLOGIC_REGISTER_CONTROL:
1730	{
1731	rc = PDMCritSectEnter(&pBusLogic->CritSectIntr, VINF_IOM_R3_IOPORT_WRITE);
1732	if (rc != VINF_SUCCESS)
1733	return rc;
1734
1735	#ifdef LOG_ENABLED
1736	uint32_t cMailboxesReady = ASMAtomicXchgU32(&pBusLogic->cInMailboxesReady, 0);
1737	Log(("%u incoming mailboxes were ready when this interrupt was cleared\n", cMailboxesReady));
1738	#endif
1739
1740	if (uVal & BUSLOGIC_REGISTER_CONTROL_INTERRUPT_RESET)
1741	buslogicClearInterrupt(pBusLogic);
1742
1743	PDMCritSectLeave(&pBusLogic->CritSectIntr);
1744
1745	if ((uVal & BUSLOGIC_REGISTER_CONTROL_HARD_RESET) \|\| (uVal & BUSLOGIC_REGISTER_CONTROL_SOFT_RESET))
1746	{
1747	#ifdef IN_RING3
1748	buslogicIntiateHardReset(pBusLogic);
1749	#else
1750	rc = VINF_IOM_R3_IOPORT_WRITE;
1751	#endif
1752	}
1753
1754	break;
1755	}
1756	case BUSLOGIC_REGISTER_COMMAND:
1757	{
1758	/* Fast path for mailbox execution command. */
1759	if ((uVal == BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND) && (pBusLogic->uOperationCode == 0xff))
1760	{
1761	ASMAtomicIncU32(&pBusLogic->cMailboxesReady);
1762	if (!ASMAtomicXchgBool(&pBusLogic->fNotificationSend, true))
1763	{
1764	/* Send new notification to the queue. */
1765	PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pBusLogic->CTX_SUFF(pNotifierQueue));
1766	AssertMsg(pItem, ("Allocating item for queue failed\n"));
1767	PDMQueueInsert(pBusLogic->CTX_SUFF(pNotifierQueue), (PPDMQUEUEITEMCORE)pItem);
1768	}
1769
1770	return rc;
1771	}
1772
1773	/*
1774	* Check if we are already fetch command parameters from the guest.
1775	* If not we initialize executing a new command.
1776	*/
1777	if (pBusLogic->uOperationCode == 0xff)
1778	{
1779	pBusLogic->uOperationCode = uVal;
1780	pBusLogic->iParameter = 0;
1781
1782	/* Mark host adapter as busy and clear the invalid status bit. */
1783	pBusLogic->regStatus &= ~(BUSLOGIC_REGISTER_STATUS_HOST_ADAPTER_READY \| BUSLOGIC_REGISTER_STATUS_COMMAND_INVALID);
1784
1785	/* Get the number of bytes for parameters from the command code. */
1786	switch (pBusLogic->uOperationCode)
1787	{
1788	case BUSLOGICCOMMAND_TEST_CMDC_INTERRUPT:
1789	case BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_LETTER:
1790	case BUSLOGICCOMMAND_INQUIRE_BOARD_ID:
1791	case BUSLOGICCOMMAND_INQUIRE_FIRMWARE_VERSION_3RD_LETTER:
1792	case BUSLOGICCOMMAND_INQUIRE_PCI_HOST_ADAPTER_INFORMATION:
1793	case BUSLOGICCOMMAND_INQUIRE_CONFIGURATION:
1794	case BUSLOGICCOMMAND_INQUIRE_INSTALLED_DEVICES_ID_0_TO_7:
1795	case BUSLOGICCOMMAND_INQUIRE_TARGET_DEVICES:
1796	pBusLogic->cbCommandParametersLeft = 0;
1797	break;
1798	case BUSLOGICCOMMAND_MODIFY_IO_ADDRESS:
1799	case BUSLOGICCOMMAND_INQUIRE_EXTENDED_SETUP_INFORMATION:
1800	case BUSLOGICCOMMAND_INQUIRE_SETUP_INFORMATION:
1801	case BUSLOGICCOMMAND_INQUIRE_HOST_ADAPTER_MODEL_NUMBER:
1802	case BUSLOGICCOMMAND_ENABLE_STRICT_ROUND_ROBIN_MODE:
1803	case BUSLOGICCOMMAND_SET_CCB_FORMAT:
1804	case BUSLOGICCOMMAND_INQUIRE_SYNCHRONOUS_PERIOD:
1805	case BUSLOGICCOMMAND_DISABLE_HOST_ADAPTER_INTERRUPT:
1806	case BUSLOGICCOMMAND_ECHO_COMMAND_DATA:
1807	case BUSLOGICCOMMAND_SET_PREEMPT_TIME_ON_BUS:
1808	case BUSLOGICCOMMAND_SET_TIME_OFF_BUS:
1809	pBusLogic->cbCommandParametersLeft = 1;
1810	break;
1811	case BUSLOGICCOMMAND_FETCH_HOST_ADAPTER_LOCAL_RAM:
1812	pBusLogic->cbCommandParametersLeft = 2;
1813	break;
1814	case BUSLOGICCOMMAND_INITIALIZE_EXTENDED_MAILBOX:
1815	pBusLogic->cbCommandParametersLeft = sizeof(RequestInitializeExtendedMailbox);
1816	break;
1817	case BUSLOGICCOMMAND_SET_ADAPTER_OPTIONS:
1818	/* There must be at least one byte following this command. */
1819	pBusLogic->cbCommandParametersLeft = 1;
1820	break;
1821	case BUSLOGICCOMMAND_EXT_BIOS_INFO:
1822	case BUSLOGICCOMMAND_UNLOCK_MAILBOX:
1823	/* Invalid commands. */
1824	pBusLogic->cbCommandParametersLeft = 0;
1825	break;
1826	case BUSLOGICCOMMAND_EXECUTE_MAILBOX_COMMAND: /* Should not come here anymore. */
1827	default:
1828	AssertMsgFailed(("Invalid operation code %#x\n", uVal));
1829	}
1830	}
1831	else
1832	{
1833	/*
1834	* The real adapter would set the Command register busy bit in the status register.
1835	* The guest has to wait until it is unset.
1836	* We don't need to do it because the guest does not continue execution while we are in this
1837	* function.
1838	*/
1839	pBusLogic->aCommandBuffer[pBusLogic->iParameter] = uVal;
1840	pBusLogic->iParameter++;
1841	pBusLogic->cbCommandParametersLeft--;
1842	}
1843
1844	/* Start execution of command if there are no parameters left. */
1845	if (!pBusLogic->cbCommandParametersLeft)
1846	{
1847	rc = buslogicProcessCommand(pBusLogic);
1848	AssertMsgRC(rc, ("Processing command failed rc=%Rrc\n", rc));
1849	}
1850	break;
1851	}
1852
1853	/* On BusLogic adapters, the interrupt and geometry registers are R/W.
1854	* That is different from Adaptec 154x where those are read only.
1855	*/
1856	case BUSLOGIC_REGISTER_INTERRUPT:
1857	pBusLogic->regInterrupt = uVal;
1858	break;
1859
1860	case BUSLOGIC_REGISTER_GEOMETRY:
1861	pBusLogic->regGeometry = uVal;
1862	break;
1863
1864	default:
1865	AssertMsgFailed(("Register not available\n"));
1866	rc = VERR_IOM_IOPORT_UNUSED;
1867	}
1868
1869	return rc;
1870	}
1871
1872	/**
1873	* Memory mapped I/O Handler for read operations.
1874	*
1875	* @returns VBox status code.
1876	*
1877	* @param pDevIns The device instance.
1878	* @param pvUser User argument.
1879	* @param GCPhysAddr Physical address (in GC) where the read starts.
1880	* @param pv Where to store the result.
1881	* @param cb Number of bytes read.
1882	*/
1883	PDMBOTHCBDECL(int) buslogicMMIORead(PPDMDEVINS pDevIns, void *pvUser,
1884	RTGCPHYS GCPhysAddr, void *pv, unsigned cb)
1885	{
1886	/* the linux driver does not make use of the MMIO area. */
1887	AssertMsgFailed(("MMIO Read\n"));
1888	return VINF_SUCCESS;
1889	}
1890
1891	/**
1892	* Memory mapped I/O Handler for write operations.
1893	*
1894	* @returns VBox status code.
1895	*
1896	* @param pDevIns The device instance.
1897	* @param pvUser User argument.
1898	* @param GCPhysAddr Physical address (in GC) where the read starts.
1899	* @param pv Where to fetch the result.
1900	* @param cb Number of bytes to write.
1901	*/
1902	PDMBOTHCBDECL(int) buslogicMMIOWrite(PPDMDEVINS pDevIns, void *pvUser,
1903	RTGCPHYS GCPhysAddr, void const *pv, unsigned cb)
1904	{
1905	/* the linux driver does not make use of the MMIO area. */
1906	AssertMsgFailed(("MMIO Write\n"));
1907	return VINF_SUCCESS;
1908	}
1909
1910	/**
1911	* Port I/O Handler for IN operations.
1912	*
1913	* @returns VBox status code.
1914	*
1915	* @param pDevIns The device instance.
1916	* @param pvUser User argument.
1917	* @param uPort Port number used for the IN operation.
1918	* @param pu32 Where to store the result.
1919	* @param cb Number of bytes read.
1920	*/
1921	PDMBOTHCBDECL(int) buslogicIOPortRead (PPDMDEVINS pDevIns, void *pvUser,
1922	RTIOPORT Port, uint32_t *pu32, unsigned cb)
1923	{
1924	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);;
1925	unsigned iRegister = Port % 4;
1926
1927	Assert(cb == 1);
1928
1929	return buslogicRegisterRead(pBusLogic, iRegister, pu32);
1930	}
1931
1932	/**
1933	* Port I/O Handler for OUT operations.
1934	*
1935	* @returns VBox status code.
1936	*
1937	* @param pDevIns The device instance.
1938	* @param pvUser User argument.
1939	* @param uPort Port number used for the IN operation.
1940	* @param u32 The value to output.
1941	* @param cb The value size in bytes.
1942	*/
1943	PDMBOTHCBDECL(int) buslogicIOPortWrite (PPDMDEVINS pDevIns, void *pvUser,
1944	RTIOPORT Port, uint32_t u32, unsigned cb)
1945	{
1946	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
1947	int rc = VINF_SUCCESS;
1948	unsigned iRegister = Port % 4;
1949	uint8_t uVal = (uint8_t)u32;
1950
1951	Assert(cb == 1);
1952
1953	rc = buslogicRegisterWrite(pBusLogic, iRegister, (uint8_t)uVal);
1954
1955	Log2(("#%d %s: pvUser=%#p cb=%d u32=%#x Port=%#x rc=%Rrc\n",
1956	pDevIns->iInstance, __FUNCTION__, pvUser, cb, u32, Port, rc));
1957
1958	return rc;
1959	}
1960
1961	#ifdef IN_RING3
1962	/**
1963	* Port I/O Handler for IN operations - legacy port.
1964	*
1965	* @returns VBox status code.
1966	*
1967	* @param pDevIns The device instance.
1968	* @param pvUser User argument.
1969	* @param uPort Port number used for the IN operation.
1970	* @param pu32 Where to store the result.
1971	* @param cb Number of bytes read.
1972	*/
1973	static int buslogicBIOSIOPortRead (PPDMDEVINS pDevIns, void *pvUser,
1974	RTIOPORT Port, uint32_t *pu32, unsigned cb)
1975	{
1976	int rc;
1977	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
1978
1979	Assert(cb == 1);
1980
1981	if (!pBusLogic->fISAEnabled)
1982	return VINF_SUCCESS;
1983
1984	rc = vboxscsiReadRegister(&pBusLogic->VBoxSCSI, (Port - BUSLOGIC_BIOS_IO_PORT), pu32);
1985
1986	//Log2(("%s: pu32=%p:{%.*Rhxs} iRegister=%d rc=%Rrc\n",
1987	// __FUNCTION__, pu32, 1, pu32, (Port - BUSLOGIC_BIOS_IO_PORT), rc));
1988
1989	return rc;
1990	}
1991
1992	static void buslogicWarningDiskFull(PPDMDEVINS pDevIns)
1993	{
1994	int rc;
1995	LogRel(("BusLogic#%d: Host disk full\n", pDevIns->iInstance));
1996	rc = PDMDevHlpVMSetRuntimeError(pDevIns, VMSETRTERR_FLAGS_SUSPEND \| VMSETRTERR_FLAGS_NO_WAIT, "DevBusLogic_DISKFULL",
1997	N_("Host system reported disk full. VM execution is suspended. You can resume after freeing some space"));
1998	AssertRC(rc);
1999	}
2000
2001	static void buslogicWarningFileTooBig(PPDMDEVINS pDevIns)
2002	{
2003	int rc;
2004	LogRel(("BusLogic#%d: File too big\n", pDevIns->iInstance));
2005	rc = PDMDevHlpVMSetRuntimeError(pDevIns, VMSETRTERR_FLAGS_SUSPEND \| VMSETRTERR_FLAGS_NO_WAIT, "DevBusLogic_FILETOOBIG",
2006	N_("Host system reported that the file size limit of the host file system has been exceeded. VM execution is suspended. You need to move your virtual hard disk to a filesystem which allows bigger files"));
2007	AssertRC(rc);
2008	}
2009
2010	static void buslogicWarningISCSI(PPDMDEVINS pDevIns)
2011	{
2012	int rc;
2013	LogRel(("BusLogic#%d: iSCSI target unavailable\n", pDevIns->iInstance));
2014	rc = PDMDevHlpVMSetRuntimeError(pDevIns, VMSETRTERR_FLAGS_SUSPEND \| VMSETRTERR_FLAGS_NO_WAIT, "DevBusLogic_ISCSIDOWN",
2015	N_("The iSCSI target has stopped responding. VM execution is suspended. You can resume when it is available again"));
2016	AssertRC(rc);
2017	}
2018
2019	static void buslogicWarningUnknown(PPDMDEVINS pDevIns, int rc)
2020	{
2021	int rc2;
2022	LogRel(("BusLogic#%d: Unknown but recoverable error has occurred (rc=%Rrc)\n", pDevIns->iInstance, rc));
2023	rc2 = PDMDevHlpVMSetRuntimeError(pDevIns, VMSETRTERR_FLAGS_SUSPEND \| VMSETRTERR_FLAGS_NO_WAIT, "DevBusLogic_UNKNOWN",
2024	N_("An unknown but recoverable I/O error has occurred (rc=%Rrc). VM execution is suspended. You can resume when the error is fixed"), rc);
2025	AssertRC(rc2);
2026	}
2027
2028	static void buslogicRedoSetWarning(PBUSLOGIC pThis, int rc)
2029	{
2030	if (rc == VERR_DISK_FULL)
2031	buslogicWarningDiskFull(pThis->CTX_SUFF(pDevIns));
2032	else if (rc == VERR_FILE_TOO_BIG)
2033	buslogicWarningFileTooBig(pThis->CTX_SUFF(pDevIns));
2034	else if (rc == VERR_BROKEN_PIPE \|\| rc == VERR_NET_CONNECTION_REFUSED)
2035	{
2036	/* iSCSI connection abort (first error) or failure to reestablish
2037	* connection (second error). Pause VM. On resume we'll retry. */
2038	buslogicWarningISCSI(pThis->CTX_SUFF(pDevIns));
2039	}
2040	else
2041	buslogicWarningUnknown(pThis->CTX_SUFF(pDevIns), rc);
2042	}
2043
2044
2045	static int buslogicPrepareBIOSSCSIRequest(PBUSLOGIC pBusLogic)
2046	{
2047	int rc;
2048	PBUSLOGICTASKSTATE pTaskState;
2049	uint32_t uTargetDevice;
2050
2051	rc = RTMemCacheAllocEx(pBusLogic->hTaskCache, (void **)&pTaskState);
2052	AssertMsgRCReturn(rc, ("Getting task from cache failed rc=%Rrc\n", rc), rc);
2053
2054	pTaskState->fBIOS = true;
2055
2056	rc = vboxscsiSetupRequest(&pBusLogic->VBoxSCSI, &pTaskState->PDMScsiRequest, &uTargetDevice);
2057	AssertMsgRCReturn(rc, ("Setting up SCSI request failed rc=%Rrc\n", rc), rc);
2058
2059	pTaskState->PDMScsiRequest.pvUser = pTaskState;
2060
2061	pTaskState->CTX_SUFF(pTargetDevice) = &pBusLogic->aDeviceStates[uTargetDevice];
2062
2063	if (!pTaskState->CTX_SUFF(pTargetDevice)->fPresent)
2064	{
2065	/* Device is not present. */
2066	AssertMsg(pTaskState->PDMScsiRequest.pbCDB[0] == SCSI_INQUIRY,
2067	("Device is not present but command is not inquiry\n"));
2068
2069	SCSIINQUIRYDATA ScsiInquiryData;
2070
2071	memset(&ScsiInquiryData, 0, sizeof(SCSIINQUIRYDATA));
2072	ScsiInquiryData.u5PeripheralDeviceType = SCSI_INQUIRY_DATA_PERIPHERAL_DEVICE_TYPE_UNKNOWN;
2073	ScsiInquiryData.u3PeripheralQualifier = SCSI_INQUIRY_DATA_PERIPHERAL_QUALIFIER_NOT_CONNECTED_NOT_SUPPORTED;
2074
2075	memcpy(pBusLogic->VBoxSCSI.pBuf, &ScsiInquiryData, 5);
2076
2077	rc = vboxscsiRequestFinished(&pBusLogic->VBoxSCSI, &pTaskState->PDMScsiRequest);
2078	AssertMsgRCReturn(rc, ("Finishing BIOS SCSI request failed rc=%Rrc\n", rc), rc);
2079
2080	RTMemCacheFree(pBusLogic->hTaskCache, pTaskState);
2081	}
2082	else
2083	{
2084	LogFlowFunc(("before increment %u\n", pTaskState->CTX_SUFF(pTargetDevice)->cOutstandingRequests));
2085	ASMAtomicIncU32(&pTaskState->CTX_SUFF(pTargetDevice)->cOutstandingRequests);
2086	LogFlowFunc(("after increment %u\n", pTaskState->CTX_SUFF(pTargetDevice)->cOutstandingRequests));
2087
2088	rc = pTaskState->CTX_SUFF(pTargetDevice)->pDrvSCSIConnector->pfnSCSIRequestSend(pTaskState->CTX_SUFF(pTargetDevice)->pDrvSCSIConnector,
2089	&pTaskState->PDMScsiRequest);
2090	AssertMsgRC(rc, ("Sending request to SCSI layer failed rc=%Rrc\n", rc));
2091	}
2092
2093	return rc;
2094	}
2095
2096	/**
2097	* Port I/O Handler for OUT operations - legacy port.
2098	*
2099	* @returns VBox status code.
2100	*
2101	* @param pDevIns The device instance.
2102	* @param pvUser User argument.
2103	* @param uPort Port number used for the IN operation.
2104	* @param u32 The value to output.
2105	* @param cb The value size in bytes.
2106	*/
2107	static int buslogicBIOSIOPortWrite (PPDMDEVINS pDevIns, void *pvUser,
2108	RTIOPORT Port, uint32_t u32, unsigned cb)
2109	{
2110	int rc;
2111	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2112
2113	Log2(("#%d %s: pvUser=%#p cb=%d u32=%#x Port=%#x\n",
2114	pDevIns->iInstance, __FUNCTION__, pvUser, cb, u32, Port));
2115
2116	Assert(cb == 1);
2117
2118	if (!pBusLogic->fISAEnabled)
2119	return VINF_SUCCESS;
2120
2121	rc = vboxscsiWriteRegister(&pBusLogic->VBoxSCSI, (Port - BUSLOGIC_BIOS_IO_PORT), (uint8_t)u32);
2122	if (rc == VERR_MORE_DATA)
2123	{
2124	rc = buslogicPrepareBIOSSCSIRequest(pBusLogic);
2125	AssertRC(rc);
2126	}
2127	else if (RT_FAILURE(rc))
2128	AssertMsgFailed(("Writing BIOS register failed %Rrc\n", rc));
2129
2130	return VINF_SUCCESS;
2131	}
2132
2133	/**
2134	* Port I/O Handler for primary port range OUT string operations.
2135	* @see FNIOMIOPORTOUTSTRING for details.
2136	*/
2137	static DECLCALLBACK(int) buslogicBIOSIOPortWriteStr(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, RTGCPTR pGCPtrSrc, PRTGCUINTREG pcTransfer, unsigned cb)
2138	{
2139	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2140	int rc;
2141
2142	Log2(("#%d %s: pvUser=%#p cb=%d Port=%#x\n",
2143	pDevIns->iInstance, __FUNCTION__, pvUser, cb, Port));
2144
2145	rc = vboxscsiWriteString(pDevIns, &pBusLogic->VBoxSCSI, (Port - BUSLOGIC_BIOS_IO_PORT),
2146	pGCPtrSrc, pcTransfer, cb);
2147	if (rc == VERR_MORE_DATA)
2148	{
2149	rc = buslogicPrepareBIOSSCSIRequest(pBusLogic);
2150	AssertRC(rc);
2151	}
2152	else if (RT_FAILURE(rc))
2153	AssertMsgFailed(("Writing BIOS register failed %Rrc\n", rc));
2154
2155	return rc;
2156	}
2157
2158	/**
2159	* Port I/O Handler for primary port range IN string operations.
2160	* @see FNIOMIOPORTINSTRING for details.
2161	*/
2162	static DECLCALLBACK(int) buslogicBIOSIOPortReadStr(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, RTGCPTR pGCPtrDst, PRTGCUINTREG pcTransfer, unsigned cb)
2163	{
2164	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2165
2166	LogFlowFunc(("#%d %s: pvUser=%#p cb=%d Port=%#x\n",
2167	pDevIns->iInstance, __FUNCTION__, pvUser, cb, Port));
2168
2169	return vboxscsiReadString(pDevIns, &pBusLogic->VBoxSCSI, (Port - BUSLOGIC_BIOS_IO_PORT),
2170	pGCPtrDst, pcTransfer, cb);
2171	}
2172
2173	static DECLCALLBACK(int) buslogicMMIOMap(PPCIDEVICE pPciDev, /unsigned/ int iRegion,
2174	RTGCPHYS GCPhysAddress, uint32_t cb,
2175	PCIADDRESSSPACE enmType)
2176	{
2177	PPDMDEVINS pDevIns = pPciDev->pDevIns;
2178	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2179	int rc = VINF_SUCCESS;
2180
2181	Log2(("%s: registering MMIO area at GCPhysAddr=%RGp cb=%u\n", __FUNCTION__, GCPhysAddress, cb));
2182
2183	Assert(cb >= 32);
2184
2185	if (enmType == PCI_ADDRESS_SPACE_MEM)
2186	{
2187	/* We use the assigned size here, because we currently only support page aligned MMIO ranges. */
2188	rc = PDMDevHlpMMIORegister(pDevIns, GCPhysAddress, cb, NULL /pvUser/,
2189	IOMMMIO_FLAGS_READ_PASSTHRU \| IOMMMIO_FLAGS_WRITE_PASSTHRU,
2190	buslogicMMIOWrite, buslogicMMIORead, "BusLogic MMIO");
2191	if (RT_FAILURE(rc))
2192	return rc;
2193
2194	if (pThis->fR0Enabled)
2195	{
2196	rc = PDMDevHlpMMIORegisterR0(pDevIns, GCPhysAddress, cb, NIL_RTR0PTR /pvUser/,
2197	"buslogicMMIOWrite", "buslogicMMIORead");
2198	if (RT_FAILURE(rc))
2199	return rc;
2200	}
2201
2202	if (pThis->fGCEnabled)
2203	{
2204	rc = PDMDevHlpMMIORegisterRC(pDevIns, GCPhysAddress, cb, NIL_RTRCPTR /pvUser/,
2205	"buslogicMMIOWrite", "buslogicMMIORead");
2206	if (RT_FAILURE(rc))
2207	return rc;
2208	}
2209
2210	pThis->MMIOBase = GCPhysAddress;
2211	}
2212	else if (enmType == PCI_ADDRESS_SPACE_IO)
2213	{
2214	rc = PDMDevHlpIOPortRegister(pDevIns, (RTIOPORT)GCPhysAddress, 32,
2215	NULL, buslogicIOPortWrite, buslogicIOPortRead, NULL, NULL, "BusLogic PCI");
2216	if (RT_FAILURE(rc))
2217	return rc;
2218
2219	if (pThis->fR0Enabled)
2220	{
2221	rc = PDMDevHlpIOPortRegisterR0(pDevIns, (RTIOPORT)GCPhysAddress, 32,
2222	0, "buslogicIOPortWrite", "buslogicIOPortRead", NULL, NULL, "BusLogic PCI");
2223	if (RT_FAILURE(rc))
2224	return rc;
2225	}
2226
2227	if (pThis->fGCEnabled)
2228	{
2229	rc = PDMDevHlpIOPortRegisterRC(pDevIns, (RTIOPORT)GCPhysAddress, 32,
2230	0, "buslogicIOPortWrite", "buslogicIOPortRead", NULL, NULL, "BusLogic PCI");
2231	if (RT_FAILURE(rc))
2232	return rc;
2233	}
2234
2235	pThis->IOPortBase = (RTIOPORT)GCPhysAddress;
2236	}
2237	else
2238	AssertMsgFailed(("Invalid enmType=%d\n", enmType));
2239
2240	return rc;
2241	}
2242
2243	static DECLCALLBACK(int) buslogicDeviceSCSIRequestCompleted(PPDMISCSIPORT pInterface, PPDMSCSIREQUEST pSCSIRequest,
2244	int rcCompletion, bool fRedo, int rcReq)
2245	{
2246	int rc;
2247	PBUSLOGICTASKSTATE pTaskState = (PBUSLOGICTASKSTATE)pSCSIRequest->pvUser;
2248	PBUSLOGICDEVICE pBusLogicDevice = pTaskState->CTX_SUFF(pTargetDevice);
2249	PBUSLOGIC pBusLogic = pBusLogicDevice->CTX_SUFF(pBusLogic);
2250
2251	LogFlowFunc(("before decrement %u\n", pBusLogicDevice->cOutstandingRequests));
2252	ASMAtomicDecU32(&pBusLogicDevice->cOutstandingRequests);
2253	LogFlowFunc(("after decrement %u\n", pBusLogicDevice->cOutstandingRequests));
2254
2255	if (fRedo)
2256	{
2257	if (!pTaskState->fBIOS)
2258	{
2259	buslogicDataBufferFree(pTaskState);
2260
2261	if (pTaskState->pbSenseBuffer)
2262	buslogicSenseBufferFree(pTaskState, false /* fCopy */);
2263	}
2264
2265	/* Add to the list. */
2266	do
2267	{
2268	pTaskState->pRedoNext = ASMAtomicReadPtrT(&pBusLogic->pTasksRedoHead, PBUSLOGICTASKSTATE);
2269	} while (!ASMAtomicCmpXchgPtr(&pBusLogic->pTasksRedoHead, pTaskState, pTaskState->pRedoNext));
2270
2271	/* Suspend the VM if not done already. */
2272	if (!ASMAtomicXchgBool(&pBusLogic->fRedo, true))
2273	buslogicRedoSetWarning(pBusLogic, rcReq);
2274	}
2275	else
2276	{
2277	if (pTaskState->fBIOS)
2278	{
2279	rc = vboxscsiRequestFinished(&pBusLogic->VBoxSCSI, pSCSIRequest);
2280	AssertMsgRC(rc, ("Finishing BIOS SCSI request failed rc=%Rrc\n", rc));
2281	}
2282	else
2283	{
2284	buslogicDataBufferFree(pTaskState);
2285
2286	if (pTaskState->pbSenseBuffer)
2287	buslogicSenseBufferFree(pTaskState, (rcCompletion != SCSI_STATUS_OK));
2288
2289	if (rcCompletion == SCSI_STATUS_OK)
2290	buslogicSendIncomingMailbox(pBusLogic, pTaskState,
2291	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_CMD_COMPLETED,
2292	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD,
2293	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITHOUT_ERROR);
2294	else if (rcCompletion == SCSI_STATUS_CHECK_CONDITION)
2295	buslogicSendIncomingMailbox(pBusLogic, pTaskState,
2296	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_CMD_COMPLETED,
2297	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_CHECK_CONDITION,
2298	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITH_ERROR);
2299	else
2300	AssertMsgFailed(("invalid completion status %d\n", rcCompletion));
2301	}
2302	/* Remove task from the cache. */
2303	RTMemCacheFree(pBusLogic->hTaskCache, pTaskState);
2304	}
2305
2306	if (pBusLogicDevice->cOutstandingRequests == 0 && pBusLogic->fSignalIdle)
2307	PDMDevHlpAsyncNotificationCompleted(pBusLogic->pDevInsR3);
2308
2309	return VINF_SUCCESS;
2310	}
2311
2312	static DECLCALLBACK(int) buslogicQueryDeviceLocation(PPDMISCSIPORT pInterface, const char **ppcszController,
2313	uint32_t piInstance, uint32_t piLUN)
2314	{
2315	PBUSLOGICDEVICE pBusLogicDevice = PDMISCSIPORT_2_PBUSLOGICDEVICE(pInterface);
2316	PPDMDEVINS pDevIns = pBusLogicDevice->CTX_SUFF(pBusLogic)->CTX_SUFF(pDevIns);
2317
2318	AssertPtrReturn(ppcszController, VERR_INVALID_POINTER);
2319	AssertPtrReturn(piInstance, VERR_INVALID_POINTER);
2320	AssertPtrReturn(piLUN, VERR_INVALID_POINTER);
2321
2322	*ppcszController = pDevIns->pReg->szName;
2323	*piInstance = pDevIns->iInstance;
2324	*piLUN = pBusLogicDevice->iLUN;
2325
2326	return VINF_SUCCESS;
2327	}
2328
2329	static int buslogicDeviceSCSIRequestSetup(PBUSLOGIC pBusLogic, PBUSLOGICTASKSTATE pTaskState)
2330	{
2331	int rc = VINF_SUCCESS;
2332
2333	/* Fetch the CCB from guest memory. */
2334	RTGCPHYS GCPhysAddrCCB = (RTGCPHYS)pTaskState->MailboxGuest.u32PhysAddrCCB;
2335	PDMDevHlpPhysRead(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrCCB,
2336	&pTaskState->CommandControlBlockGuest, sizeof(CommandControlBlock));
2337
2338	PBUSLOGICDEVICE pTargetDevice = &pBusLogic->aDeviceStates[pTaskState->CommandControlBlockGuest.uTargetId];
2339	pTaskState->CTX_SUFF(pTargetDevice) = pTargetDevice;
2340
2341	#ifdef DEBUG
2342	buslogicDumpCCBInfo(&pTaskState->CommandControlBlockGuest);
2343	#endif
2344
2345	/* Alloc required buffers. */
2346	rc = buslogicDataBufferAlloc(pTaskState);
2347	AssertMsgRC(rc, ("Alloc failed rc=%Rrc\n", rc));
2348
2349	if (pTaskState->CommandControlBlockGuest.cbSenseData)
2350	{
2351	rc = buslogicSenseBufferAlloc(pTaskState);
2352	AssertMsgRC(rc, ("Mapping sense buffer failed rc=%Rrc\n", rc));
2353	}
2354
2355	/* Check if device is present on bus. If not return error immediately and don't process this further. */
2356	if (!pBusLogic->aDeviceStates[pTaskState->CommandControlBlockGuest.uTargetId].fPresent)
2357	{
2358	buslogicDataBufferFree(pTaskState);
2359
2360	if (pTaskState->pbSenseBuffer)
2361	buslogicSenseBufferFree(pTaskState, true);
2362
2363	buslogicSendIncomingMailbox(pBusLogic, pTaskState,
2364	BUSLOGIC_MAILBOX_INCOMING_ADAPTER_STATUS_SCSI_SELECTION_TIMEOUT,
2365	BUSLOGIC_MAILBOX_INCOMING_DEVICE_STATUS_OPERATION_GOOD,
2366	BUSLOGIC_MAILBOX_INCOMING_COMPLETION_WITH_ERROR);
2367
2368	RTMemCacheFree(pBusLogic->hTaskCache, pTaskState);
2369	}
2370	else
2371	{
2372	/* Setup SCSI request. */
2373	pTaskState->PDMScsiRequest.uLogicalUnit = pTaskState->CommandControlBlockGuest.uLogicalUnit;
2374
2375	if (pTaskState->CommandControlBlockGuest.uDataDirection == BUSLOGIC_CCB_DIRECTION_UNKNOWN)
2376	pTaskState->PDMScsiRequest.uDataDirection = PDMSCSIREQUESTTXDIR_UNKNOWN;
2377	else if (pTaskState->CommandControlBlockGuest.uDataDirection == BUSLOGIC_CCB_DIRECTION_IN)
2378	pTaskState->PDMScsiRequest.uDataDirection = PDMSCSIREQUESTTXDIR_FROM_DEVICE;
2379	else if (pTaskState->CommandControlBlockGuest.uDataDirection == BUSLOGIC_CCB_DIRECTION_OUT)
2380	pTaskState->PDMScsiRequest.uDataDirection = PDMSCSIREQUESTTXDIR_TO_DEVICE;
2381	else if (pTaskState->CommandControlBlockGuest.uDataDirection == BUSLOGIC_CCB_DIRECTION_NO_DATA)
2382	pTaskState->PDMScsiRequest.uDataDirection = PDMSCSIREQUESTTXDIR_NONE;
2383	else
2384	AssertMsgFailed(("Invalid data direction type %d\n", pTaskState->CommandControlBlockGuest.uDataDirection));
2385
2386	pTaskState->PDMScsiRequest.cbCDB = pTaskState->CommandControlBlockGuest.cbCDB;
2387	pTaskState->PDMScsiRequest.pbCDB = pTaskState->CommandControlBlockGuest.aCDB;
2388	if (pTaskState->DataSeg.cbSeg)
2389	{
2390	pTaskState->PDMScsiRequest.cbScatterGather = pTaskState->DataSeg.cbSeg;
2391	pTaskState->PDMScsiRequest.cScatterGatherEntries = 1;
2392	pTaskState->PDMScsiRequest.paScatterGatherHead = &pTaskState->DataSeg;
2393	}
2394	else
2395	{
2396	pTaskState->PDMScsiRequest.cbScatterGather = 0;
2397	pTaskState->PDMScsiRequest.cScatterGatherEntries = 0;
2398	pTaskState->PDMScsiRequest.paScatterGatherHead = NULL;
2399	}
2400	pTaskState->PDMScsiRequest.cbSenseBuffer = pTaskState->CommandControlBlockGuest.cbSenseData;
2401	pTaskState->PDMScsiRequest.pbSenseBuffer = pTaskState->pbSenseBuffer;
2402	pTaskState->PDMScsiRequest.pvUser = pTaskState;
2403
2404	ASMAtomicIncU32(&pTargetDevice->cOutstandingRequests);
2405	rc = pTargetDevice->pDrvSCSIConnector->pfnSCSIRequestSend(pTargetDevice->pDrvSCSIConnector, &pTaskState->PDMScsiRequest);
2406	AssertMsgRC(rc, ("Sending request to SCSI layer failed rc=%Rrc\n", rc));
2407	}
2408
2409	return rc;
2410	}
2411
2412	/**
2413	* Read mailbox from the guest and execute command.
2414	*
2415	* @returns VBox status code.
2416	* @param pBusLogic Pointer to the BusLogic instance data.
2417	*/
2418	static int buslogicProcessMailboxNext(PBUSLOGIC pBusLogic)
2419	{
2420	PBUSLOGICTASKSTATE pTaskState = NULL;
2421	RTGCPHYS GCPhysAddrMailboxCurrent;
2422	int rc;
2423
2424	rc = RTMemCacheAllocEx(pBusLogic->hTaskCache, (void **)&pTaskState);
2425	AssertMsgReturn(RT_SUCCESS(rc) && (pTaskState != NULL), ("Failed to get task state from cache\n"), rc);
2426
2427	pTaskState->fBIOS = false;
2428
2429	if (!pBusLogic->fStrictRoundRobinMode)
2430	{
2431	/* Search for a filled mailbox - stop if we have scanned all mailboxes. */
2432	uint8_t uMailboxPosCur = pBusLogic->uMailboxOutgoingPositionCurrent;
2433
2434	do
2435	{
2436	/* Fetch mailbox from guest memory. */
2437	GCPhysAddrMailboxCurrent = buslogicOutgoingMailboxGetGCPhys(pBusLogic);
2438
2439	PDMDevHlpPhysRead(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxCurrent,
2440	&pTaskState->MailboxGuest, sizeof(Mailbox));
2441
2442	/* Check the next mailbox. */
2443	buslogicOutgoingMailboxAdvance(pBusLogic);
2444	} while ( pTaskState->MailboxGuest.u.out.uActionCode == BUSLOGIC_MAILBOX_OUTGOING_ACTION_FREE
2445	&& uMailboxPosCur != pBusLogic->uMailboxOutgoingPositionCurrent);
2446	}
2447	else
2448	{
2449	/* Fetch mailbox from guest memory. */
2450	GCPhysAddrMailboxCurrent = buslogicOutgoingMailboxGetGCPhys(pBusLogic);
2451
2452	PDMDevHlpPhysRead(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxCurrent,
2453	&pTaskState->MailboxGuest, sizeof(Mailbox));
2454	}
2455
2456	/*
2457	* Check if the mailbox is actually loaded.
2458	* It might be possible that the guest notified us without
2459	* a loaded mailbox. Do nothing in that case but leave a
2460	* log entry.
2461	*/
2462	if (pTaskState->MailboxGuest.u.out.uActionCode == BUSLOGIC_MAILBOX_OUTGOING_ACTION_FREE)
2463	{
2464	Log(("No loaded mailbox left\n"));
2465	RTMemCacheFree(pBusLogic->hTaskCache, pTaskState);
2466	return VERR_NO_DATA;
2467	}
2468
2469	LogFlow(("Got loaded mailbox at slot %u, CCB phys %RGp\n", pBusLogic->uMailboxOutgoingPositionCurrent, (RTGCPHYS)pTaskState->MailboxGuest.u32PhysAddrCCB));
2470	#ifdef DEBUG
2471	buslogicDumpMailboxInfo(&pTaskState->MailboxGuest, true);
2472	#endif
2473
2474	/* We got the mailbox, mark it as free in the guest. */
2475	uint8_t uActionCode = BUSLOGIC_MAILBOX_OUTGOING_ACTION_FREE;
2476	PDMDevHlpPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxCurrent + RT_OFFSETOF(Mailbox, u.out.uActionCode), &uActionCode, sizeof(uActionCode));
2477
2478	if (pTaskState->MailboxGuest.u.out.uActionCode == BUSLOGIC_MAILBOX_OUTGOING_ACTION_START_COMMAND)
2479	rc = buslogicDeviceSCSIRequestSetup(pBusLogic, pTaskState);
2480	else if (pTaskState->MailboxGuest.u.out.uActionCode == BUSLOGIC_MAILBOX_OUTGOING_ACTION_ABORT_COMMAND)
2481	{
2482	AssertMsgFailed(("Not implemented yet\n"));
2483	}
2484	else
2485	AssertMsgFailed(("Invalid outgoing mailbox action code %u\n", pTaskState->MailboxGuest.u.out.uActionCode));
2486
2487	AssertRC(rc);
2488
2489	/* Advance to the next mailbox. */
2490	if (pBusLogic->fStrictRoundRobinMode)
2491	buslogicOutgoingMailboxAdvance(pBusLogic);
2492
2493	return rc;
2494	}
2495
2496	/**
2497	* Transmit queue consumer
2498	* Queue a new async task.
2499	*
2500	* @returns Success indicator.
2501	* If false the item will not be removed and the flushing will stop.
2502	* @param pDevIns The device instance.
2503	* @param pItem The item to consume. Upon return this item will be freed.
2504	*/
2505	static DECLCALLBACK(bool) buslogicNotifyQueueConsumer(PPDMDEVINS pDevIns, PPDMQUEUEITEMCORE pItem)
2506	{
2507	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2508
2509	/* Reset notification send flag now. */
2510	Assert(pBusLogic->fNotificationSend);
2511	ASMAtomicXchgBool(&pBusLogic->fNotificationSend, false);
2512	ASMAtomicXchgU32(&pBusLogic->cMailboxesReady, 0); /* @todo: Actually not required anymore but to stay compatible with older saved states. */
2513
2514	/* Process mailboxes. */
2515	int rc;
2516	do
2517	{
2518	rc = buslogicProcessMailboxNext(pBusLogic);
2519	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_NO_DATA, ("Processing mailbox failed rc=%Rrc\n", rc));
2520	} while (RT_SUCCESS(rc));
2521
2522	return true;
2523	}
2524
2525	/**
2526	* Kicks the controller to process pending tasks after the VM was resumed
2527	* or loaded from a saved state.
2528	*
2529	* @returns nothing.
2530	* @param pThis The BusLogic device instance.
2531	*/
2532	static void buslogicKick(PBUSLOGIC pThis)
2533	{
2534	if (pThis->fRedo)
2535	{
2536	pThis->fRedo = false;
2537	if (pThis->VBoxSCSI.fBusy)
2538	{
2539
2540	/* The BIOS had a request active when we got suspended. Resume it. */
2541	int rc = buslogicPrepareBIOSSCSIRequest(pThis);
2542	AssertRC(rc);
2543	}
2544	else
2545	{
2546	/* Queue all pending tasks again. */
2547	PBUSLOGICTASKSTATE pTaskState = pThis->pTasksRedoHead;
2548
2549	pThis->pTasksRedoHead = NULL;
2550
2551	while (pTaskState)
2552	{
2553	PBUSLOGICTASKSTATE pCur = pTaskState;
2554
2555	int rc = buslogicDeviceSCSIRequestSetup(pThis, pCur);
2556	AssertRC(rc);
2557
2558	pTaskState = pTaskState->pRedoNext;
2559	}
2560	}
2561	}
2562	}
2563
2564	static DECLCALLBACK(int) buslogicLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
2565	{
2566	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2567
2568	/* Save the device config. */
2569	for (unsigned i = 0; i < RT_ELEMENTS(pThis->aDeviceStates); i++)
2570	SSMR3PutBool(pSSM, pThis->aDeviceStates[i].fPresent);
2571
2572	return VINF_SSM_DONT_CALL_AGAIN;
2573	}
2574
2575	static DECLCALLBACK(int) buslogicSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
2576	{
2577	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2578
2579	/* Every device first. */
2580	for (unsigned i = 0; i < RT_ELEMENTS(pBusLogic->aDeviceStates); i++)
2581	{
2582	PBUSLOGICDEVICE pDevice = &pBusLogic->aDeviceStates[i];
2583
2584	AssertMsg(!pDevice->cOutstandingRequests,
2585	("There are still outstanding requests on this device\n"));
2586	SSMR3PutBool(pSSM, pDevice->fPresent);
2587	SSMR3PutU32(pSSM, pDevice->cOutstandingRequests);
2588	}
2589	/* Now the main device state. */
2590	SSMR3PutU8 (pSSM, pBusLogic->regStatus);
2591	SSMR3PutU8 (pSSM, pBusLogic->regInterrupt);
2592	SSMR3PutU8 (pSSM, pBusLogic->regGeometry);
2593	SSMR3PutMem (pSSM, &pBusLogic->LocalRam, sizeof(pBusLogic->LocalRam));
2594	SSMR3PutU8 (pSSM, pBusLogic->uOperationCode);
2595	SSMR3PutMem (pSSM, &pBusLogic->aCommandBuffer, sizeof(pBusLogic->aCommandBuffer));
2596	SSMR3PutU8 (pSSM, pBusLogic->iParameter);
2597	SSMR3PutU8 (pSSM, pBusLogic->cbCommandParametersLeft);
2598	SSMR3PutBool (pSSM, pBusLogic->fUseLocalRam);
2599	SSMR3PutMem (pSSM, pBusLogic->aReplyBuffer, sizeof(pBusLogic->aReplyBuffer));
2600	SSMR3PutU8 (pSSM, pBusLogic->iReply);
2601	SSMR3PutU8 (pSSM, pBusLogic->cbReplyParametersLeft);
2602	SSMR3PutBool (pSSM, pBusLogic->fIRQEnabled);
2603	SSMR3PutBool (pSSM, pBusLogic->fISAEnabled);
2604	SSMR3PutU32 (pSSM, pBusLogic->cMailbox);
2605	SSMR3PutGCPhys(pSSM, pBusLogic->GCPhysAddrMailboxOutgoingBase);
2606	SSMR3PutU32 (pSSM, pBusLogic->uMailboxOutgoingPositionCurrent);
2607	SSMR3PutU32 (pSSM, pBusLogic->cMailboxesReady);
2608	SSMR3PutBool (pSSM, pBusLogic->fNotificationSend);
2609	SSMR3PutGCPhys(pSSM, pBusLogic->GCPhysAddrMailboxIncomingBase);
2610	SSMR3PutU32 (pSSM, pBusLogic->uMailboxIncomingPositionCurrent);
2611	SSMR3PutBool (pSSM, pBusLogic->fStrictRoundRobinMode);
2612	SSMR3PutBool (pSSM, pBusLogic->fExtendedLunCCBFormat);
2613	/* Now the data for the BIOS interface. */
2614	SSMR3PutU8 (pSSM, pBusLogic->VBoxSCSI.regIdentify);
2615	SSMR3PutU8 (pSSM, pBusLogic->VBoxSCSI.uTargetDevice);
2616	SSMR3PutU8 (pSSM, pBusLogic->VBoxSCSI.uTxDir);
2617	SSMR3PutU8 (pSSM, pBusLogic->VBoxSCSI.cbCDB);
2618	SSMR3PutMem (pSSM, pBusLogic->VBoxSCSI.aCDB, sizeof(pBusLogic->VBoxSCSI.aCDB));
2619	SSMR3PutU8 (pSSM, pBusLogic->VBoxSCSI.iCDB);
2620	SSMR3PutU32 (pSSM, pBusLogic->VBoxSCSI.cbBuf);
2621	SSMR3PutU32 (pSSM, pBusLogic->VBoxSCSI.iBuf);
2622	SSMR3PutBool (pSSM, pBusLogic->VBoxSCSI.fBusy);
2623	SSMR3PutU8 (pSSM, pBusLogic->VBoxSCSI.enmState);
2624	if (pBusLogic->VBoxSCSI.cbBuf)
2625	SSMR3PutMem(pSSM, pBusLogic->VBoxSCSI.pBuf, pBusLogic->VBoxSCSI.cbBuf);
2626
2627	/*
2628	* Save the physical addresses of the command control blocks of still pending tasks.
2629	* They are processed again on resume.
2630	*
2631	* The number of pending tasks needs to be determined first.
2632	*/
2633	uint32_t cTasks = 0;
2634
2635	PBUSLOGICTASKSTATE pTaskState = pBusLogic->pTasksRedoHead;
2636	if (pBusLogic->fRedo)
2637	{
2638	while (pTaskState)
2639	{
2640	cTasks++;
2641	pTaskState = pTaskState->pRedoNext;
2642	}
2643	}
2644	SSMR3PutU32(pSSM, cTasks);
2645
2646	/* Write the address of every task now. */
2647	pTaskState = pBusLogic->pTasksRedoHead;
2648	while (pTaskState)
2649	{
2650	SSMR3PutU32(pSSM, pTaskState->MailboxGuest.u32PhysAddrCCB);
2651	pTaskState = pTaskState->pRedoNext;
2652	}
2653
2654	return SSMR3PutU32(pSSM, ~0);
2655	}
2656
2657	static DECLCALLBACK(int) buslogicLoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
2658	{
2659	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2660
2661	buslogicKick(pThis);
2662	return VINF_SUCCESS;
2663	}
2664
2665	static DECLCALLBACK(int) buslogicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
2666	{
2667	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2668	int rc = VINF_SUCCESS;
2669
2670	/* We support saved states only from this and older versions. */
2671	if (uVersion > BUSLOGIC_SAVED_STATE_MINOR_VERSION)
2672	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
2673
2674	/* Every device first. */
2675	for (unsigned i = 0; i < RT_ELEMENTS(pBusLogic->aDeviceStates); i++)
2676	{
2677	PBUSLOGICDEVICE pDevice = &pBusLogic->aDeviceStates[i];
2678
2679	AssertMsg(!pDevice->cOutstandingRequests,
2680	("There are still outstanding requests on this device\n"));
2681	bool fPresent;
2682	rc = SSMR3GetBool(pSSM, &fPresent);
2683	AssertRCReturn(rc, rc);
2684	if (pDevice->fPresent != fPresent)
2685	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Target %u config mismatch: config=%RTbool state=%RTbool"), i, pDevice->fPresent, fPresent);
2686
2687	if (uPass == SSM_PASS_FINAL)
2688	SSMR3GetU32(pSSM, (uint32_t *)&pDevice->cOutstandingRequests);
2689	}
2690
2691	if (uPass != SSM_PASS_FINAL)
2692	return VINF_SUCCESS;
2693
2694	/* Now the main device state. */
2695	SSMR3GetU8 (pSSM, (uint8_t *)&pBusLogic->regStatus);
2696	SSMR3GetU8 (pSSM, (uint8_t *)&pBusLogic->regInterrupt);
2697	SSMR3GetU8 (pSSM, (uint8_t *)&pBusLogic->regGeometry);
2698	SSMR3GetMem (pSSM, &pBusLogic->LocalRam, sizeof(pBusLogic->LocalRam));
2699	SSMR3GetU8 (pSSM, &pBusLogic->uOperationCode);
2700	SSMR3GetMem (pSSM, &pBusLogic->aCommandBuffer, sizeof(pBusLogic->aCommandBuffer));
2701	SSMR3GetU8 (pSSM, &pBusLogic->iParameter);
2702	SSMR3GetU8 (pSSM, &pBusLogic->cbCommandParametersLeft);
2703	SSMR3GetBool (pSSM, &pBusLogic->fUseLocalRam);
2704	SSMR3GetMem (pSSM, pBusLogic->aReplyBuffer, sizeof(pBusLogic->aReplyBuffer));
2705	SSMR3GetU8 (pSSM, &pBusLogic->iReply);
2706	SSMR3GetU8 (pSSM, &pBusLogic->cbReplyParametersLeft);
2707	SSMR3GetBool (pSSM, &pBusLogic->fIRQEnabled);
2708	SSMR3GetBool (pSSM, &pBusLogic->fISAEnabled);
2709	SSMR3GetU32 (pSSM, &pBusLogic->cMailbox);
2710	SSMR3GetGCPhys(pSSM, &pBusLogic->GCPhysAddrMailboxOutgoingBase);
2711	SSMR3GetU32 (pSSM, &pBusLogic->uMailboxOutgoingPositionCurrent);
2712	SSMR3GetU32 (pSSM, (uint32_t *)&pBusLogic->cMailboxesReady);
2713	SSMR3GetBool (pSSM, (bool *)&pBusLogic->fNotificationSend);
2714	SSMR3GetGCPhys(pSSM, &pBusLogic->GCPhysAddrMailboxIncomingBase);
2715	SSMR3GetU32 (pSSM, &pBusLogic->uMailboxIncomingPositionCurrent);
2716	SSMR3GetBool (pSSM, &pBusLogic->fStrictRoundRobinMode);
2717	SSMR3GetBool (pSSM, &pBusLogic->fExtendedLunCCBFormat);
2718	/* Now the data for the BIOS interface. */
2719	SSMR3GetU8 (pSSM, &pBusLogic->VBoxSCSI.regIdentify);
2720	SSMR3GetU8 (pSSM, &pBusLogic->VBoxSCSI.uTargetDevice);
2721	SSMR3GetU8 (pSSM, &pBusLogic->VBoxSCSI.uTxDir);
2722	SSMR3GetU8 (pSSM, &pBusLogic->VBoxSCSI.cbCDB);
2723	SSMR3GetMem (pSSM, pBusLogic->VBoxSCSI.aCDB, sizeof(pBusLogic->VBoxSCSI.aCDB));
2724	SSMR3GetU8 (pSSM, &pBusLogic->VBoxSCSI.iCDB);
2725	SSMR3GetU32 (pSSM, &pBusLogic->VBoxSCSI.cbBuf);
2726	SSMR3GetU32 (pSSM, &pBusLogic->VBoxSCSI.iBuf);
2727	SSMR3GetBool(pSSM, (bool *)&pBusLogic->VBoxSCSI.fBusy);
2728	SSMR3GetU8 (pSSM, (uint8_t *)&pBusLogic->VBoxSCSI.enmState);
2729	if (pBusLogic->VBoxSCSI.cbBuf)
2730	{
2731	pBusLogic->VBoxSCSI.pBuf = (uint8_t *)RTMemAllocZ(pBusLogic->VBoxSCSI.cbBuf);
2732	if (!pBusLogic->VBoxSCSI.pBuf)
2733	{
2734	LogRel(("BusLogic: Out of memory during restore.\n"));
2735	return PDMDEV_SET_ERROR(pDevIns, VERR_NO_MEMORY,
2736	N_("BusLogic: Out of memory during restore\n"));
2737	}
2738	SSMR3GetMem(pSSM, pBusLogic->VBoxSCSI.pBuf, pBusLogic->VBoxSCSI.cbBuf);
2739	}
2740
2741	if (pBusLogic->VBoxSCSI.fBusy)
2742	pBusLogic->fRedo = true;
2743
2744	if (uVersion > BUSLOGIC_SAVED_STATE_MINOR_PRE_ERROR_HANDLING)
2745	{
2746	/* Check if there are pending tasks saved. */
2747	uint32_t cTasks = 0;
2748
2749	SSMR3GetU32(pSSM, &cTasks);
2750
2751	if (cTasks)
2752	pBusLogic->fRedo = true;
2753
2754	for (uint32_t i = 0; i < cTasks; i++)
2755	{
2756	PBUSLOGICTASKSTATE pTaskState = (PBUSLOGICTASKSTATE)RTMemCacheAlloc(pBusLogic->hTaskCache);
2757	if (!pTaskState)
2758	{
2759	rc = VERR_NO_MEMORY;
2760	break;
2761	}
2762
2763	rc = SSMR3GetU32(pSSM, &pTaskState->MailboxGuest.u32PhysAddrCCB);
2764	if (RT_FAILURE(rc))
2765	{
2766	RTMemCacheFree(pBusLogic->hTaskCache, pTaskState);
2767	break;
2768	}
2769
2770	/* Link into the list. */
2771	pTaskState->pRedoNext = pBusLogic->pTasksRedoHead;
2772	pBusLogic->pTasksRedoHead = pTaskState;
2773	}
2774	}
2775
2776	if (RT_SUCCESS(rc))
2777	{
2778	uint32_t u32;
2779	rc = SSMR3GetU32(pSSM, &u32);
2780	if (RT_SUCCESS(rc))
2781	AssertMsgReturn(u32 == ~0U, ("%#x\n", u32), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2782	}
2783
2784	return rc;
2785	}
2786
2787	/**
2788	* Gets the pointer to the status LED of a device - called from the SCSi driver.
2789	*
2790	* @returns VBox status code.
2791	* @param pInterface Pointer to the interface structure containing the called function pointer.
2792	* @param iLUN The unit which status LED we desire. Always 0 here as the driver
2793	* doesn't know about other LUN's.
2794	* @param ppLed Where to store the LED pointer.
2795	*/
2796	static DECLCALLBACK(int) buslogicDeviceQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
2797	{
2798	PBUSLOGICDEVICE pDevice = PDMILEDPORTS_2_PBUSLOGICDEVICE(pInterface);
2799	if (iLUN == 0)
2800	{
2801	*ppLed = &pDevice->Led;
2802	Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
2803	return VINF_SUCCESS;
2804	}
2805	return VERR_PDM_LUN_NOT_FOUND;
2806	}
2807
2808	/**
2809	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
2810	*/
2811	static DECLCALLBACK(void ) buslogicDeviceQueryInterface(PPDMIBASE pInterface, const char pszIID)
2812	{
2813	PBUSLOGICDEVICE pDevice = PDMIBASE_2_PBUSLOGICDEVICE(pInterface);
2814	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDevice->IBase);
2815	PDMIBASE_RETURN_INTERFACE(pszIID, PDMISCSIPORT, &pDevice->ISCSIPort);
2816	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pDevice->ILed);
2817	return NULL;
2818	}
2819
2820	/**
2821	* Gets the pointer to the status LED of a unit.
2822	*
2823	* @returns VBox status code.
2824	* @param pInterface Pointer to the interface structure containing the called function pointer.
2825	* @param iLUN The unit which status LED we desire.
2826	* @param ppLed Where to store the LED pointer.
2827	*/
2828	static DECLCALLBACK(int) buslogicStatusQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
2829	{
2830	PBUSLOGIC pBusLogic = PDMILEDPORTS_2_PBUSLOGIC(pInterface);
2831	if (iLUN < BUSLOGIC_MAX_DEVICES)
2832	{
2833	*ppLed = &pBusLogic->aDeviceStates[iLUN].Led;
2834	Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
2835	return VINF_SUCCESS;
2836	}
2837	return VERR_PDM_LUN_NOT_FOUND;
2838	}
2839
2840	/**
2841	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
2842	*/
2843	static DECLCALLBACK(void ) buslogicStatusQueryInterface(PPDMIBASE pInterface, const char pszIID)
2844	{
2845	PBUSLOGIC pThis = PDMIBASE_2_PBUSLOGIC(pInterface);
2846	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
2847	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->ILeds);
2848	return NULL;
2849	}
2850
2851	/* -=-=-=-=- Helper -=-=-=-=- */
2852
2853	/**
2854	* Checks if all asynchronous I/O is finished.
2855	*
2856	* Used by buslogicReset, buslogicSuspend and buslogicPowerOff.
2857	*
2858	* @returns true if quiesced, false if busy.
2859	* @param pDevIns The device instance.
2860	*/
2861	static bool buslogicR3AllAsyncIOIsFinished(PPDMDEVINS pDevIns)
2862	{
2863	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2864
2865	for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aDeviceStates); i++)
2866	{
2867	PBUSLOGICDEVICE pThisDevice = &pThis->aDeviceStates[i];
2868	if (pThisDevice->pDrvBase)
2869	{
2870	if (pThisDevice->cOutstandingRequests != 0)
2871	return false;
2872	}
2873	}
2874
2875	return true;
2876	}
2877
2878	/**
2879	* Callback employed by buslogicR3Suspend and buslogicR3PowerOff..
2880	*
2881	* @returns true if we've quiesced, false if we're still working.
2882	* @param pDevIns The device instance.
2883	*/
2884	static DECLCALLBACK(bool) buslogicR3IsAsyncSuspendOrPowerOffDone(PPDMDEVINS pDevIns)
2885	{
2886	if (!buslogicR3AllAsyncIOIsFinished(pDevIns))
2887	return false;
2888
2889	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2890	ASMAtomicWriteBool(&pThis->fSignalIdle, false);
2891	return true;
2892	}
2893
2894	/**
2895	* Common worker for ahciR3Suspend and ahciR3PowerOff.
2896	*/
2897	static void buslogicR3SuspendOrPowerOff(PPDMDEVINS pDevIns, bool fPowerOff)
2898	{
2899	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2900
2901	ASMAtomicWriteBool(&pThis->fSignalIdle, true);
2902	if (!buslogicR3AllAsyncIOIsFinished(pDevIns))
2903	PDMDevHlpSetAsyncNotification(pDevIns, buslogicR3IsAsyncSuspendOrPowerOffDone);
2904	else
2905	{
2906	ASMAtomicWriteBool(&pThis->fSignalIdle, false);
2907
2908	AssertMsg(!pThis->fNotificationSend, ("The PDM Queue should be empty at this point\n"));
2909
2910	if (pThis->fRedo)
2911	{
2912	if (fPowerOff)
2913	{
2914	/* Free tasks which would have been queued again on resume. */
2915	PBUSLOGICTASKSTATE pTaskState = pThis->pTasksRedoHead;
2916
2917	pThis->pTasksRedoHead = NULL;
2918
2919	while (pTaskState)
2920	{
2921	PBUSLOGICTASKSTATE pFree;
2922
2923	pFree = pTaskState;
2924	pTaskState = pTaskState->pRedoNext;
2925
2926	RTMemCacheFree(pThis->hTaskCache, pFree);
2927	}
2928	pThis->fRedo = false;
2929	}
2930	else if (pThis->VBoxSCSI.fBusy)
2931	{
2932	/* Destroy the task because the BIOS interface has all necessary information. */
2933	Assert(pThis->pTasksRedoHead->fBIOS);
2934	Assert(!pThis->pTasksRedoHead->pRedoNext);
2935
2936	RTMemCacheFree(pThis->hTaskCache, pThis->pTasksRedoHead);
2937	pThis->pTasksRedoHead = NULL;
2938	}
2939	}
2940	}
2941	}
2942
2943	/**
2944	* Suspend notification.
2945	*
2946	* @param pDevIns The device instance data.
2947	*/
2948	static DECLCALLBACK(void) buslogicSuspend(PPDMDEVINS pDevIns)
2949	{
2950	Log(("buslogicSuspend\n"));
2951	buslogicR3SuspendOrPowerOff(pDevIns, false /* fPoweroff */);
2952	}
2953
2954	/**
2955	* Resume notification.
2956	*
2957	* @param pDevIns The device instance data.
2958	*/
2959	static DECLCALLBACK(void) buslogicResume(PPDMDEVINS pDevIns)
2960	{
2961	Log(("buslogicResume\n"));
2962	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2963	buslogicKick(pThis);
2964	}
2965
2966
2967	/**
2968	* Detach notification.
2969	*
2970	* One harddisk at one port has been unplugged.
2971	* The VM is suspended at this point.
2972	*
2973	* @param pDevIns The device instance.
2974	* @param iLUN The logical unit which is being detached.
2975	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
2976	*/
2977	static DECLCALLBACK(void) buslogicDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
2978	{
2979	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
2980	PBUSLOGICDEVICE pDevice = &pThis->aDeviceStates[iLUN];
2981
2982	Log(("%s:\n", __FUNCTION__));
2983
2984	AssertMsg(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
2985	("BusLogic: Device does not support hotplugging\n"));
2986
2987	/*
2988	* Zero some important members.
2989	*/
2990	pDevice->pDrvBase = NULL;
2991	pDevice->fPresent = false;
2992	pDevice->pDrvSCSIConnector = NULL;
2993	}
2994
2995	/**
2996	* Attach command.
2997	*
2998	* This is called when we change block driver.
2999	*
3000	* @returns VBox status code.
3001	* @param pDevIns The device instance.
3002	* @param iLUN The logical unit which is being detached.
3003	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
3004	*/
3005	static DECLCALLBACK(int) buslogicAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
3006	{
3007	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
3008	PBUSLOGICDEVICE pDevice = &pThis->aDeviceStates[iLUN];
3009	int rc;
3010
3011	AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
3012	("BusLogic: Device does not support hotplugging\n"),
3013	VERR_INVALID_PARAMETER);
3014
3015	/* the usual paranoia */
3016	AssertRelease(!pDevice->pDrvBase);
3017	AssertRelease(!pDevice->pDrvSCSIConnector);
3018	Assert(pDevice->iLUN == iLUN);
3019
3020	/*
3021	* Try attach the block device and get the interfaces,
3022	* required as well as optional.
3023	*/
3024	rc = PDMDevHlpDriverAttach(pDevIns, pDevice->iLUN, &pDevice->IBase, &pDevice->pDrvBase, NULL);
3025	if (RT_SUCCESS(rc))
3026	{
3027	/* Get SCSI connector interface. */
3028	pDevice->pDrvSCSIConnector = PDMIBASE_QUERY_INTERFACE(pDevice->pDrvBase, PDMISCSICONNECTOR);
3029	AssertMsgReturn(pDevice->pDrvSCSIConnector, ("Missing SCSI interface below\n"), VERR_PDM_MISSING_INTERFACE);
3030	pDevice->fPresent = true;
3031	}
3032	else
3033	AssertMsgFailed(("Failed to attach LUN#%d. rc=%Rrc\n", pDevice->iLUN, rc));
3034
3035	if (RT_FAILURE(rc))
3036	{
3037	pDevice->pDrvBase = NULL;
3038	pDevice->pDrvSCSIConnector = NULL;
3039	}
3040	return rc;
3041	}
3042
3043	/**
3044	* Callback employed by buslogicR3Reset.
3045	*
3046	* @returns true if we've quiesced, false if we're still working.
3047	* @param pDevIns The device instance.
3048	*/
3049	static DECLCALLBACK(bool) buslogicR3IsAsyncResetDone(PPDMDEVINS pDevIns)
3050	{
3051	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
3052
3053	if (!buslogicR3AllAsyncIOIsFinished(pDevIns))
3054	return false;
3055	ASMAtomicWriteBool(&pThis->fSignalIdle, false);
3056
3057	buslogicHwReset(pThis);
3058	return true;
3059	}
3060
3061	/**
3062	* @copydoc FNPDMDEVRESET
3063	*/
3064	static DECLCALLBACK(void) buslogicReset(PPDMDEVINS pDevIns)
3065	{
3066	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
3067
3068	ASMAtomicWriteBool(&pThis->fSignalIdle, true);
3069	if (!buslogicR3AllAsyncIOIsFinished(pDevIns))
3070	PDMDevHlpSetAsyncNotification(pDevIns, buslogicR3IsAsyncResetDone);
3071	else
3072	{
3073	ASMAtomicWriteBool(&pThis->fSignalIdle, false);
3074	buslogicHwReset(pThis);
3075	}
3076	}
3077
3078	static DECLCALLBACK(void) buslogicRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
3079	{
3080	uint32_t i;
3081	PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
3082
3083	pBusLogic->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
3084	pBusLogic->pNotifierQueueRC = PDMQueueRCPtr(pBusLogic->pNotifierQueueR3);
3085
3086	for (i = 0; i < BUSLOGIC_MAX_DEVICES; i++)
3087	{
3088	PBUSLOGICDEVICE pDevice = &pBusLogic->aDeviceStates[i];
3089
3090	pDevice->pBusLogicRC = PDMINS_2_DATA_RCPTR(pDevIns);
3091	}
3092
3093	}
3094
3095	/**
3096	* Poweroff notification.
3097	*
3098	* @param pDevIns Pointer to the device instance
3099	*/
3100	static DECLCALLBACK(void) buslogicPowerOff(PPDMDEVINS pDevIns)
3101	{
3102	Log(("buslogicPowerOff\n"));
3103	buslogicR3SuspendOrPowerOff(pDevIns, true /* fPoweroff */);
3104	}
3105
3106	/**
3107	* Destroy a driver instance.
3108	*
3109	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
3110	* resources can be freed correctly.
3111	*
3112	* @param pDevIns The device instance data.
3113	*/
3114	static DECLCALLBACK(int) buslogicDestruct(PPDMDEVINS pDevIns)
3115	{
3116	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
3117	PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
3118
3119	PDMR3CritSectDelete(&pThis->CritSectIntr);
3120
3121	/*
3122	* Free all tasks which are still hanging around
3123	* (Power off after the VM was suspended).
3124	*/
3125	if (pThis->fRedo)
3126	{
3127	/* Free tasks which would have been queued again on resume. */
3128	PBUSLOGICTASKSTATE pTaskState = pThis->pTasksRedoHead;
3129
3130	pThis->pTasksRedoHead = NULL;
3131
3132	while (pTaskState)
3133	{
3134	PBUSLOGICTASKSTATE pFree;
3135
3136	pFree = pTaskState;
3137	pTaskState = pTaskState->pRedoNext;
3138
3139	RTMemCacheFree(pThis->hTaskCache, pFree);
3140	}
3141	pThis->fRedo = false;
3142	}
3143
3144	int rc = RTMemCacheDestroy(pThis->hTaskCache);
3145	AssertMsgRC(rc, ("Destroying task cache failed rc=%Rrc\n", rc));
3146
3147	return rc;
3148	}
3149
3150	/**
3151	* @interface_method_impl{PDMDEVREG,pfnConstruct}
3152	*/
3153	static DECLCALLBACK(int) buslogicConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
3154	{
3155	PBUSLOGIC pThis = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
3156	int rc = VINF_SUCCESS;
3157	bool fBootable = true;
3158	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
3159
3160	/*
3161	* Validate and read configuration.
3162	*/
3163	if (!CFGMR3AreValuesValid(pCfg,
3164	"GCEnabled\0"
3165	"R0Enabled\0"
3166	"Bootable\0"))
3167	return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
3168	N_("BusLogic configuration error: unknown option specified"));
3169
3170	rc = CFGMR3QueryBoolDef(pCfg, "GCEnabled", &pThis->fGCEnabled, true);
3171	if (RT_FAILURE(rc))
3172	return PDMDEV_SET_ERROR(pDevIns, rc,
3173	N_("BusLogic configuration error: failed to read GCEnabled as boolean"));
3174	Log(("%s: fGCEnabled=%d\n", __FUNCTION__, pThis->fGCEnabled));
3175
3176	rc = CFGMR3QueryBoolDef(pCfg, "R0Enabled", &pThis->fR0Enabled, true);
3177	if (RT_FAILURE(rc))
3178	return PDMDEV_SET_ERROR(pDevIns, rc,
3179	N_("BusLogic configuration error: failed to read R0Enabled as boolean"));
3180	Log(("%s: fR0Enabled=%d\n", __FUNCTION__, pThis->fR0Enabled));
3181	rc = CFGMR3QueryBoolDef(pCfg, "Bootable", &fBootable, true);
3182	if (RT_FAILURE(rc))
3183	return PDMDEV_SET_ERROR(pDevIns, rc,
3184	N_("BusLogic configuration error: failed to read Bootable as boolean"));
3185	Log(("%s: fBootable=%RTbool\n", __FUNCTION__, fBootable));
3186
3187	pThis->pDevInsR3 = pDevIns;
3188	pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
3189	pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
3190	pThis->IBase.pfnQueryInterface = buslogicStatusQueryInterface;
3191	pThis->ILeds.pfnQueryStatusLed = buslogicStatusQueryStatusLed;
3192
3193	PCIDevSetVendorId (&pThis->dev, 0x104b); /* BusLogic */
3194	PCIDevSetDeviceId (&pThis->dev, 0x1040); /* BT-958 */
3195	PCIDevSetCommand (&pThis->dev, 0x0003);
3196	PCIDevSetRevisionId (&pThis->dev, 0x01);
3197	PCIDevSetClassProg (&pThis->dev, 0x00); /* SCSI */
3198	PCIDevSetClassSub (&pThis->dev, 0x00); /* SCSI */
3199	PCIDevSetClassBase (&pThis->dev, 0x01); /* Mass storage */
3200	PCIDevSetBaseAddress (&pThis->dev, 0, true /IO/, false /Pref/, false /64-bit/, 0x00000000);
3201	PCIDevSetBaseAddress (&pThis->dev, 1, false /IO/, false /Pref/, false /64-bit/, 0x00000000);
3202	PCIDevSetSubSystemVendorId(&pThis->dev, 0x104b);
3203	PCIDevSetSubSystemId (&pThis->dev, 0x1040);
3204	PCIDevSetInterruptLine (&pThis->dev, 0x00);
3205	PCIDevSetInterruptPin (&pThis->dev, 0x01);
3206
3207	/*
3208	* Register the PCI device, it's I/O regions.
3209	*/
3210	rc = PDMDevHlpPCIRegister (pDevIns, &pThis->dev);
3211	if (RT_FAILURE(rc))
3212	return rc;
3213
3214	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 32, PCI_ADDRESS_SPACE_IO, buslogicMMIOMap);
3215	if (RT_FAILURE(rc))
3216	return rc;
3217
3218	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 1, 32, PCI_ADDRESS_SPACE_MEM, buslogicMMIOMap);
3219	if (RT_FAILURE(rc))
3220	return rc;
3221
3222	if (fBootable)
3223	{
3224	/* Register I/O port space in ISA region for BIOS access. */
3225	rc = PDMDevHlpIOPortRegister(pDevIns, BUSLOGIC_BIOS_IO_PORT, 3, NULL,
3226	buslogicBIOSIOPortWrite, buslogicBIOSIOPortRead,
3227	buslogicBIOSIOPortWriteStr, buslogicBIOSIOPortReadStr,
3228	"BusLogic BIOS");
3229	if (RT_FAILURE(rc))
3230	return PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic cannot register legacy I/O handlers"));
3231	}
3232
3233	/* Initialize task cache. */
3234	rc = RTMemCacheCreate(&pThis->hTaskCache, sizeof(BUSLOGICTASKSTATE), 0, UINT32_MAX,
3235	NULL, NULL, NULL, 0);
3236	if (RT_FAILURE(rc))
3237	return PDMDEV_SET_ERROR(pDevIns, rc,
3238	N_("BusLogic: Failed to initialize task cache\n"));
3239
3240	/* Initialize task queue. */
3241	rc = PDMDevHlpQueueCreate(pDevIns, sizeof(PDMQUEUEITEMCORE), 5, 0,
3242	buslogicNotifyQueueConsumer, true, "BusLogicTask", &pThis->pNotifierQueueR3);
3243	if (RT_FAILURE(rc))
3244	return rc;
3245	pThis->pNotifierQueueR0 = PDMQueueR0Ptr(pThis->pNotifierQueueR3);
3246	pThis->pNotifierQueueRC = PDMQueueRCPtr(pThis->pNotifierQueueR3);
3247
3248	rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSectIntr, RT_SRC_POS, "BusLogic-Intr#%u", pDevIns->iInstance);
3249	if (RT_FAILURE(rc))
3250	return PDMDEV_SET_ERROR(pDevIns, rc,
3251	N_("BusLogic: cannot create critical section"));
3252
3253	/* Initialize per device state. */
3254	for (unsigned i = 0; i < RT_ELEMENTS(pThis->aDeviceStates); i++)
3255	{
3256	char szName[24];
3257	PBUSLOGICDEVICE pDevice = &pThis->aDeviceStates[i];
3258
3259	RTStrPrintf(szName, sizeof(szName), "Device%d", i);
3260
3261	/* Initialize static parts of the device. */
3262	pDevice->iLUN = i;
3263	pDevice->pBusLogicR3 = pThis;
3264	pDevice->pBusLogicR0 = PDMINS_2_DATA_R0PTR(pDevIns);
3265	pDevice->pBusLogicRC = PDMINS_2_DATA_RCPTR(pDevIns);
3266	pDevice->Led.u32Magic = PDMLED_MAGIC;
3267	pDevice->IBase.pfnQueryInterface = buslogicDeviceQueryInterface;
3268	pDevice->ISCSIPort.pfnSCSIRequestCompleted = buslogicDeviceSCSIRequestCompleted;
3269	pDevice->ISCSIPort.pfnQueryDeviceLocation = buslogicQueryDeviceLocation;
3270	pDevice->ILed.pfnQueryStatusLed = buslogicDeviceQueryStatusLed;
3271
3272	/* Attach SCSI driver. */
3273	rc = PDMDevHlpDriverAttach(pDevIns, pDevice->iLUN, &pDevice->IBase, &pDevice->pDrvBase, szName);
3274	if (RT_SUCCESS(rc))
3275	{
3276	/* Get SCSI connector interface. */
3277	pDevice->pDrvSCSIConnector = PDMIBASE_QUERY_INTERFACE(pDevice->pDrvBase, PDMISCSICONNECTOR);
3278	AssertMsgReturn(pDevice->pDrvSCSIConnector, ("Missing SCSI interface below\n"), VERR_PDM_MISSING_INTERFACE);
3279
3280	pDevice->fPresent = true;
3281	}
3282	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
3283	{
3284	pDevice->pDrvBase = NULL;
3285	pDevice->fPresent = false;
3286	rc = VINF_SUCCESS;
3287	Log(("BusLogic: no driver attached to device %s\n", szName));
3288	}
3289	else
3290	{
3291	AssertLogRelMsgFailed(("BusLogic: Failed to attach %s\n", szName));
3292	return rc;
3293	}
3294	}
3295
3296	/*
3297	* Attach status driver (optional).
3298	*/
3299	PPDMIBASE pBase;
3300	rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
3301	if (RT_SUCCESS(rc))
3302	pThis->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
3303	else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
3304	{
3305	AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
3306	return PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic cannot attach to status driver"));
3307	}
3308
3309	rc = PDMDevHlpSSMRegisterEx(pDevIns, BUSLOGIC_SAVED_STATE_MINOR_VERSION, sizeof(*pThis), NULL,
3310	NULL, buslogicLiveExec, NULL,
3311	NULL, buslogicSaveExec, NULL,
3312	NULL, buslogicLoadExec, buslogicLoadDone);
3313	if (RT_FAILURE(rc))
3314	return PDMDEV_SET_ERROR(pDevIns, rc, N_("BusLogic cannot register save state handlers"));
3315
3316	rc = buslogicHwReset(pThis);
3317	AssertMsgRC(rc, ("hardware reset of BusLogic host adapter failed rc=%Rrc\n", rc));
3318
3319	return rc;
3320	}
3321
3322	/**
3323	* The device registration structure.
3324	*/
3325	const PDMDEVREG g_DeviceBusLogic =
3326	{
3327	/* u32Version */
3328	PDM_DEVREG_VERSION,
3329	/* szName */
3330	"buslogic",
3331	/* szRCMod */
3332	"VBoxDDGC.gc",
3333	/* szR0Mod */
3334	"VBoxDDR0.r0",
3335	/* pszDescription */
3336	"BusLogic BT-958 SCSI host adapter.\n",
3337	/* fFlags */
3338	PDM_DEVREG_FLAGS_DEFAULT_BITS \| PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0 \|
3339	PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION \| PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION,
3340	/* fClass */
3341	PDM_DEVREG_CLASS_STORAGE,
3342	/* cMaxInstances */
3343	~0U,
3344	/* cbInstance */
3345	sizeof(BUSLOGIC),
3346	/* pfnConstruct */
3347	buslogicConstruct,
3348	/* pfnDestruct */
3349	buslogicDestruct,
3350	/* pfnRelocate */
3351	buslogicRelocate,
3352	/* pfnIOCtl */
3353	NULL,
3354	/* pfnPowerOn */
3355	NULL,
3356	/* pfnReset */
3357	buslogicReset,
3358	/* pfnSuspend */
3359	buslogicSuspend,
3360	/* pfnResume */
3361	buslogicResume,
3362	/* pfnAttach */
3363	buslogicAttach,
3364	/* pfnDetach */
3365	buslogicDetach,
3366	/* pfnQueryInterface. */
3367	NULL,
3368	/* pfnInitComplete */
3369	NULL,
3370	/* pfnPowerOff */
3371	buslogicPowerOff,
3372	/* pfnSoftReset */
3373	NULL,
3374	/* u32VersionEnd */
3375	PDM_DEVREG_VERSION
3376	};
3377
3378	#endif /* IN_RING3 */
3379	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
3380

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

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

Download in other formats: