iokit/Families/IOATAHDDrive/IOATAHDDriveNub.cpp

   1 /*
   2  * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 /*
  23  * Copyright (c) 1999 Apple Computer, Inc.  All rights reserved.
  24  *
  25  * IOATAHDDriveNub.cpp
  26  *
  27  * This subclass implements a relay to a protocol and device-specific
  28  * provider.
  29  *
  30  * HISTORY
  31  * Aug 27, 1999  jliu - Created.
  32  */
  33
  34 #include <IOKit/IOLib.h>
  35 #include <IOKit/storage/ata/IOATAHDDriveNub.h>
  36 #include <IOKit/storage/ata/IOATAHDDrive.h>
  37
  38 #define super IOBlockStorageDevice
  39 OSDefineMetaClassAndStructors( IOATAHDDriveNub, IOBlockStorageDevice )
  40
  41 //---------------------------------------------------------------------------
  42 // attach to provider.
  43
  44 bool IOATAHDDriveNub::attach(IOService * provider)
  45 {
  46     if (!super::attach(provider))
  47         return false;
  48
  49     _provider = OSDynamicCast(IOATAHDDrive, provider);
  50     if (_provider == 0) {
  51         IOLog("IOATAHDDriveNub: attach; wrong provider type!\n");
  52         return false;
  53     }
  54
  55     return true;
  56 }
  57
  58 //---------------------------------------------------------------------------
  59 // detach from provider.
  60
  61 void IOATAHDDriveNub::detach(IOService * provider)
  62 {
  63     if (_provider == provider)
  64         _provider = 0;
  65
  66     super::detach(provider);
  67 }
  68
  69 //---------------------------------------------------------------------------
  70 //
  71
  72 IOReturn IOATAHDDriveNub::doAsyncReadWrite(IOMemoryDescriptor * buffer,
  73                                            UInt32               block,
  74                                            UInt32               nblks,
  75                                            IOStorageCompletion  completion)
  76 {
  77     return _provider->doAsyncReadWrite(buffer, block, nblks, completion);
  78 }
  79
  80 //---------------------------------------------------------------------------
  81 //
  82
  83 IOReturn IOATAHDDriveNub::doSyncReadWrite(IOMemoryDescriptor *buffer,
  84                                      UInt32 block,UInt32 nblks)
  85 {
  86     return _provider->doSyncReadWrite(buffer, block, nblks);
  87 }
  88
  89 //---------------------------------------------------------------------------
  90 //
  91
  92 IOReturn IOATAHDDriveNub::doEjectMedia()
  93 {
  94     return _provider->doEjectMedia();
  95 }
  96
  97 //---------------------------------------------------------------------------
  98 //
  99
 100 IOReturn IOATAHDDriveNub::doFormatMedia(UInt64 byteCapacity)
 101 {
 102     return _provider->doFormatMedia(byteCapacity);
 103 }
 104
 105 //---------------------------------------------------------------------------
 106 //
 107
 108 UInt32
 109 IOATAHDDriveNub::doGetFormatCapacities(UInt64 * capacities,
 110                                        UInt32   capacitiesMaxCount) const
 111 {
 112     return _provider->doGetFormatCapacities(capacities, capacitiesMaxCount);
 113 }
 114
 115 //---------------------------------------------------------------------------
 116 //
 117
 118 IOReturn IOATAHDDriveNub::doLockUnlockMedia(bool doLock)
 119 {
 120     return _provider->doLockUnlockMedia(doLock);
 121 }
 122
 123 //---------------------------------------------------------------------------
 124 //
 125
 126 IOReturn IOATAHDDriveNub::doSynchronizeCache()
 127 {
 128     return _provider->doSynchronizeCache();
 129 }
 130
 131 //---------------------------------------------------------------------------
 132 //
 133
 134 char * IOATAHDDriveNub::getVendorString()
 135 {
 136     return _provider->getVendorString();
 137 }
 138
 139 //---------------------------------------------------------------------------
 140 //
 141
 142 char * IOATAHDDriveNub::getProductString()
 143 {
 144     return _provider->getProductString();
 145 }
 146
 147 //---------------------------------------------------------------------------
 148 //
 149
 150 char * IOATAHDDriveNub::getRevisionString()
 151 {
 152     return _provider->getRevisionString();
 153 }
 154
 155 //---------------------------------------------------------------------------
 156 //
 157
 158 char * IOATAHDDriveNub::getAdditionalDeviceInfoString()
 159 {
 160     return _provider->getAdditionalDeviceInfoString();
 161 }
 162
 163 //---------------------------------------------------------------------------
 164 //
 165
 166 IOReturn IOATAHDDriveNub::reportBlockSize(UInt64 * blockSize)
 167 {
 168     return _provider->reportBlockSize(blockSize);
 169 }
 170
 171 //---------------------------------------------------------------------------
 172 //
 173
 174 IOReturn IOATAHDDriveNub::reportEjectability(bool * isEjectable)
 175 {
 176     return _provider->reportEjectability(isEjectable);
 177 }
 178
 179 //---------------------------------------------------------------------------
 180 //
 181
 182 IOReturn IOATAHDDriveNub::reportLockability(bool * isLockable)
 183 {
 184     return _provider->reportLockability(isLockable);
 185 }
 186
 187 //---------------------------------------------------------------------------
 188 //
 189
 190 IOReturn IOATAHDDriveNub::reportPollRequirements(bool * pollIsRequired,
 191                                                  bool * pollIsExpensive)
 192 {
 193     return _provider->reportPollRequirements(pollIsRequired, pollIsExpensive);
 194 }
 195
 196 //---------------------------------------------------------------------------
 197 //
 198
 199 IOReturn IOATAHDDriveNub::reportMaxReadTransfer(UInt64   blockSize,
 200                                                 UInt64 * max)
 201 {
 202     return _provider->reportMaxReadTransfer(blockSize, max);
 203 }
 204
 205 //---------------------------------------------------------------------------
 206 //
 207
 208 IOReturn IOATAHDDriveNub::reportMaxValidBlock(UInt64 * maxBlock)
 209 {
 210     return _provider->reportMaxValidBlock(maxBlock);
 211 }
 212
 213 //---------------------------------------------------------------------------
 214 //
 215
 216 IOReturn IOATAHDDriveNub::reportMaxWriteTransfer(UInt64   blockSize,
 217                                                  UInt64 * max)
 218 {
 219     return _provider->reportMaxWriteTransfer(blockSize, max);
 220 }
 221
 222 //---------------------------------------------------------------------------
 223 //
 224
 225 IOReturn IOATAHDDriveNub::reportMediaState(bool * mediaPresent,
 226                                            bool * changed)
 227 {
 228     return _provider->reportMediaState(mediaPresent, changed);
 229 }
 230
 231 //---------------------------------------------------------------------------
 232 //
 233
 234 IOReturn IOATAHDDriveNub::reportRemovability(bool * isRemovable)
 235 {
 236     return _provider->reportRemovability(isRemovable);
 237 }
 238
 239 //---------------------------------------------------------------------------
 240 //
 241
 242 IOReturn IOATAHDDriveNub::reportWriteProtection(bool * isWriteProtected)
 243 {
 244     return _provider->reportWriteProtection(isWriteProtected);
 245 }