Chameleon

Chameleon Svn Source Tree

Root/branches/rewrite/i386/include/IOKit/scsi/IOSCSIBlockCommandsDevice.h

Source at commit 1129 created 12 years 11 months ago.
By meklort, Change options.o so that it reloads the system config as well. Also change it so that it uses that config for variables (NOTE: if the calue exists in chameleonConfig, it's used instead.
1/*␊
2 * Copyright (c) 1998-2009 Apple Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 * ␊
6 * This file contains Original Code and/or Modifications of Original Code␊
7 * as defined in and that are subject to the Apple Public Source License␊
8 * Version 2.0 (the 'License'). You may not use this file except in␊
9 * compliance with the License. Please obtain a copy of the License at␊
10 * http://www.opensource.apple.com/apsl/ and read it before using this␊
11 * file.␊
12 * ␊
13 * The Original Code and all software distributed under the License are␊
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.␊
18 * Please see the License for the specific language governing rights and␊
19 * limitations under the License.␊
20 * ␊
21 * @APPLE_LICENSE_HEADER_END@␊
22 */␊
23␊
24␊
25#ifndef _IOKIT_IO_SCSI_BLOCK_COMMANDS_DEVICE_H_␊
26#define _IOKIT_IO_SCSI_BLOCK_COMMANDS_DEVICE_H_␊
27␊
28#if defined(KERNEL) && defined(__cplusplus)␊
29␊
30//-----------------------------------------------------------------------------␊
31//␉Constants␊
32//-----------------------------------------------------------------------------␊
33␊
34// SBC power states as defined in T10:996D SCSI Block Commands - 3 (SBC-3)␊
35// Revision 8c, November 13, 1997, pages 10-11.␊
36enum␊
37{␊
38␉kSBCPowerStateSystemSleep ␉= 0,␊
39␉kSBCPowerStateSleep ␉␉= 1,␊
40␉kSBCPowerStateStandby ␉␉= 2,␊
41␉kSBCPowerStateIdle␉␉␉= 3,␊
42␉kSBCPowerStateActive␉␉= 4,␊
43␉kSBCNumPowerStates␉␉␉= 5␊
44};␊
45␊
46enum␊
47{␊
48␉kMediaStateUnlocked␉= 0,␊
49␉kMediaStateLocked ␉= 1␊
50};␊
51␊
52␊
53//-----------------------------------------------------------------------------␊
54//␉Includes␊
55//-----------------------------------------------------------------------------␊
56␊
57// General IOKit headers␊
58#include <IOKit/IOLib.h>␊
59#include <IOKit/IOMemoryDescriptor.h>␊
60#include <IOKit/IOService.h>␊
61#include <IOKit/IOUserClient.h>␊
62␊
63// Generic IOKit storage related headers␊
64#include <IOKit/storage/IOStorage.h>␊
65␊
66// SCSI Architecture Model Family includes␊
67#include <IOKit/scsi/IOSCSIPrimaryCommandsDevice.h>␊
68␊
69␊
70// Forward declaration for the SCSIBlockCommands that is used internally by the␊
71// IOSCSIBlockCommandsDevice class.␊
72class SCSIBlockCommands;␊
73␊
74//-----------------------------------------------------------------------------␊
75//␉Class Declaration␊
76//-----------------------------------------------------------------------------␊
77␊
78class IOSCSIBlockCommandsDevice : public IOSCSIPrimaryCommandsDevice␊
79{␊
80␉␊
81␉OSDeclareAbstractStructors ( IOSCSIBlockCommandsDevice )␊
82␉␊
83private:␊
84␉␊
85␊
86#ifndef __LP64__␊
87␉␊
88␉SCSIBlockCommands *␉␉fSCSIBlockCommandObject;␊
89␉SCSIBlockCommands *␉␉GetSCSIBlockCommandObject ( void );␊
90␉␊
91#endif␉/* !__LP64__ */␊
92␊
93␉IOReturn␉␉␉␉GetWriteCacheState ( IOMemoryDescriptor * ␉buffer,␊
94␉␉␉␉␉␉␉␉␉␉␉␉ UInt8␉␉␉␉␉modePageControlValue );␊
95␉␊
96␉static void␉␉␉␉AsyncReadWriteComplete ( SCSITaskIdentifier␉completedTask );␊
97␉␊
98protected:␊
99␉␊
100␉// Reserve space for future expansion.␊
101 struct IOSCSIBlockCommandsDeviceExpansionData␊
102␉{␊
103␉␉IONotifier *␉␉fPowerDownNotifier;␊
104␉␉bool␉␉␉␉fWriteCacheEnabled;␊
105␉␉bool␉␉␉␉fDeviceIsShared;␊
106␉␉UInt64␉␉␉␉fMediumBlockCount64;␊
107␉␉bool␉␉␉␉fDeviceHasSATTranslation;␊
108␉␉bool␉␉␉␉fProtocolSpecificPowerControl;␊
109␉␉bool␉␉␉␉fRequiresEjectWithStartStopUnit;␊
110␉};␊
111 IOSCSIBlockCommandsDeviceExpansionData * fIOSCSIBlockCommandsDeviceReserved;␊
112␉␊
113␉#define fPowerDownNotifier␉fIOSCSIBlockCommandsDeviceReserved->fPowerDownNotifier␊
114␉#define fWriteCacheEnabled␉fIOSCSIBlockCommandsDeviceReserved->fWriteCacheEnabled␊
115␉␊
116␉// The fDeviceIsShared is used to indicate whether this device exists on a Physical␊
117␉// Interconnect that allows multiple initiators to access it. This is used mainly␊
118␉// by the power management code to not send power state related START_STOP_UNIT␊
119␉// commands to the device.␊
120␉// The fDeviceIsShared value is also used to prevent power state commands from being␊
121␉// sent to manual eject device since these devices behave better when allowed to␊
122␉// manage their own power.␊
123␉#define fDeviceIsShared␉fIOSCSIBlockCommandsDeviceReserved->fDeviceIsShared␊
124␉␊
125␉// The fMediumBlockCount64 provides support for 64 bit LBAs and␊
126␉// replaces fMediumBlockCount which only supports 32 bits.␊
127␉// This value should not be directly accessed and instead the member routine ␊
128␉// ReportMediumTotalBlockCount() should be used to retrieve it and the member routine␊
129␉// SetMediumCharacteristics() should be used to set it.␊
130␉#define fMediumBlockCount64␉fIOSCSIBlockCommandsDeviceReserved->fMediumBlockCount64␊
131␉␊
132␉#define fDeviceHasSATTranslation fIOSCSIBlockCommandsDeviceReserved->fDeviceHasSATTranslation␊
133␉␊
134␉// Device support protocol specific power off␊
135␉#define fProtocolSpecificPowerControl fIOSCSIBlockCommandsDeviceReserved->fProtocolSpecificPowerControl␊
136␉␊
137␉// Device requires START_STOP_UNIT for ejects, regardless if PREVENT_ALLOW_MEIDUMREMOVAL␊
138␉// failed. ␊
139␉#define fRequiresEjectWithStartStopUnit fIOSCSIBlockCommandsDeviceReserved->fRequiresEjectWithStartStopUnit␊
140␉␊
141private:␊
142␉/* OBSOLETE. Use IOSCSIPrimaryCommandsDevice::Get/SetANSIVersion */␊
143␉UInt8␉␉␉␉fANSIVersion;␊
144␊
145protected:␊
146␉// ---- Device Characteristics ----␊
147␉bool␉␉␉␉fMediaIsRemovable;␊
148␉␊
149␉// ---- Medium Characteristics ----␊
150␉bool␉␉␉␉fMediumPresent;␊
151␉␊
152private:␊
153␉// The byte count of each physical block on the medium.␊
154␉// This value should not be directly accessed and instead the member routine ␊
155␉// ReportMediumBlockSize() should be used to retrieve it and the member routine␊
156␉// SetMediumCharacteristics() should be used to set it.␊
157␉UInt32␉␉␉␉fMediumBlockSize;␊
158␉␊
159␉// The total number of blocks of fMediumBlockSize on the medium.␊
160␉// OBSOLETE. Use fMediumBlockCount64 instead which allows for support of␊
161␉// devices that have 33 through 64 bit LBA values.␊
162␉UInt32␉␉␉␉fMediumBlockCount;␊
163␉␊
164protected:␊
165␉// Whether the installed medium is protected from writes␊
166␉bool␉␉␉␉fMediumIsWriteProtected;␊
167␉␊
168␉// Whether user removal of medium has been prevented␉␊
169␉bool␉␉␉␉fMediumRemovalPrevented;␊
170␉␊
171␉// Indicates whether this is a known manual eject device␊
172␉bool␉␉␉␉fKnownManualEject;␊
173␉␊
174␉// Polling thread variables␊
175␉thread_call_t␉␉fPollingThread;␊
176␉UInt32␉␉␉␉fPollingMode;␊
177␉enum␊
178␉{␊
179␉␉kPollingMode_Suspended␉␉= 0,␊
180␉␉kPollingMode_NewMedia ␉␉= 1,␊
181␉␉kPollingMode_MediaRemoval␉= 2␊
182␉};␊
183␉␊
184␉// ---- Methods for controlling the current state of device support ----␊
185␉virtual bool␉␉InitializeDeviceSupport ( void );␊
186␉virtual void␉␉StartDeviceSupport ( void );␊
187␉virtual void␉␉SuspendDeviceSupport ( void );␊
188␉virtual void␉␉ResumeDeviceSupport ( void );␊
189␉virtual void␉␉StopDeviceSupport ( void );␊
190␉virtual void␉␉TerminateDeviceSupport ( void );␊
191␊
192␉virtual void ␉␉free ( void );␊
193␊
194#ifndef __LP64__␊
195␉␊
196␉// This method will retrieve the SCSI Primary Command Set object for␊
197␉// the class. For subclasses, this will be overridden using a␊
198␉// dynamic cast on the subclasses base command set object.␊
199␉virtual SCSIPrimaryCommands *␉GetSCSIPrimaryCommandObject ( void );␊
200␉␊
201␉virtual bool␉␉CreateCommandSetObjects ( void );␊
202␉virtual void␉␉FreeCommandSetObjects ( void );␊
203␉␊
204#endif␉/* !__LP64__ */␊
205␊
206␉virtual bool␉␉ClearNotReadyStatus ( void );␊
207␉virtual void ␉␉CreateStorageServiceNub ( void );␊
208␉virtual bool␉␉DetermineDeviceCharacteristics ( void );␊
209␉␊
210␉// ---- Methods used for controlling the polling thread ----␊
211␉virtual void␉␉ProcessPoll ( void );␊
212␉virtual void␉␉EnablePolling ( void );␊
213␉virtual void␉␉DisablePolling ( void );␊
214␉␊
215␉// Main and support methods for polling for new Media␊
216␉virtual void␉␉PollForNewMedia ( void );␊
217␉virtual bool␉␉DetermineMediaPresence ( void );␊
218␉virtual bool␉␉PreventMediumRemoval ( void );␊
219␉virtual bool␉␉DetermineMediumCapacity (␊
220␉␉␉␉␉␉␉UInt64 * ␉␉␉␉blockSize,␊
221␉␉␉␉␉␉␉UInt64 * ␉␉␉␉blockCount );␊
222␉virtual bool␉␉DetermineMediumWriteProtectState ( void );␊
223␉␊
224␉// Main and support methods for polling for Media removal␊
225␉virtual void␉␉PollForMediaRemoval ( void );␊
226␉␊
227␉// ---- Methods used for handling medium characteristics ----␊
228␉␊
229␉// OBSOLETE - Use the version compatible with 64 bit LBAs instead.␊
230␉virtual void␉␉SetMediumCharacteristics (␊
231␉␉␉␉␉␉␉UInt32 ␉␉␉␉␉blockSize,␊
232␉␉␉␉␉␉␉UInt32 ␉␉␉␉␉blockCount );␊
233␊
234␉void␉␉␉␉SetMediumCharacteristics (␊
235␉␉␉␉␉␉␉UInt64 ␉␉␉␉␉blockSize,␊
236␉␉␉␉␉␉␉UInt64 ␉␉␉␉␉blockCount );␊
237␉␊
238␉virtual void␉␉ResetMediumCharacteristics ( void );␊
239␊
240␉virtual IOReturn␉IssueRead (␊
241␉␉␉␉␉␉␉IOMemoryDescriptor *␉buffer,␊
242␉␉␉␉␉␉ ␉UInt64␉␉␉␉␉startBlock,␊
243␉␉␉␉␉ ␉␉UInt64␉␉␉␉␉blockCount );␊
244␉␊
245␉virtual IOReturn␉IssueRead (␊
246␉␉␉␉␉␉␉IOMemoryDescriptor *␉buffer,␊
247␉␉␉␉␉ ␉␉UInt64␉␉␉␉␉startBlock,␊
248␉␉␉␉␉ ␉␉UInt64␉␉␉␉␉blockCount,␊
249␉␉␉␉␉ ␉␉void * ␉␉␉␉␉clientData );␊
250␉␊
251␉virtual IOReturn␉IssueWrite (␊
252␉␉␉␉␉␉␉IOMemoryDescriptor *␉buffer,␊
253␉␉␉␉␉␉␉UInt64␉␉␉␉␉startBlock,␊
254␉␉␉␉␉ ␉␉UInt64␉␉␉␉␉blockCount );␊
255␉␊
256␉virtual IOReturn␉IssueWrite (␊
257␉␉␉␉␉␉␉IOMemoryDescriptor *␉buffer,␊
258␉␉␉␉␉␉ ␉UInt64␉␉␉␉␉startBlock,␊
259␉␉␉␉␉ ␉␉UInt64␉␉␉␉␉blockCount,␊
260␉␉␉␉␉␉␉void * ␉␉␉␉␉clientData );␊
261␉␊
262␉// ----- Power Management Support ------␊
263␉␊
264␉// We override this method to set our power states and register ourselves␊
265␉// as a power policy maker.␊
266␉virtual void ␉␉InitializePowerManagement ( IOService * provider );␊
267␉␊
268␉// We override this method so that when we register for power management,␊
269␉// we go to our active power state (which the drive is definitely in␊
270␉// at startup time).␊
271␉virtual UInt32␉␉GetInitialPowerState ( void );␊
272␉␊
273␉// We override this method in order to provide the number of transitions␊
274␉// from Fully active to Sleep state so that the idle timer can be adjusted␊
275␉// to the appropriate time period based on the disk spindown time set in␊
276␉// the Energy Saver prefs panel.␊
277␉virtual UInt32␉␉GetNumberOfPowerStateTransitions ( void );␊
278␉␊
279␉// The TicklePowerManager method is called to tell the power manager that␊
280␉// the device needs to be in a certain power state to handle requests.␊
281␉virtual void␉␉TicklePowerManager ( void );␊
282␉␊
283␉// The HandlePowerChange method is the state machine for power management.␊
284␉// It is guaranteed to be on its own thread of execution (different from␊
285␉// the power manager thread AND the workloop thread. This routine can␊
286␉// send sync or async calls to the drive without worrying about threading␊
287␉// issues.␊
288␉virtual void␉␉HandlePowerChange ( void );␊
289␉␊
290␉// The HandleCheckPowerState (void) method is on the serialized side of the␊
291␉// command gate and can change member variables safely without␊
292␉// multi-threading issues. It's main purpose is to call the superclass'␊
293␉// HandleCheckPowerState ( UInt32 maxPowerState ) with the max power state␊
294␉// the class registered with.␊
295␉virtual void␉␉HandleCheckPowerState ( void );␊
296␉␊
297␉// The VerifyMediumPresence method is called to see if the medium which we␊
298␉// anticipated being there is still there.␊
299␉virtual bool␉␉VerifyMediumPresence ( void );␊
300␉␊
301public:␊
302␉␊
303␉static ␉void␉␉sProcessPoll ( void * pdtDriver, void * refCon );␊
304␉␊
305␉// ---- Methods for controlling the device ----␊
306␉virtual IOReturn␉SyncReadWrite (␊
307␉␉␉␉␉␉␉IOMemoryDescriptor *␉buffer,␊
308␉␉␉␉␉␉␉UInt64␉␉␉␉␉startBlock,␊
309␉␉␉␉␉␉␉UInt64␉␉␉␉␉blockCount,␊
310␉␉␉␉␉␉␉UInt64␉␉␉␉␉blockSize );␊
311␉␊
312␉virtual IOReturn␉AsyncReadWrite (␊
313␉␉␉␉␉␉␉IOMemoryDescriptor *␉buffer,␊
314␉␉␉␉␉␉␉UInt64␉␉␉␉␉startBlock,␊
315␉␉␉␉␉␉␉UInt64␉␉␉␉␉blockCount,␊
316␉␉␉␉␉␉␉UInt64␉␉␉␉␉blockSize,␊
317␉␉␉␉␉␉␉void * ␉␉␉␉␉clientData );␊
318␉␊
319␉IOReturn␉GetWriteCacheState ( bool * enabled );␉␊
320␉IOReturn␉SetWriteCacheState ( bool enabled );␊
321␉void␉␉DetermineMediumGeometry ( void );␊
322␉␊
323␉// ---- Methods for controlling medium state ----␊
324␉virtual IOReturn␉EjectTheMedium ( void );␊
325␉virtual IOReturn␉LockUnlockMedium ( bool doLock );␊
326␉virtual IOReturn␉SynchronizeCache ( void );␊
327␉␊
328␉// ---- Methods for controlling media format ----␊
329␉virtual IOReturn␉FormatMedium (␊
330␉␉␉␉␉␉␉UInt64 ␉␉␉␉␉blockCount,␊
331␉␉␉␉␉␉␉UInt64 ␉␉␉␉␉blockSize );␊
332␉virtual UInt32␉␉GetFormatCapacities (␊
333␉␉␉␉␉␉␉UInt64 * ␉␉␉␉capacities,␊
334␉␉␉ ␉␉␉␉UInt32 ␉␉␉␉capacitiesMaxCount ) const;␊
335␉␊
336␉// ---- Query methods to report device characteristics ----␊
337␉␊
338␉// Report the maximum number of blocks that the device can handle per␊
339␉// read or write. A value of 0 (zero) indicates there is no limit aside␊
340␉// from the size of the method's return parameter.␊
341␉virtual UInt64␉␉ReportDeviceMaxBlocksReadTransfer ( void );␊
342␉virtual UInt64␉␉ReportDeviceMaxBlocksWriteTransfer ( void );␊
343␉␊
344␉// Report whether the device supports removal of the media.␊
345␉virtual bool␉␉ReportDeviceMediaRemovability ( void );␊
346␉␊
347␉// ---- Query methods to report installed medium characteristics ----␊
348␉virtual UInt64␉␉ReportMediumBlockSize ( void );␊
349␉virtual UInt64␉␉ReportMediumTotalBlockCount ( void );␊
350␉virtual bool␉␉ReportMediumWriteProtection ( void );␊
351␉␊
352␉␊
353protected:␊
354␉␊
355␊
356#ifndef __LP64__␊
357␉␊
358␉// Command methods to access all commands available to SBC based devices.␊
359␉virtual bool ERASE_10 (␊
360␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
361␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉ERA,␊
362␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
363␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
364␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
365␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
366␊
367␉virtual bool ERASE_12 (␊
368␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
369␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉ERA,␊
370␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
371␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
372␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉TRANSFER_LENGTH,␊
373␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
374␊
375␉virtual bool FORMAT_UNIT (␊
376␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
377␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
378␉␉␉␉␉␉IOByteCount␉␉␉␉␉defectListSize,␊
379␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FMTDATA,␊
380␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉CMPLST,␊
381␉␉␉␉␉␉SCSICmdField3Bit ␉␉␉DEFECT_LIST_FORMAT,␊
382␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉VENDOR_SPECIFIC,␊
383␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉INTERLEAVE,␊
384␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
385␉␊
386␉// Defined in SBC-2 Section 5.41␊
387␉bool FORMAT_UNIT (␊
388␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
389␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
390␉␉␉␉␉␉IOByteCount␉␉␉␉␉defectListSize,␊
391␉␉␉␉␉␉SCSICmdField1Bit␉␉␉FMTPINFO,␊
392␉␉␉␉␉␉SCSICmdField1Bit␉␉␉RTO_REQ,␊
393␉␉␉␉␉␉SCSICmdField1Bit␉␉␉LONGLIST,␊
394␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FMTDATA, ␊
395␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉CMPLST,␊
396␉␉␉␉␉␉SCSICmdField3Bit ␉␉␉DEFECT_LIST_FORMAT, ␊
397␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉VENDOR_SPECIFIC, ␊
398␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
399␉ ␉ ␊
400␉virtual bool LOCK_UNLOCK_CACHE (␊
401␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
402␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉LOCK,␊
403␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
404␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
405␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉NUMBER_OF_BLOCKS,␊
406␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
407␊
408␉// Defined in SBC-2 section 5.5␊
409␉bool LOCK_UNLOCK_CACHE (␊
410␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
411␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉LOCK,␊
412␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
413␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉NUMBER_OF_BLOCKS,␊
414␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
415␊
416␉bool LOCK_UNLOCK_CACHE_16 (␊
417␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
418␉␉␉␉␉␉SCSICmdField1Bit␉␉␉LOCK,␊
419␉␉␉␉␉␉SCSICmdField8Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
420␉␉␉␉␉␉SCSICmdField4Byte␉␉␉NUMBER_OF_BLOCKS,␊
421␉␉␉␉␉␉SCSICmdField1Byte␉␉␉CONTROL );␊
422␉␉␉␉␉␉␊
423␉virtual bool MEDIUM_SCAN (␊
424␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
425␉␉␉ ␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
426␉␉ ␉␉␉␉SCSICmdField1Bit ␉␉␉WBS,␊
427␉␉ ␉␉␉␉SCSICmdField1Bit ␉␉␉ASA,␊
428␉␉ ␉␉␉␉SCSICmdField1Bit ␉␉␉PSD,␊
429␉␉ ␉␉␉␉SCSICmdField1Bit ␉␉␉PRA,␊
430␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
431␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
432␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉PARAMETER_LIST_LENGTH,␊
433␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
434␊
435␉virtual bool PREFETCH (␊
436␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
437␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉IMMED,␊
438␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
439␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
440␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
441␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
442␊
443␉// Defined in SBC-2 section 5.7␊
444␉bool PREFETCH (␊
445␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
446␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉IMMED,␊
447␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
448␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
449␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
450␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
451␊
452␉bool PREFETCH_16 (␊
453␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
454␉␉␉␉␉␉SCSICmdField1Bit␉␉␉IMMED,␊
455␉␉␉␉␉␉SCSICmdField8Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
456␉␉␉␉␉␉SCSICmdField4Byte␉␉␉TRANSFER_LENGTH,␊
457␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
458␉␉␉␉␉␉SCSICmdField1Byte␉␉␉CONTROL );␊
459␉␊
460␉virtual bool READ_6 (␊
461␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
462␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
463␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
464␉␉␉␉␉␉SCSICmdField21Bit ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
465␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉TRANSFER_LENGTH,␊
466␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
467␊
468#endif␉/* __LP64__ */␊
469␉␊
470␉virtual bool READ_10 (␊
471␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
472␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
473␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
474␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
475␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
476␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
477␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
478␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
479␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
480␊
481␉// Defined in SBC-2 section 5.10␊
482␉bool READ_10 (␊
483␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
484␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
485␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
486␉␉␉␉␉␉SCSICmdField3Bit ␉␉␉RDPROTECT,␊
487␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
488␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
489␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA_NV,␊
490␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
491␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
492␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
493␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
494␊
495␉virtual bool READ_12 (␊
496␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
497␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
498␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
499␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
500␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
501␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
502␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
503␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉TRANSFER_LENGTH,␊
504␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
505␊
506␉// Defined in SBC-2 section 5.11␊
507␉bool READ_12 (␊
508␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
509␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
510␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
511␉␉␉␉␉␉SCSICmdField3Bit␉␉␉RDPROTECT,␊
512␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
513␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
514␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA_NV,␊
515␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
516␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉TRANSFER_LENGTH,␊
517␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
518␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
519␊
520␉bool READ_16 (␊
521␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
522␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
523␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
524␉␉␉␉␉␉SCSICmdField3Bit␉␉␉RDPROTECT,␊
525␉␉␉␉␉␉SCSICmdField1Bit␉␉␉DPO,␊
526␉␉␉␉␉␉SCSICmdField1Bit␉␉␉FUA,␊
527␉␉␉␉␉␉SCSICmdField1Bit␉␉␉FUA_NV,␊
528␉␉␉␉␉␉SCSICmdField8Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
529␉␉␉␉␉␉SCSICmdField4Byte␉␉␉TRANSFER_LENGTH,␊
530␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
531␉␉␉␉␉␉SCSICmdField1Byte␉␉␉CONTROL );␊
532␉␊
533␉virtual bool READ_CAPACITY (␊
534␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
535␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
536␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
537␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
538␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉PMI,␊
539␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
540␉␊
541␉bool READ_CAPACITY_16 (␊
542␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
543␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
544␉␉␉␉␉␉SCSICmdField8Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
545␉␉␉␉␉␉SCSICmdField4Byte␉␉␉ALLOCATION_LENGTH,␊
546␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉PMI,␊
547␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
548␊
549#ifndef __LP64__␊
550␊
551␉virtual bool READ_DEFECT_DATA_10 (␊
552␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
553␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
554␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉PLIST,␊
555␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉GLIST,␊
556␉␉␉␉␉␉SCSICmdField3Bit ␉␉␉DEFECT_LIST_FORMAT,␊
557␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉ALLOCATION_LENGTH,␊
558␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
559␊
560␉virtual bool READ_DEFECT_DATA_12 (␊
561␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
562␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
563␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉PLIST,␊
564␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉GLIST,␊
565␉␉␉␉␉␉SCSICmdField3Bit ␉␉␉DEFECT_LIST_FORMAT,␊
566␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉ALLOCATION_LENGTH,␊
567␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
568␊
569␉virtual bool READ_GENERATION (␊
570␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
571␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
572␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
573␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
574␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉ALLOCATION_LENGTH,␊
575␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
576␊
577␉virtual bool READ_LONG (␊
578␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
579␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
580␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉CORRCT,␊
581␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
582␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
583␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉BYTE_TRANSFER_LENGTH,␊
584␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
585␊
586␉bool READ_LONG_16 (␊
587␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
588␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
589␉␉␉␉␉␉SCSICmdField8Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
590␉␉␉␉␉␉SCSICmdField2Byte␉␉␉BYTE_TRANSFER_LENGTH,␊
591␉␉␉␉␉␉SCSICmdField1Bit␉␉␉CORRCT,␊
592␉␉␉␉␉␉SCSICmdField1Byte␉␉␉CONTROL );␊
593␉␉␊
594␉virtual bool READ_UPDATED_BLOCK_10 (␊
595␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
596␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
597␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
598␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
599␉␉␉␉␉ ␉SCSICmdField1Bit ␉␉␉RELADR,␊
600␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
601␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉LATEST,␊
602␉␉␉␉␉ ␉SCSICmdField15Bit ␉␉␉GENERATION_ADDRESS,␊
603␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
604␊
605␉virtual bool REASSIGN_BLOCKS (␊
606␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
607␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
608␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
609␊
610␉// Defined in SBC-2 section 5.20␊
611␉bool REASSIGN_BLOCKS (␊
612␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
613␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
614␉␉␉␉␉␉SCSICmdField1Bit␉␉␉LONGLBA,␊
615␉␉␉␉␉␉SCSICmdField1Bit␉␉␉LONGLIST,␊
616␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
617␉␊
618␉virtual bool REBUILD (␊
619␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
620␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
621␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
622␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
623␉␉␉␉␉ ␉SCSICmdField1Bit ␉␉␉INTDATA,␊
624␉␉␉␉␉␉SCSICmdField2Bit ␉␉␉PORT_CONTROL,␊
625␉␉␉␉␉ ␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
626␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉REBUILD_LENGTH,␊
627␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉PARAMETER_LIST_LENGTH,␊
628␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
629␉␊
630␉virtual bool REGENERATE (␊
631␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
632␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
633␉␉␉␉␉␉SCSICmdField1Bit␉␉␉DPO,␊
634␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
635␉␉␉␉␉ ␉SCSICmdField1Bit ␉␉␉INTDATA,␊
636␉␉␉␉␉ ␉SCSICmdField2Bit ␉␉␉PORT_CONTROL,␊
637␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
638␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉REBUILD_LENGTH,␊
639␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉PARAMETER_LIST_LENGTH,␊
640␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
641␊
642␉virtual bool REZERO_UNIT (␊
643␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
644␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
645␊
646␉virtual bool SEARCH_DATA_EQUAL_10 (␊
647␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
648␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
649␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉INVERT,␊
650␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉SPNDAT,␊
651␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
652␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
653␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉NUMBER_OF_BLOCKS_TO_SEARCH,␊
654␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
655␊
656␉virtual bool SEARCH_DATA_HIGH_10 (␊
657␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
658␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
659␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉INVERT,␊
660␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉SPNDAT,␊
661␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
662␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
663␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉NUMBER_OF_BLOCKS_TO_SEARCH,␊
664␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
665␊
666␉virtual bool SEARCH_DATA_LOW_10 (␊
667␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
668␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
669␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉INVERT,␊
670␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉SPNDAT,␊
671␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
672␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
673␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉NUMBER_OF_BLOCKS_TO_SEARCH,␊
674␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
675␊
676␉virtual bool SEEK_6 (␊
677␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
678␉␉␉␉␉␉SCSICmdField21Bit ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
679␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
680␊
681␉virtual bool SEEK_10 (␊
682␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
683␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
684␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
685␊
686␉virtual bool SET_LIMITS_10 (␊
687␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
688␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RDINH,␊
689␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉WRINH,␊
690␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
691␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉NUMBER_OF_BLOCKS,␊
692␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
693␊
694␉virtual bool SET_LIMITS_12 (␊
695␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
696␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RDINH,␊
697␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉WRINH,␊
698␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
699␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉NUMBER_OF_BLOCKS,␊
700␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
701␊
702#endif␉/* __LP64__ */␊
703␉␊
704␉virtual bool START_STOP_UNIT (␊
705␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
706␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉IMMED,␊
707␉␉␉␉␉␉SCSICmdField4Bit ␉␉␉POWER_CONDITIONS,␊
708␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉LOEJ,␊
709␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉START,␊
710␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
711␊
712␉virtual bool SYNCHRONIZE_CACHE (␊
713␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
714␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉IMMED,␊
715␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
716␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
717␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉NUMBER_OF_BLOCKS,␊
718␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
719␊
720␉// Defined in SBC-2 section 5.22␊
721␉bool SYNCHRONIZE_CACHE (␊
722␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
723␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉IMMED,␊
724␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉SYNC_NV,␊
725␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
726␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
727␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉NUMBER_OF_BLOCKS,␊
728␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
729␊
730␉bool SYNCRONIZE_CACHE_16 (␊
731␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
732␉␉␉␉␉␉SCSICmdField1Bit␉␉␉SYNC_NV,␊
733␉␉␉␉␉␉SCSICmdField1Bit␉␉␉IMMED,␊
734␉␉␉␉␉␉SCSICmdField8Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
735␉␉␉␉␉␉SCSICmdField4Byte␉␉␉NUMBER_OF_BLOCKS,␊
736␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
737␉␉␉␉␉␉SCSICmdField1Byte␉␉␉CONTROL );␊
738␉␉␉␉␉␉␊
739#ifndef __LP64__␊
740␊
741␉virtual bool UPDATE_BLOCK (␊
742␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
743␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
744␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
745␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
746␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
747␊
748␉virtual bool VERIFY_10 (␊
749␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
750␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
751␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BLKVFY,␊
752␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BYTCHK,␊
753␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
754␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
755␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉VERIFICATION_LENGTH,␊
756␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
757␉␊
758␉// Defined in SBC-2 section 5.24␊
759␉bool VERIFY_10 (␊
760␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
761␉␉␉␉␉␉SCSICmdField3Bit ␉␉␉VRPROTECT,␊
762␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
763␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BYTCHK,␊
764␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
765␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
766␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉VERIFICATION_LENGTH,␊
767␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
768␊
769␉virtual bool VERIFY_12 (␊
770␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
771␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
772␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BLKVFY,␊
773␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BYTCHK,␊
774␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
775␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
776␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉VERIFICATION_LENGTH,␊
777␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
778␊
779␉// Defined in SBC-2 section 5.25␊
780␉bool VERIFY_12 (␊
781␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
782␉␉␉␉␉␉SCSICmdField3Bit ␉␉␉VRPROTECT,␊
783␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
784␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BYTCHK,␊
785␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
786␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
787␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉VERIFICATION_LENGTH,␊
788␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
789␊
790␉bool VERIFY_16 (␊
791␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
792␉␉␉␉␉␉SCSICmdField3Bit␉␉␉VRPROTECT,␊
793␉␉␉␉␉␉SCSICmdField1Bit␉␉␉DPO,␊
794␉␉␉␉␉␉SCSICmdField1Bit␉␉␉BYTCHK,␊
795␉␉␉␉␉␉SCSICmdField8Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
796␉␉␉␉␉␉SCSICmdField4Byte␉␉␉VERIFICATION_LENGTH,␊
797␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
798␉␉␉␉␉␉SCSICmdField1Byte␉␉␉CONTROL );␊
799␉␊
800␉virtual bool WRITE_6 (␊
801␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
802␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
803␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
804␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
805␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉TRANSFER_LENGTH,␊
806␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
807␉␊
808#endif␉/* __LP64__ */␊
809␊
810␉virtual bool WRITE_10 (␊
811␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
812␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
813␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
814␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
815␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
816␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉EBP,␊
817␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
818␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
819␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
820␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
821␊
822␉// Defined in SBC-2 section 5.29␊
823␉bool WRITE_10 (␊
824␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
825␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
826␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
827␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
828␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
829␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
830␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA_NV,␊
831␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
832␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
833␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
834␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
835␊
836␉virtual bool WRITE_12 (␊
837␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
838␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
839␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
840␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
841␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
842␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉EBP,␊
843␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
844␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
845␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉TRANSFER_LENGTH,␊
846␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
847␊
848␉// Defined in SBC-2 section 5.30␊
849␉bool WRITE_12 (␊
850␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
851␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
852␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
853␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
854␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
855␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
856␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA_NV,␊
857␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
858␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
859␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉TRANSFER_LENGTH,␊
860␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
861␊
862␉bool WRITE_16 (␊
863␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
864␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
865␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
866␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
867␉␉␉␉␉␉SCSICmdField1Bit␉␉␉DPO,␊
868␉␉␉␉␉␉SCSICmdField1Bit␉␉␉FUA,␊
869␉␉␉␉␉␉SCSICmdField1Bit␉␉␉FUA_NV,␊
870␉␉␉␉␉␉SCSICmdField8Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
871␉␉␉␉␉␉SCSICmdField4Byte␉␉␉TRANSFER_LENGTH,␊
872␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
873␉␉␉␉␉␉SCSICmdField1Byte␉␉␉CONTROL );␊
874␊
875#ifndef __LP64__␊
876␉␉␉␉␊
877␉virtual bool WRITE_AND_VERIFY_10 (␊
878␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
879␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
880␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
881␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
882␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉EBP,␊
883␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BYTCHK,␊
884␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
885␉␉␉␉␉␉SCSICmdField4Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
886␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
887␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
888␊
889␉// Defined in SBC-2 section 5.33␊
890␉bool WRITE_AND_VERIFY_10 (␊
891␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
892␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
893␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
894␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
895␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
896␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BYTCHK,␊
897␉␉␉␉␉␉SCSICmdField4Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
898␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
899␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
900␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
901␊
902␉virtual bool WRITE_AND_VERIFY_12 (␊
903␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
904␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
905␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
906␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
907␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉EBP,␊
908␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BYTCHK,␊
909␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
910␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
911␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉TRANSFER_LENGTH,␊
912␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
913␉␊
914␉// Defined in SBC-2 section 5.34␊
915␉bool WRITE_AND_VERIFY_12 (␊
916␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
917␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
918␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
919␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
920␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
921␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BYTCHK,␊
922␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
923␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉TRANSFER_LENGTH,␊
924␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
925␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
926␊
927␉bool WRITE_AND_VERIFY_16 (␊
928␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
929␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
930␉␉␉␉␉␉UInt32␉␉␉␉␉␉blockSize,␊
931␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
932␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
933␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉BYTCHK,␊
934␉␉␉␉␉␉SCSICmdField8Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
935␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉TRANSFER_LENGTH,␊
936␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
937␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
938␊
939␊
940␉virtual bool WRITE_LONG (␊
941␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
942␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
943␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
944␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
945␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
946␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
947␊
948␉bool WRITE_LONG_16 (␊
949␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
950␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
951␉␉␉␉␉␉SCSICmdField8Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
952␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
953␉␉␉␉␉␉SCSICmdField1Bit␉␉␉CORRCT,␊
954␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
955␊
956␉virtual bool WRITE_SAME (␊
957␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
958␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
959␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉PBDATA,␊
960␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉LBDATA,␊
961␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉RELADR,␊
962␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
963␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
964␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
965␊
966␉// Defined in SBC-2 section 5.39␊
967␉bool WRITE_SAME (␊
968␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
969␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
970␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
971␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉PBDATA,␊
972␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉LBDATA,␊
973␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
974␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
975␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
976␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
977␊
978␉bool WRITE_SAME_16 (␊
979␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
980␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
981␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
982␉␉␉␉␉␉SCSICmdField1Bit␉␉␉PBDATA,␊
983␉␉␉␉␉␉SCSICmdField1Bit␉␉␉LBDATA,␊
984␉␉␉␉␉␉SCSICmdField8Byte␉␉␉LOGICAL_BLOCK_ADDRESS,␊
985␉␉␉␉␉␉SCSICmdField4Byte␉␉␉TRANSFER_LENGTH,␊
986␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
987␉␉␉␉␉␉SCSICmdField1Byte␉␉␉CONTROL );␊
988␊
989␉virtual bool XDREAD (␊
990␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
991␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
992␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
993␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
994␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
995␊
996␉// Defined in SBC-2 section 5.42␊
997␉bool XDREAD (␊
998␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
999␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
1000␉␉␉␉␉␉SCSICmdField1Bit␉␉␉XORPINFO,␊
1001␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
1002␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
1003␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
1004␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
1005␊
1006␉virtual bool XDWRITE (␊
1007␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
1008␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
1009␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
1010␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
1011␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DISABLE_WRITE,␊
1012␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
1013␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
1014␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
1015␊
1016␉// Defined in SBC-2 section 5.43␊
1017␉bool XDWRITE (␊
1018␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
1019␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
1020␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
1021␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
1022␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
1023␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DISABLE_WRITE,␊
1024␉␉␉␉␉␉SCSICmdField1Bit␉␉␉FUA_NV,␊
1025␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
1026␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
1027␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
1028␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
1029␊
1030␉virtual bool XDWRITE_EXTENDED (␊
1031␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
1032␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
1033␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉TABLE_ADDRESS,␊
1034␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
1035␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
1036␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DISABLE_WRITE,␊
1037␉␉␉␉␉␉SCSICmdField2Bit ␉␉␉PORT_CONTROL,␊
1038␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
1039␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉SECONDARY_BLOCK_ADDRESS,␊
1040␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉TRANSFER_LENGTH,␊
1041␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉SECONDARY_ADDRESS,␊
1042␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
1043␉␊
1044␉// Defined in SBC-2 section 5.46␊
1045␉bool XDWRITEREAD_10 (␊
1046␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
1047␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
1048␉␉␉␉␉␉SCSICmdField3Bit␉␉␉WRPROTECT,␊
1049␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
1050␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
1051␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DISABLE_WRITE,␊
1052␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA_NV,␊
1053␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉XORPINFO,␊
1054␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
1055␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
1056␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
1057␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
1058␉␊
1059␉virtual bool XPWRITE (␊
1060␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
1061␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
1062␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
1063␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
1064␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
1065␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
1066␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
1067␊
1068␉// Defined in SBC-2 section 5.48␊
1069␉bool XPWRITE (␊
1070␉␉␉␉␉␉SCSITaskIdentifier␉␉␉request,␊
1071␉␉␉␉␉␉IOMemoryDescriptor *␉␉dataBuffer,␊
1072␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉DPO,␊
1073␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA,␊
1074␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉FUA_NV,␊
1075␉␉␉␉␉␉SCSICmdField1Bit ␉␉␉XORPINFO,␊
1076␉␉␉␉␉␉SCSICmdField4Byte ␉␉␉LOGICAL_BLOCK_ADDRESS,␊
1077␉␉␉␉␉␉SCSICmdField5Bit␉␉␉GROUP_NUMBER,␊
1078␉␉␉␉␉␉SCSICmdField2Byte ␉␉␉TRANSFER_LENGTH,␊
1079␉␉␉␉␉␉SCSICmdField1Byte ␉␉␉CONTROL );␊
1080␊
1081#endif␉/* __LP64__ */␊
1082␉␊
1083␉␊
1084␉/* Added with 10.2 */␉␊
1085␉OSMetaClassDeclareReservedUsed ( IOSCSIBlockCommandsDevice, 1 );␊
1086␉␊
1087public:␊
1088␉␊
1089␉virtual IOReturn␉PowerDownHandler (␉void * ␉␉␉refCon,␊
1090␉␉␉␉␉␉␉␉␉␉␉UInt32 ␉␉␉messageType,␊
1091␉␉␉␉␉␉␉␉␉␉␉IOService * ␉provider,␊
1092␉␉␉␉␉␉␉␉␉␉␉void * ␉␉␉messageArgument,␊
1093␉␉␉␉␉␉␉␉␉␉␉vm_size_t ␉␉argSize );␊
1094␉␊
1095␊
1096␉/* Added with 10.2 */␉␊
1097␉OSMetaClassDeclareReservedUsed ( IOSCSIBlockCommandsDevice, 2 );␊
1098␉␊
1099protected:␊
1100␉␊
1101␉virtual␉void␉␉SetMediumIcon ( void );␊
1102␉␊
1103␉␊
1104␉/* Added with 10.3.3 */␉␉␊
1105␉OSMetaClassDeclareReservedUsed ( IOSCSIBlockCommandsDevice, 3 );␊
1106␉␊
1107protected:␊
1108␊
1109␉virtual␉void AsyncReadWriteCompletion ( SCSITaskIdentifier completedTask );␊
1110␉␊
1111␉␊
1112␉/* Added with 10.6.0 */␊
1113␉OSMetaClassDeclareReservedUsed ( IOSCSIBlockCommandsDevice, 4 );␊
1114␉␊
1115public:␊
1116␉␊
1117␉virtual␉IOReturn AsyncReadWrite (␊
1118␉␉␉␉␉␉␉IOMemoryDescriptor *␉buffer,␊
1119␉␉␉␉␉␉␉UInt64␉␉␉␉␉startBlock,␊
1120␉␉␉␉␉␉␉UInt64␉␉␉␉␉blockCount,␊
1121␉␉␉␉␉␉␉UInt64␉␉␉␉␉blockSize,␊
1122␉␉␉␉␉␉␉IOStorageAttributes *␉attributes,␊
1123␉␉␉␉␉␉␉void * ␉␉␉␉␉clientData );␊
1124␉␊
1125␉␊
1126private:␊
1127␉␊
1128␉// Space reserved for future expansion.␊
1129␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 5 );␊
1130␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 6 );␊
1131␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 7 );␊
1132␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 8 );␊
1133␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 9 );␊
1134␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 10 );␊
1135␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 11 );␊
1136␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 12 );␊
1137␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 13 );␊
1138␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 14 );␊
1139␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 15 );␊
1140␉OSMetaClassDeclareReservedUnused ( IOSCSIBlockCommandsDevice, 16 );␊
1141␉␊
1142};␊
1143␊
1144#endif␉/* defined(KERNEL) && defined(__cplusplus) */␊
1145␊
1146#endif /* _IOKIT_IO_SCSI_BLOCK_COMMANDS_DEVICE_H_ */␊
1147

Archive Download this file

Revision: 1129