VM* vm_new(int num_cpus) {
if (num_cpus <= 0) {
LOG_ERROR("vm_new: num_cpus <= 0");
return NULL;
}
VM* vm = (VM*)IOMalloc(sizeof(VM));
if (!vm) {
LOG_ERROR("vm_new: can't allocate VM");
return NULL;
}
memset(vm, 0, sizeof(VM));
vm->num_cpus = num_cpus;
vm->cpus = (CPU**)IOMalloc(sizeof(CPU*) * num_cpus);
if (!vm->cpus) {
LOG_ERROR("vm_new: can't allocate cpus[]");
vm_delete(vm);
return NULL;
}
memset(vm->cpus, 0, sizeof(sizeof(CPU*) * num_cpus));
for (int i = 0; i < vm->num_cpus; i++) {
CPU* cpu = cpu_new();
if (!cpu) {
vm_delete(vm);
return NULL;
}
vm->cpus[i] = cpu;
}
LOG("created VM");
return vm;
}
bool SuperIOSensor::initWithOwner(SuperIOMonitor *aOwner, const char* aKey, const char* aType, unsigned char aSize, SuperIOSensorGroup aGroup, unsigned long aIndex)
{
if (!OSObject::init())
return false;
if (!(owner = aOwner))
return false;
if (!(name = (char *)IOMalloc(5)))
return false;
bcopy(aKey, name, 4);
name[5] = '\0';
if (!(type = (char *)IOMalloc(5)))
return false;
bcopy(aType, type, 4);
type[5] = '\0';
size = aSize;
group = aGroup;
index = aIndex;
return true;
}
IOReturn IOSharedInterruptController::initInterruptController(IOInterruptController *parentController, OSData *parentSource)
{
int cnt, interruptType;
IOReturn error;
if (!super::init())
return kIOReturnNoResources;
// Set provider to this so enable/disable nub stuff works.
provider = this;
// Allocate the IOInterruptSource so this can act like a nub.
_interruptSources = (IOInterruptSource *)IOMalloc(sizeof(IOInterruptSource));
if (_interruptSources == 0) return kIOReturnNoMemory;
_numInterruptSources = 1;
// Set up the IOInterruptSource to point at this.
_interruptSources[0].interruptController = parentController;
_interruptSources[0].vectorData = parentSource;
sourceIsLevel = false;
error = provider->getInterruptType(0, &interruptType);
if (error == kIOReturnSuccess) {
if (interruptType & kIOInterruptTypeLevel)
sourceIsLevel = true;
}
// Allocate the memory for the vectors
numVectors = 32; // For now a constant number.
vectors = (IOInterruptVector *)IOMalloc(numVectors * sizeof(IOInterruptVector));
if (vectors == NULL) {
IOFree(_interruptSources, sizeof(IOInterruptSource));
return kIOReturnNoMemory;
}
bzero(vectors, numVectors * sizeof(IOInterruptVector));
// Allocate the lock for the controller.
controllerLock = IOSimpleLockAlloc();
if (controllerLock == 0) return kIOReturnNoResources;
// Allocate locks for the vectors.
for (cnt = 0; cnt < numVectors; cnt++) {
vectors[cnt].interruptLock = IOLockAlloc();
if (vectors[cnt].interruptLock == NULL) {
for (cnt = 0; cnt < numVectors; cnt++) {
if (vectors[cnt].interruptLock != NULL)
IOLockFree(vectors[cnt].interruptLock);
}
return kIOReturnNoResources;
}
}
vectorsRegistered = 0;
vectorsEnabled = 0;
controllerDisabled = 1;
return kIOReturnSuccess;
}
Boolean IOSharedDataQueue::initWithCapacity(UInt32 size)
{
IODataQueueAppendix * appendix;
vm_size_t allocSize;
if (!super::init()) {
return false;
}
_reserved = (ExpansionData *)IOMalloc(sizeof(struct ExpansionData));
if (!_reserved) {
return false;
}
if (size > UINT32_MAX - DATA_QUEUE_MEMORY_HEADER_SIZE - DATA_QUEUE_MEMORY_APPENDIX_SIZE) {
return false;
}
allocSize = round_page(size + DATA_QUEUE_MEMORY_HEADER_SIZE + DATA_QUEUE_MEMORY_APPENDIX_SIZE);
if (allocSize < size) {
return false;
}
dataQueue = (IODataQueueMemory *)IOMallocAligned(allocSize, PAGE_SIZE);
if (dataQueue == 0) {
return false;
}
bzero(dataQueue, allocSize);
dataQueue->queueSize = size;
// dataQueue->head = 0;
// dataQueue->tail = 0;
if (!setQueueSize(size)) {
return false;
}
appendix = (IODataQueueAppendix *)((UInt8 *)dataQueue + size + DATA_QUEUE_MEMORY_HEADER_SIZE);
appendix->version = 0;
if (!notifyMsg) {
notifyMsg = IOMalloc(sizeof(mach_msg_header_t));
if (!notifyMsg)
return false;
}
bzero(notifyMsg, sizeof(mach_msg_header_t));
setNotificationPort(MACH_PORT_NULL);
return true;
}
bool FakeSMCKey::init(const char * aKey, const char * aType, unsigned char aSize, const void *aValue, IOService * aHandler)
{
if (!super::init())
return false;
if (!aKey || strlen(aKey) == 0 || !(key = (char *)IOMalloc(5)))
return false;
copySymbol(aKey, key);
size = aSize;
if (!(type = (char *)IOMalloc(5)))
return false;
if (!aType || strlen(aType) == 0) {
switch (size)
{
case 1:
copySymbol("ui8", type);
break;
case 2:
copySymbol("ui16", type);
break;
case 4:
copySymbol("ui32", type);
break;
default:
copySymbol("ch8*", type);
break;
}
//copySymbol("\0\0\0\0", type);
}
else
copySymbol(aType, type);
if (size == 0)
size++;
if (!(value = IOMalloc(size)))
return false;
if (aValue)
bcopy(aValue, value, size);
else
bzero(value, size);
handler = aHandler;
return true;
}
int VoodooI2CHIDDevice::i2c_hid_alloc_buffers(i2c_hid *ihid, UInt report_size) {
int args_len = sizeof(UInt8) + sizeof(UInt16) + sizeof(UInt16) + report_size;
ihid->inbuf = (char *)IOMalloc(report_size);
ihid->argsbuf = (char *)IOMalloc(report_size);
ihid->cmdbuf = (char *)IOMalloc(sizeof(union command) + args_len);
if(!ihid->inbuf || !ihid->argsbuf || !ihid->cmdbuf) {
i2c_hid_free_buffers(ihid, report_size);
return -1;
}
ihid->bufsize = report_size;
return 0;
}
bool IOHIKeyboard::init(OSDictionary * properties)
{
if (!super::init(properties)) return false;
/*
* Initialize minimal state.
*/
_deviceLock = IOLockAlloc();
_keyMap = 0;
_keyStateSize = 4*((maxKeyCodes()+(EVK_BITS_PER_UNIT-1))/EVK_BITS_PER_UNIT);
_keyState = (UInt32 *) IOMalloc(_keyStateSize);
_codeToRepeat = (unsigned)-1;
_keyboardEventTarget = 0;
_keyboardEventAction = 0;
_keyboardSpecialEventTarget = 0;
_keyboardSpecialEventAction = 0;
_updateEventFlagsTarget = 0;
_updateEventFlagsAction = 0;
if (!_deviceLock || !_keyState) return false;
bzero(_keyState, _keyStateSize);
return true;
}
QTOCDataFormat10Ptr
CreateBufferFromData ( OSData * theData )
{
vm_size_t bufferLength = 0;
QTOCDataFormat10Ptr buffer = NULL;
DebugLog ( ( "CreateBufferFromData: Entering...\n" ) );
DebugAssert ( ( theData != NULL ) );
if ( theData == NULL )
{
DebugLog ( ( "CreateBufferFromData: theData is NULL.\n" ) );
return NULL;
}
bufferLength = theData->getLength ( );
buffer = ( QTOCDataFormat10Ptr ) IOMalloc ( bufferLength );
if ( buffer != NULL )
{
// Copy the bytes into the buffer
bcopy ( theData->getBytesNoCopy ( ), buffer, bufferLength );
}
DebugLog ( ( "CreateBufferFromData: exiting.\n" ) );
return buffer;
}
bool IOFWPseudoAddressSpaceAux::createMemberVariables( void )
{
bool success = true;
if( fMembers == NULL )
{
// create member variables
if( success )
{
fMembers = (MemberVariables*)IOMalloc( sizeof(MemberVariables) );
if( fMembers == NULL )
success = false;
}
// zero member variables
if( success )
{
bzero( fMembers, sizeof(MemberVariables) );
}
// clean up on failure
if( !success )
{
destroyMemberVariables();
}
}
return success;
}
bool VoodooI2CHIDDevice::probe(IOService* device) {
hid_device = (I2CDevice *)IOMalloc(sizeof(I2CDevice));
//hid_device->_dev = _controller->_dev;
if (!super::start(device))
return false;
hid_device->provider = OSDynamicCast(IOACPIPlatformDevice, device);
hid_device->provider->retain();
int ret = i2c_get_slave_address(hid_device);
if (ret < 0){
IOLog("%s::%s::Failed to get a slave address for an I2C device, aborting.\n", getName(), _controller->_dev->name);
IOFree(hid_device, sizeof(I2CDevice));
return false;
}
IOLog("%s::%s::HID Probe called for i2c 0x%02x\n", getName(), _controller->_dev->name, hid_device->addr);
initHIDDevice(hid_device);
//super::stop(device);
return 0;
}
// Queue a read on a controller
bool WirelessGamingReceiver::QueueRead(int index)
{
IOUSBCompletion complete;
IOReturn err;
WGRREAD *data;
data = (WGRREAD*)IOMalloc(sizeof(WGRREAD));
if (data == NULL)
return false;
data->index = index;
data->buffer = IOBufferMemoryDescriptor::inTaskWithOptions(kernel_task, 0, GetMaxPacketSize(connections[index].controllerIn));
if (data->buffer == NULL)
{
IOFree(data, sizeof(WGRREAD));
return false;
}
complete.target = this;
complete.action = _ReadComplete;
complete.parameter = data;
err = connections[index].controllerIn->Read(data->buffer, 0, 0, data->buffer->getLength(), &complete);
if (err == kIOReturnSuccess)
return true;
data->buffer->release();
IOFree(data, sizeof(WGRREAD));
// IOLog("read - failed to start (0x%.8x)\n", err);
return false;
}
bool
ZFSDatasetProxy::init(OSDictionary *properties)
{
char *str = (char *)IOMalloc(1);
if (!str) {
dprintf("string allocation failed\n");
return (false);
}
str[0] = '\0';
vendorString = str;
revisionString = str;
infoString = str;
if (IOBlockStorageDevice::init(properties) == false) {
dprintf("BlockStorageDevice start failed");
goto error;
}
return (true);
error:
if (str) {
vendorString = 0;
revisionString = 0;
infoString = 0;
IOFree(str, 1);
}
return (false);
}
bool GeforceSensors::shadowBios()
{
struct nouveau_device *device = &card;
//try to load bios from registry first from "vbios" property created by Chameleon boolloader
if (OSData *vbios = OSDynamicCast(OSData, pciDevice->getProperty("vbios"))) {
device->bios.size = vbios->getLength();
device->bios.data = (u8*)IOMalloc(card.bios.size);
memcpy(device->bios.data, vbios->getBytesNoCopy(), device->bios.size);
}
if (!device->bios.data || !device->bios.size || nouveau_bios_score(device, true) < 1) {
if (nouveau_bios_shadow(device)) {
//nv_info(device, "early shadow VBIOS succeeded\n");
}
else {
if (device->bios.data && device->bios.size) {
IOFree(card.bios.data, card.bios.size);
device->bios.data = NULL;
device->bios.size = 0;
}
return false;
}
}
return true;
}
bool Core99NVRAM::start(IOService *provider)
{
IOMemoryMap *nvramMemoryMap;
unsigned long gen1, gen2;
// Get the base address for the nvram.
nvramMemoryMap = provider->mapDeviceMemoryWithIndex(0);
if (nvramMemoryMap == 0) return false;
nvramBaseAddress = (unsigned char *)nvramMemoryMap->getVirtualAddress();
// Allocte the nvram shadow.
nvramShadow = (unsigned char *)IOMalloc(kCore99NVRAMSize);
if (nvramShadow == 0) return false;
// Find the current nvram partition and set the next.
gen1 = validateGeneration(nvramBaseAddress + kCore99NVRAMAreaAOffset);
gen2 = validateGeneration(nvramBaseAddress + kCore99NVRAMAreaBOffset);
if (gen1 > gen2) {
generation = gen1;
nvramCurrent = nvramBaseAddress + kCore99NVRAMAreaAOffset;
nvramNext = nvramBaseAddress + kCore99NVRAMAreaBOffset;
} else {
generation = gen2;
nvramCurrent = nvramBaseAddress + kCore99NVRAMAreaBOffset;
nvramNext = nvramBaseAddress + kCore99NVRAMAreaAOffset;
}
// Copy the nvram into the shadow.
bcopy(nvramCurrent, nvramShadow, kCore99NVRAMSize);
return super::start(provider);
}
bool FakeSMCKey::setValueFromBuffer(const void *aBuffer, UInt8 aSize)
{
if (!aBuffer || aSize == 0)
return false;
if (aSize != size) {
if (value)
IOFree(value, size);
size = aSize;
if (!(value = IOMalloc(size)))
return false;
}
bcopy(aBuffer, value, size);
if (handler) {
IOReturn result = handler->callPlatformFunction(kFakeSMCSetValueCallback, false, (void *)key, (void *)value, (void *)size, 0);
if (kIOReturnSuccess != result)
HWSensorsWarningLog("value changed event callback error for key %s, return 0x%x", key, result);
}
return true;
}
bool IOFWCompareAndSwapCommand::createMemberVariables( void )
{
bool success = true;
if( fMembers == NULL )
{
// create member variables
if( success )
{
fMembers = (MemberVariables*)IOMalloc( sizeof(MemberVariables) );
if( fMembers == NULL )
success = false;
}
// zero member variables
if( success )
{
bzero( fMembers, sizeof(MemberVariables) );
}
// clean up on failure
if( !success )
{
destroyMemberVariables();
}
}
return success;
}
bool HoRNDIS::rndisSetPacketFilter(uint32_t filter) {
union {
unsigned char *buf;
struct rndis_msg_hdr *hdr;
struct rndis_set *set;
struct rndis_set_c *set_c;
} u;
int rc;
u.buf = (unsigned char *)IOMalloc(RNDIS_CMD_BUF_SZ);
if (!u.buf) {
LOG(V_ERROR, "out of memory?");
return false;;
}
memset(u.buf, 0, sizeof *u.set);
u.set->msg_type = RNDIS_MSG_SET;
u.set->msg_len = cpu_to_le32(4 + sizeof *u.set);
u.set->oid = OID_GEN_CURRENT_PACKET_FILTER;
u.set->len = cpu_to_le32(4);
u.set->offset = cpu_to_le32((sizeof *u.set) - 8);
*(uint32_t *)(u.buf + sizeof *u.set) = filter;
rc = rndisCommand(u.hdr, RNDIS_CMD_BUF_SZ);
if (rc != kIOReturnSuccess) {
LOG(V_ERROR, "SET not successful?");
IOFree(u.buf, RNDIS_CMD_BUF_SZ);
return false;
}
IOFree(u.buf, RNDIS_CMD_BUF_SZ);
return true;
}
// Standard IOService.h function methods
bool AppleUSBAudioPlugin::start (IOService * provider) {
if (!super::start (provider))
{
return FALSE;
}
reserved = (ExpansionData *)IOMalloc (sizeof(struct ExpansionData));
if (!reserved) {
return FALSE;
}
reserved->streamProvider = OSDynamicCast (AppleUSBAudioStream, provider);
if (reserved->streamProvider)
{
// Tell AppleUSBAudioStream that we're loaded
reserved->streamProvider->registerPlugin (this);
}
else
{
mOurProvider = OSDynamicCast (AppleUSBAudioEngine, provider);
if (mOurProvider)
{
// Tell AppleUSBAudioEngine that we're loaded
mOurProvider->registerPlugin (this);
}
}
return TRUE;
}
IOReturn HoRNDIS::getHardwareAddress(IOEthernetAddress *ea) {
UInt32 i;
void *buf;
unsigned char *bp;
int rlen = -1;
int rv;
buf = IOMalloc(RNDIS_CMD_BUF_SZ);
if (!buf)
return kIOReturnNoMemory;
rv = rndisQuery(buf, OID_802_3_PERMANENT_ADDRESS, 48, (void **) &bp, &rlen);
if (rv < 0) {
LOG(V_ERROR, "getHardwareAddress OID failed?");
IOFree(buf, RNDIS_CMD_BUF_SZ);
return kIOReturnIOError;
}
LOG(V_DEBUG, "MAC Address %02x:%02x:%02x:%02x:%02x:%02x -- rlen %d",
bp[0], bp[1], bp[2], bp[3], bp[4], bp[5],
rlen);
for (i=0; i<6; i++)
ea->bytes[i] = bp[i];
IOFree(buf, RNDIS_CMD_BUF_SZ);
return kIOReturnSuccess;
}
//==============================================================================
// IOHIDEvent::initWithCapacity
//==============================================================================
bool IOHIDEvent::initWithCapacity(IOByteCount capacity)
{
if (!super::init())
return false;
if (_data && (!capacity || _capacity < capacity) ) {
// clean out old data's storage if it isn't big enough
IOFree(_data, _capacity);
_data = 0;
}
_capacity = capacity;
if ( !_capacity )
return false;
if ( !_data && !(_data = (IOHIDEventData *) IOMalloc(_capacity)))
return false;
bzero(_data, _capacity);
_data->size = _capacity;
_children = NULL;
clock_get_uptime(&_creationTimeStamp);
return true;
}
bool
IOSCSITape::GrowDeviceMinorNumberMemory(void)
{
IOSCSITape **newDevices;
int cur_size = sizeof(IOSCSITape *) * deviceCount;
int new_size = sizeof(IOSCSITape *) * (deviceCount + GROW_FACTOR);
newDevices = (IOSCSITape **)IOMalloc(new_size);
if (!newDevices)
return false;
bzero(newDevices, new_size);
if (deviceCount)
{
memcpy(newDevices, devices, cur_size);
IOFree(devices, cur_size);
}
devices = newDevices;
deviceCount += GROW_FACTOR;
return true;
}
bool FileNVRAM::setProperty(const OSSymbol *aKey, OSObject *anObject)
{
// Verify permissions.
if (IOUserClient::clientHasPrivilege(current_task(), kIOClientPrivilegeAdministrator) != kIOReturnSuccess)
{
// Not priveleged!
return false;
}
// Check for SIP configuration variables.
if ((strncmp("csr-data", aKey->getCStringNoCopy(), 8) == 0) || (strncmp("csr-active-config", aKey->getCStringNoCopy(), 17) == 0))
{
// We have a match so first verify the entitlements.
if (IOUserClient::copyClientEntitlement(current_task(), "com.apple.private.iokit.nvram-csr") == NULL)
{
LOG(INFO, "setProperty(%s, (%s) %p) failed (not entitled)\n", aKey->getCStringNoCopy(), anObject->getMetaClass()->getClassName(), anObject);
// Not entitled!
return false;
}
}
OSSerialize *s = OSSerialize::withCapacity(1000);
if (anObject->serialize(s))
{
LOG(INFO, "setProperty(%s, (%s) %s) called\n", aKey->getCStringNoCopy(), anObject->getMetaClass()->getClassName(), s->text());
}
else
{
LOG(INFO, "setProperty(%s, (%s) %p) called\n", aKey->getCStringNoCopy(), anObject->getMetaClass()->getClassName(), anObject);
}
s->release();
// Check for special FileNVRAM properties:
if (strncmp(FILE_NVRAM_GUID ":", aKey->getCStringNoCopy(), MIN(aKey->getLength(), strlen(FILE_NVRAM_GUID ":"))) == 0)
{
unsigned long bytes = aKey->getLength() - strlen(FILE_NVRAM_GUID ":") + 1;
// Found GUID
char* newKey = (char*)IOMalloc(bytes);
snprintf(newKey, bytes+1, "%s", &(aKey->getCStringNoCopy()[strlen(FILE_NVRAM_GUID ":")]));
// Send d
OSString* str = OSString::withCString(newKey);
handleSetting(str, anObject, this);
str->release();
IOFree(newKey, bytes);
}
bool stat = IOService::setProperty(aKey, cast(aKey, anObject));
if (mInitComplete)
{
sync();
}
return stat;
}
static void *IOMallocZero(int len)
{
void *buf = IOMalloc(len);
if (!buf)
panic("alloc failed");
bzero(buf, len);
return buf;
}
void
RingBuffer::init(int desiredSize)
{
size = desiredSize + 1;
data = (char *)IOMalloc(size);
head = 0;
tail = 0;
};
IOSimpleLock * IOSimpleLockAlloc( void )
{
IOSimpleLock * lock;
lock = (IOSimpleLock *) IOMalloc( sizeof(IOSimpleLock));
if( lock)
IOSimpleLockInit( lock );
return( lock );
}
void *PoolAllocateResident (vm_size_t size, unsigned char clear)
{
void *mem = IOMalloc(size);
if (clear) {
bzero(mem, size);
}
return mem;
}
bool GenericInterruptController::start(IOService *provider)
{
IOInterruptAction handler;
IOSymbol *interruptControllerName;
// If needed call the parents start.
if (!super::start(provider))
return false;
// Map the device's memory and initalize its state.
// For now you must allocate storage for the vectors.
// This will probably changed to something like: initVectors(numVectors).
// In the mean time something like this works well.
#if 0
// Allocate the memory for the vectors.
vectors = (IOInterruptVector *)IOMalloc(numVectors *
sizeof(IOInterruptVector));
if (vectors == NULL) return false;
bzero(vectors, numVectors * sizeof(IOInterruptVector));
// Allocate locks for the vectors.
for (cnt = 0; cnt < numVectors; cnt++) {
vectors[cnt].interruptLock = IOLockAlloc();
if (vectors[cnt].interruptLock == NULL) {
for (cnt = 0; cnt < numVectors; cnt++) {
if (vectors[cnt].interruptLock != NULL)
IOLockFree(vectors[cnt].interruptLock);
}
}
}
#endif
// If you know that this interrupt controller is the primary
// interrupt controller, use this to set it nub properties properly.
// This may be done by the nub's creator.
getPlatform()->setCPUInterruptProperties(provider);
// register the interrupt handler so it can receive interrupts.
handler = getInterruptHandlerAddress();
provider->registerInterrupt(0, this, handler, 0);
// Just like any interrupt source, you must enable it to receive interrupts.
provider->enableInterrupt(0);
// Set interruptControllerName to the proper symbol.
//interruptControllerName = xxx;
// Register this interrupt controller so clients can find it.
getPlatform()->registerInterruptController(interruptControllerName, this);
// All done, so return true.
return true;
}
XHCIAsyncTD* XHCIAsyncTD::ForEndpoint(XHCIAsyncEndpoint* provider)
{
XHCIAsyncTD* pTd;
pTd = static_cast<XHCIAsyncTD*>(IOMalloc(sizeof *pTd));
if (!pTd)
return 0;
bzero(pTd, sizeof *pTd);
pTd->provider = provider;
return pTd;
}
bool VoodooI2CHIDDevice::i2c_hid_get_report_descriptor(i2c_hid *ihid){
UInt rsize;
int ret;
IOLog("reg: 0x%x\n",ihid->hdesc.wReportDescRegister);
rsize = UInt16(ihid->hdesc.wReportDescLength);
unsigned char* rdesc = (unsigned char *)IOMalloc(rsize);
i2c_hid_hwreset(ihid);
if (!rdesc){
return -1;
}
/*
if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE){
IOLog("%s::%s::Weird size of report descriptor (%u)\n", getName(), hid_device->name, rsize);ƒ
return 1;
}
*/
ret = i2c_hid_command(ihid, &hid_report_desc_cmd, rdesc, rsize);
if (!ret){
IOLog("it worked!\n");
}
//_controller->registerDump(_controller->_dev);
/*
if (ret) {
IOLog("%s::%s::Reading report descriptor failed", getName(), hid_device->name);
return -1;
}
IOLog("%s::%s::Report descriptor: %s\n", getName(), hid_device->name, rdesc);
*/
IOLog("===Report Descriptor===\n");
for (int i = 0; i < UInt16(ihid->hdesc.wReportDescLength); i++)
IOLog("0x%02x\n", (UInt8) rdesc[i]);
IOLog("===Report Descriptor===\n");
IOFree(rdesc, rsize);
return 0;
};
XHCIAsyncEndpoint* XHCIAsyncEndpoint::withParameters(GenericUSBXHCI* provider, ringStruct* pRing, uint32_t maxPacketSize, uint32_t maxBurst, uint32_t multiple)
{
XHCIAsyncEndpoint* obj;
obj = static_cast<XHCIAsyncEndpoint*>(IOMalloc(sizeof *obj));
if (!obj)
return 0;
bzero(obj, sizeof *obj);
obj->provider = provider;
obj->pRing = pRing;
obj->setParameters(maxPacketSize, maxBurst, multiple);
return obj;
}
