DevBusLogic.cpp@ 43330

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

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

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

Download in other formats: