+++ /dev/null
-/*
- * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License"). You may not use this file except in compliance with the
- * License. Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
- *
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
- * License for the specific language governing rights and limitations
- * under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
- *
- * IOATAPIHDDrive.h - Generic ATAPI Direct-Access driver.
- *
- * HISTORY
- * Sep 2, 1999 jliu - Ported from AppleATAPIDrive.
- */
-
-#include <IOKit/assert.h>
-#include <IOKit/storage/ata/IOATAPIHDDrive.h>
-#include <IOKit/storage/ata/IOATAPIHDDriveNub.h>
-
-#define super IOATAHDDrive
-OSDefineMetaClassAndStructors( IOATAPIHDDrive, IOATAHDDrive )
-
-//---------------------------------------------------------------------------
-// Override the init() method in IOATAHDDrive.
-
-bool
-IOATAPIHDDrive::init(OSDictionary * properties)
-{
- _mediaPresent = false;
- _isRemovable = false;
-
- return super::init(properties);
-}
-
-//---------------------------------------------------------------------------
-// Override probe() method inherited from IOATAHDDrive. We need to
-// perform additional matching on ATAPI device type based on the
-// Inquiry data revealed by an ATA(PI) device nub.
-
-IOService *
-IOATAPIHDDrive::probe(IOService * provider, SInt32 * score)
-{
- UInt8 deviceType;
- IOService * ret = 0;
- bool wasOpened = false;
-
- // Let superclass have a go at probe first.
- //
- if (!super::probe(provider, score))
- return 0;
-
- // Our provider must be a IOATADevice nub, most likely created
- // by an IOATAController instance.
- //
- _ataDevice = OSDynamicCast(IOATADevice, provider);
- if (_ataDevice == 0)
- return 0; // IOATADevice nub not found.
-
- do {
- // Since we may issue command to the IOATADevice to perform
- // device matching, we express interest in using the device by
- // performing an open.
- //
- if (_ataDevice->open(this) == false)
- break;
-
- wasOpened = true;
-
- // Perform ATAPI type matching, CD-ROM, Direct-Access, Tape, etc.
- //
- if (!_ataDevice->getInquiryData(1, (ATAPIInquiry *) &deviceType) ||
- !matchATAPIDeviceType(deviceType & 0x1f, score))
- break;
-
- ret = this;
- }
- while (false);
-
- if (wasOpened)
- _ataDevice->close(this);
-
- _ataDevice = 0;
-
- return ret;
-}
-
-//---------------------------------------------------------------------------
-// Report as an ATAPI device.
-
-ATADeviceType
-IOATAPIHDDrive::reportATADeviceType() const
-{
- return kATADeviceATAPI;
-}
-
-//---------------------------------------------------------------------------
-// Looks for an ATAPI device which is a direct-access device.
-
-bool
-IOATAPIHDDrive::matchATAPIDeviceType(UInt8 type, SInt32 * score)
-{
- if (type == kIOATAPIDeviceTypeDirectAccess)
- return true;
-
- return false;
-}
-
-//---------------------------------------------------------------------------
-// Gather information about the ATAPI device nub.
-
-bool
-IOATAPIHDDrive::inspectDevice(IOATADevice * device)
-{
- OSString * string;
-
- // Fetch ATAPI device information from the nub.
- //
- string = OSDynamicCast(OSString,
- device->getProperty(kATAPropertyVendorName));
- if (string) {
- strncpy(_vendor, string->getCStringNoCopy(), 8);
- _vendor[8] = '\0';
- }
-
- string = OSDynamicCast(OSString,
- device->getProperty(kATAPropertyProductName));
- if (string) {
- strncpy(_product, string->getCStringNoCopy(), 16);
- _product[16] = '\0';
- }
-
- string = OSDynamicCast(OSString,
- device->getProperty(kATAPropertyProductRevision));
- if (string) {
- strncpy(_revision, string->getCStringNoCopy(), 4);
- _revision[4] = '\0';
- }
-
- // Device wants to be power-managed.
- //
- _supportedFeatures |= kIOATAFeaturePowerManagement;
-
- return true;
-}
-
-//---------------------------------------------------------------------------
-// Async read/write requests.
-
-IOReturn
-IOATAPIHDDrive::doAsyncReadWrite(IOMemoryDescriptor * buffer,
- UInt32 block,
- UInt32 nblks,
- IOStorageCompletion completion)
-{
- IOReturn ret;
- IOATACommand * cmd = atapiCommandReadWrite(buffer, block, nblks);
-
- if (!cmd)
- return kIOReturnNoMemory;
-
- ret = asyncExecute(cmd, completion);
-
- cmd->release();
-
- return ret;
-}
-
-//---------------------------------------------------------------------------
-// Sync read/write requests.
-
-IOReturn
-IOATAPIHDDrive::doSyncReadWrite(IOMemoryDescriptor * buffer,
- UInt32 block,
- UInt32 nblks)
-{
- IOReturn ret;
- IOATACommand * cmd = atapiCommandReadWrite(buffer, block, nblks);
-
- if (!cmd)
- return kIOReturnNoMemory;
-
- ret = syncExecute(cmd);
-
- cmd->release();
-
- return ret;
-}
-
-//---------------------------------------------------------------------------
-// Eject the media in the removable drive.
-
-IOReturn
-IOATAPIHDDrive::doEjectMedia()
-{
- IOReturn ret;
- IOATACommand * cmd = atapiCommandStartStopUnit(false, /* start unit */
- true, /* Load/Eject */
- false); /* Immediate */
-
- if (!cmd)
- return kIOReturnNoMemory;
-
- ret = syncExecute(cmd);
-
- cmd->release();
-
- return ret;
-}
-
-//---------------------------------------------------------------------------
-// Format the media in the drive.
-
-IOReturn
-IOATAPIHDDrive::doFormatMedia(UInt64 byteCapacity,
- IOMemoryDescriptor * formatData = 0)
-{
- IOReturn ret;
- IOATACommand * cmd = atapiCommandFormatUnit(0, 0, 0, formatData);
-
- if (!cmd)
- return kIOReturnNoMemory;
-
- ret = syncExecute(cmd, 15 * 60 * 1000); // 15 min timeout
-
- cmd->release();
-
- return ret;
-}
-
-//---------------------------------------------------------------------------
-// Lock/unlock the media in the removable drive.
-
-IOReturn
-IOATAPIHDDrive::doLockUnlockMedia(bool doLock)
-{
- IOReturn ret;
- IOATACommand * cmd = atapiCommandPreventAllowRemoval(doLock);
-
- if (!cmd)
- return kIOReturnNoMemory;
-
- ret = syncExecute(cmd);
-
- cmd->release();
-
- // Cache the state on the media lock, and restore it when
- // the driver wakes up from sleep.
-
- _isLocked = doLock;
-
- return ret;
-}
-
-//---------------------------------------------------------------------------
-// Sync the write cache.
-
-IOReturn
-IOATAPIHDDrive::doSynchronizeCache()
-{
- IOReturn ret;
- IOATACommand * cmd = atapiCommandSynchronizeCache();
-
- if (!cmd)
- return kIOReturnNoMemory;
-
- ret = syncExecute(cmd);
-
- cmd->release();
-
- return ret;
-}
-
-//---------------------------------------------------------------------------
-// Start up the drive.
-
-IOReturn
-IOATAPIHDDrive::doStart()
-{
- return doStartStop(true);
-}
-
-//---------------------------------------------------------------------------
-// Stop the drive.
-
-IOReturn
-IOATAPIHDDrive::doStop()
-{
- return doStartStop(false);
-}
-
-//---------------------------------------------------------------------------
-// Issue a START/STOP Unit command.
-
-IOReturn
-IOATAPIHDDrive::doStartStop(bool doStart)
-{
- IOReturn ret;
- IOATACommand * cmd;
-
- cmd = atapiCommandStartStopUnit(doStart, /* start unit */
- false, /* Load/Eject */
- false); /* Immediate operation */
-
- if (!cmd) return kIOReturnNoMemory;
-
- ret = syncExecute(cmd);
-
- cmd->release();
-
- return ret;
-}
-
-//---------------------------------------------------------------------------
-// Return device identification strings
-
-char * IOATAPIHDDrive::getVendorString()
-{
- return _vendor;
-}
-
-char * IOATAPIHDDrive::getProductString()
-{
- return _product;
-}
-
-char * IOATAPIHDDrive::getRevisionString()
-{
- return _revision;
-}
-
-char * IOATAPIHDDrive::getAdditionalDeviceInfoString()
-{
- return ("[ATAPI]");
-}
-
-//---------------------------------------------------------------------------
-// Report whether the media in the drive is ejectable.
-
-IOReturn
-IOATAPIHDDrive::reportEjectability(bool * isEjectable)
-{
- *isEjectable = true; /* default: if it's removable, it's ejectable */
- return kIOReturnSuccess;
-}
-
-//---------------------------------------------------------------------------
-// Report whether the drive can prevent user-initiated ejects by locking
-// the media in the drive.
-
-IOReturn
-IOATAPIHDDrive::reportLockability(bool * isLockable)
-{
- *isLockable = true; /* default: if it's removable, it's lockable */
- return kIOReturnSuccess;
-}
-
-//---------------------------------------------------------------------------
-// Report our polling requirments.
-
-IOReturn
-IOATAPIHDDrive::reportPollRequirements(bool * pollRequired,
- bool * pollIsExpensive)
-{
- *pollIsExpensive = false;
- *pollRequired = _isRemovable;
- return kIOReturnSuccess;
-}
-
-//---------------------------------------------------------------------------
-// Report the current state of the media.
-
-IOReturn
-IOATAPIHDDrive::reportMediaState(bool * mediaPresent,
- bool * changed)
-{
- IOATACommand * cmd = 0;
- IOMemoryDescriptor * senseData = 0;
- UInt8 senseBuf[18];
- ATAResults results;
- IOReturn ret;
-
- assert(mediaPresent && changed);
-
- do {
- ret = kIOReturnNoMemory;
-
- bzero((void *) senseBuf, sizeof(senseBuf));
- senseData = IOMemoryDescriptor::withAddress(senseBuf,
- sizeof(senseBuf),
- kIODirectionIn);
- if (!senseData)
- break;
-
- cmd = atapiCommandTestUnitReady();
- if (!cmd)
- break;
-
- // Execute the Test Unit Ready command with no retries.
- //
- syncExecute(cmd, kATADefaultTimeout, kATAZeroRetry, senseData);
-
- ret = kIOReturnSuccess;
-
- if (cmd->getResults(&results) == kIOReturnSuccess)
- {
- *mediaPresent = true;
- *changed = (*mediaPresent != _mediaPresent);
- _mediaPresent = true;
- }
- else
- {
- UInt8 errorCode = senseBuf[0];
- UInt8 senseKey = senseBuf[2];
-
-#ifdef DEBUG_LOG
- UInt8 senseCode = senseBuf[12];
- UInt8 senseQualifier = senseBuf[13];
-
- IOLog("-- IOATAPIHDDrive::reportMediaState --\n");
- IOLog("Error code: %02x\n", errorCode);
- IOLog("Sense Key : %02x\n", senseKey);
- IOLog("ASC : %02x\n", senseCode);
- IOLog("ASCQ : %02x\n", senseQualifier);
-#endif
-
- *mediaPresent = false;
- *changed = (*mediaPresent != _mediaPresent);
- _mediaPresent = false;
-
- // The error code field for ATAPI request sense should always
- // be 0x70 or 0x71. Otherwise ignore the sense data.
- //
- if ((errorCode == 0x70) || (errorCode == 0x71))
- {
- switch (senseKey) {
- case 5: /* Invalid ATAPI command */
- ret = kIOReturnIOError;
- break;
-
- case 2: /* Not ready */
- break;
-
- default:
- break;
- }
- }
- }
- }
- while (false);
-
- if (cmd)
- cmd->release();
-
- if (senseData)
- senseData->release();
-
-#if 0
- IOLog("%s: media present %s, changed %s\n", getName(),
- *mediaPresent ? "Y" : "N",
- *changed ? "Y" : "N"
- );
-#endif
-
- return ret;
-}
-
-//---------------------------------------------------------------------------
-// Report media removability.
-
-IOReturn
-IOATAPIHDDrive::reportRemovability(bool * isRemovable)
-{
- UInt8 inqBuf[2];
-
- *isRemovable = false;
-
- if (_ataDevice->getInquiryData(sizeof(inqBuf), (ATAPIInquiry *) inqBuf))
- {
- if (inqBuf[1] & 0x80)
- *isRemovable = _isRemovable = true;
- else
- *isRemovable = _isRemovable = false;
- }
-
- return kIOReturnSuccess;
-}
-
-//---------------------------------------------------------------------------
-// Report whether media is write-protected.
-
-IOReturn
-IOATAPIHDDrive::reportWriteProtection(bool * isWriteProtected)
-{
- *isWriteProtected = false; // defaults to read-write
- return kIOReturnSuccess;
-}
-
-//---------------------------------------------------------------------------
-// Instantiate an ATAPI specific subclass of IOBlockStorageDevice.
-
-IOService *
-IOATAPIHDDrive::instantiateNub()
-{
- IOService * nub = new IOATAPIHDDriveNub;
- return nub;
-}
-
-//---------------------------------------------------------------------------
-// Override the handleActiveStateTransition() method in IOATAHDDrive and
-// perform ATAPI specific handling.
-
-void
-IOATAPIHDDrive::handleActiveStateTransition( UInt32 stage, IOReturn status )
-{
- // Restore the lock on the media after the ATAPI device wakes up from
- // sleep. Assume that the drive will always power up in the unlocked state.
- // Technically, some drives may have a jumper to set the default state
- // at power up.
-
- if ( ( stage == kIOATAActiveStage0 ) && _isLocked )
- {
- IOStorageCompletion completion;
- IOReturn ret;
- IOATACommand * cmd = atapiCommandPreventAllowRemoval( true );
-
- completion.target = this;
- completion.action = sHandleActiveStateTransition;
- completion.parameter = (void *) kIOATAActiveStage1;
-
- if ( cmd )
- {
- cmd->setQueueInfo( kATAQTypeBypassQ );
- ret = asyncExecute( cmd, completion );
- cmd->release();
- }
- }
- else
- {
- super::handleActiveStateTransition( stage, status );
- }
-}
projects / apple / xnu.git / blobdiff