int wrmsr(int addr, msr_t msr)
{
kern_return_t err;
size_t dataInLen = sizeof(msrcmd_t);
size_t dataOutLen = sizeof(msrcmd_t);
msrcmd_t in, out;
in.core = current_logical_cpu;
in.index = addr;
in.lo = msr.lo;
in.hi = msr.hi;
#if !defined(__LP64__) && defined(WANT_OLD_API)
/* Check if OSX 10.5 API is available */
if (IOConnectCallStructMethod != NULL) {
#endif
err = IOConnectCallStructMethod(connect, kWriteMSR, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
} else {
/* Use old API */
err = IOConnectMethodStructureIStructureO(connect, kWriteMSR, dataInLen, &dataOutLen, &in, &out);
}
#endif
if (err != KERN_SUCCESS)
return 1;
return 0;
}
USBLIB_DECL(void *) USBLibAddFilter(PCUSBFILTER pFilter)
{
VBOXUSBADDFILTEROUT Out = { 0, VERR_WRONG_ORDER };
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1050
IOByteCount cbOut = sizeof(Out);
kern_return_t kr = IOConnectMethodStructureIStructureO(g_Connection,
VBOXUSBMETHOD_ADD_FILTER,
sizeof(*pFilter),
&cbOut,
(void *)pFilter,
&Out);
#else /* 10.5 and later */
size_t cbOut = sizeof(Out);
kern_return_t kr = IOConnectCallStructMethod(g_Connection,
VBOXUSBMETHOD_ADD_FILTER,
(void *)pFilter, sizeof(*pFilter),
&Out, &cbOut);
#endif /* 10.5 and later */
if ( kr == kIOReturnSuccess
&& RT_SUCCESS(Out.rc))
{
Assert(cbOut == sizeof(Out));
Assert((void *)Out.uId != NULL);
return (void *)Out.uId;
}
AssertMsgFailed(("kr=%#x Out.rc=%Rrc\n", kr, Out.rc));
return NULL;
}
static int darwin_iowrite(int pos, unsigned char * buf, int len)
{
kern_return_t err;
size_t dataInLen = sizeof(iomem_t);
size_t dataOutLen = sizeof(iomem_t);
iomem_t in;
iomem_t out;
in.width = len;
in.offset = pos;
memcpy(&in.data, buf, len);
if (len > 4)
return 1;
#if !defined(__LP64__) && defined(WANT_OLD_API)
/* Check if OSX 10.5 API is available */
if (IOConnectCallStructMethod != NULL) {
#endif
err = IOConnectCallStructMethod(connect, kWriteIO, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
} else {
/* Use old API */
err = IOConnectMethodStructureIStructureO(connect, kWriteIO, dataInLen, &dataOutLen, &in, &out);
}
#endif
if (err != KERN_SUCCESS)
return 1;
return 0;
}
msr_t rdmsr(int addr)
{
kern_return_t err;
size_t dataInLen = sizeof(msrcmd_t);
size_t dataOutLen = sizeof(msrcmd_t);
msrcmd_t in, out;
msr_t ret = { INVALID_MSR_HI, INVALID_MSR_LO };
in.core = current_logical_cpu;
in.index = addr;
#if !defined(__LP64__) && defined(WANT_OLD_API)
/* Check if OSX 10.5 API is available */
if (IOConnectCallStructMethod != NULL) {
#endif
err = IOConnectCallStructMethod(connect, kReadMSR, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
} else {
/* Use old API */
err = IOConnectMethodStructureIStructureO(connect, kReadMSR, dataInLen, &dataOutLen, &in, &out);
}
#endif
if (err != KERN_SUCCESS)
return ret;
ret.lo = out.lo;
ret.hi = out.hi;
return ret;
}
static int darwin_ioread(int pos, unsigned char * buf, int len)
{
kern_return_t err;
size_t dataInLen = sizeof(iomem_t);
size_t dataOutLen = sizeof(iomem_t);
iomem_t in;
iomem_t out;
UInt32 tmpdata;
in.width = len;
in.offset = pos;
if (len > 4)
return 1;
#if !defined(__LP64__) && defined(WANT_OLD_API)
/* Check if OSX 10.5 API is available */
if (IOConnectCallStructMethod != NULL) {
#endif
err = IOConnectCallStructMethod(connect, kReadIO, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
} else {
/* Use old API */
err = IOConnectMethodStructureIStructureO(connect, kReadIO, dataInLen, &dataOutLen, &in, &out);
}
#endif
if (err != KERN_SUCCESS)
return 1;
tmpdata = out.data;
switch (len) {
case 1:
memcpy(buf, &tmpdata, 1);
break;
case 2:
memcpy(buf, &tmpdata, 2);
break;
case 4:
memcpy(buf, &tmpdata, 4);
break;
}
return 0;
}
USBLIB_DECL(void) USBLibRemoveFilter(void *pvId)
{
int rc = VERR_WRONG_ORDER;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1050
IOByteCount cbOut = sizeof(rc);
kern_return_t kr = IOConnectMethodStructureIStructureO(g_Connection,
VBOXUSBMETHOD_REMOVE_FILTER,
sizeof(pvId),
&cbOut,
&pvId,
&rc);
#else /* 10.5 and later */
size_t cbOut = sizeof(rc);
kern_return_t kr = IOConnectCallStructMethod(g_Connection,
VBOXUSBMETHOD_REMOVE_FILTER,
(void *)&pvId, sizeof(pvId),
&rc, &cbOut);
#endif /* 10.5 and later */
AssertMsg(kr == kIOReturnSuccess && RT_SUCCESS(rc), ("kr=%#x rc=%Rrc\n", kr, rc));
NOREF(kr);
}
kern_return_t SMCCall(int index, SMCKeyData_t *inputStructure, SMCKeyData_t *outputStructure)
{
size_t structureInputSize;
size_t structureOutputSize;
structureInputSize = sizeof(SMCKeyData_t);
structureOutputSize = sizeof(SMCKeyData_t);
#if MAC_OS_X_VERSION_10_5
return IOConnectCallStructMethod( conn, index,
// inputStructure
inputStructure, structureInputSize,
// ouputStructure
outputStructure, &structureOutputSize );
#else
return IOConnectMethodStructureIStructureO( conn, index,
structureInputSize, /* structureInputSize */
&structureOutputSize, /* structureOutputSize */
inputStructure, /* inputStructure */
outputStructure); /* ouputStructure */
#endif
}
void *map_physical(uint64_t phys_addr, size_t len)
{
kern_return_t err;
#if __LP64__
mach_vm_address_t addr;
mach_vm_size_t size;
#else
vm_address_t addr;
vm_size_t size;
#endif
size_t dataInLen = sizeof(map_t);
size_t dataOutLen = sizeof(map_t);
map_t in, out;
in.addr = phys_addr;
in.size = len;
#ifdef DEBUG
printf("map_phys: phys %08lx, %08x\n", phys_addr, len);
#endif
#if !defined(__LP64__) && defined(WANT_OLD_API)
/* Check if OSX 10.5 API is available */
if (IOConnectCallStructMethod != NULL) {
#endif
err = IOConnectCallStructMethod(connect, kPrepareMap, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
} else {
/* Use old API */
err = IOConnectMethodStructureIStructureO(connect, kPrepareMap, dataInLen, &dataOutLen, &in, &out);
}
#endif
if (err != KERN_SUCCESS) {
printf("\nError(kPrepareMap): system 0x%x subsystem 0x%x code 0x%x ",
err_get_system(err), err_get_sub(err), err_get_code(err));
printf("physical 0x%08"PRIx64"[0x%zx]\n", phys_addr, len);
switch (err_get_code(err)) {
case 0x2c2: printf("Invalid argument.\n"); errno = EINVAL; break;
case 0x2cd: printf("Device not open.\n"); errno = ENOENT; break;
}
return MAP_FAILED;
}
err = IOConnectMapMemory(connect, 0, mach_task_self(),
&addr, &size, kIOMapAnywhere | kIOMapInhibitCache);
/* Now this is odd; The above connect seems to be unfinished at the
* time the function returns. So wait a little bit, or the calling
* program will just segfault. Bummer. Who knows a better solution?
*/
usleep(1000);
if (err != KERN_SUCCESS) {
printf("\nError(IOConnectMapMemory): system 0x%x subsystem 0x%x code 0x%x ",
err_get_system(err), err_get_sub(err), err_get_code(err));
printf("physical 0x%08"PRIx64"[0x%zx]\n", phys_addr, len);
switch (err_get_code(err)) {
case 0x2c2: printf("Invalid argument.\n"); errno = EINVAL; break;
case 0x2cd: printf("Device not open.\n"); errno = ENOENT; break;
}
return MAP_FAILED;
}
#ifdef DEBUG
printf("map_phys: virt %08x, %08x\n", addr, size);
#endif
return (void *)addr;
}
static int probe_sms(int kernFunc, char *servMatch, int dataType, void *data)
{
kern_return_t result;
mach_port_t masterPort;
io_iterator_t iterator;
io_object_t aDevice;
io_connect_t dataPort;
IOItemCount structureInputSize;
IOByteCount structureOutputSize;
union motion_data inputStructure;
union motion_data *outputStructure;
outputStructure = (union motion_data *)data;
result = IOMasterPort(MACH_PORT_NULL, &masterPort);
CFMutableDictionaryRef matchingDictionary = IOServiceMatching(servMatch);
result = IOServiceGetMatchingServices(masterPort, matchingDictionary, &iterator);
if (result != KERN_SUCCESS) {
//fputs("IOServiceGetMatchingServices returned error.\n", stderr);
return 0;
}
aDevice = IOIteratorNext(iterator);
IOObjectRelease(iterator);
if (aDevice == 0) {
//fputs("No motion sensor available\n", stderr);
return 0;
}
result = IOServiceOpen(aDevice, mach_task_self(), 0, &dataPort);
IOObjectRelease(aDevice);
if (result != KERN_SUCCESS) {
//fputs("Could not open motion sensor device\n", stderr);
return 0;
}
switch ( dataType ) {
case PB_IB:
structureInputSize = sizeof(struct pb_ib_data);
structureOutputSize = sizeof(struct pb_ib_data);
break;
case MBP:
structureInputSize = sizeof(struct mbp_data);
structureOutputSize = sizeof(struct mbp_data);
break;
default:
return 0;
}
memset(&inputStructure, 0, sizeof(union motion_data));
memset(outputStructure, 0, sizeof(union motion_data));
result = IOConnectMethodStructureIStructureO(dataPort, kernFunc, structureInputSize,
&structureOutputSize, &inputStructure, outputStructure);
IOServiceClose(dataPort);
if (result != KERN_SUCCESS) {
//puts("no coords");
return 0;
}
return 1;
}
void Test( mach_port_t masterPort, io_service_t service )
{
kern_return_t kr;
io_connect_t connect;
size_t structureOutputSize;
AppleSampleStructForMethod2 method2Param;
AppleSampleResultsForMethod2 method2Results;
uint32_t varStructParam[3] = { 1, 2, 3 };
IOByteCount bigBufferLen;
uint32_t * bigBuffer;
kr = IOServiceOpen( service, mach_task_self(), kAppleSamplePCIConnectType, &connect );
assert( KERN_SUCCESS == kr );
// test a simple struct in/out method
structureOutputSize = sizeof(varStructParam);
#if MAC_OS_X_VERSION_10_5
kr = IOConnectCallStructMethod( connect, kAppleSampleMethod1,
// inputStructure
&varStructParam, sizeof(varStructParam),
// ouputStructure
&varStructParam, &structureOutputSize );
#else
kr = IOConnectMethodStructureIStructureO( connect, kAppleSampleMethod1,
sizeof(varStructParam), /* structureInputSize */
&structureOutputSize, /* structureOutputSize */
&varStructParam, /* inputStructure */
&varStructParam); /* ouputStructure */
#endif
assert( KERN_SUCCESS == kr );
printf("kAppleSampleMethod1 results 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 "\n",
varStructParam[0], varStructParam[1], varStructParam[2]);
// test shared memory
TestSharedMemory( connect );
// test method with out of line memory
bigBufferLen = 0x4321;
bigBuffer = malloc( bigBufferLen );
strcpy( (char *) (bigBuffer + (32 / 4)), "some out of line data");
method2Param.parameter1 = 0x12345678;
method2Param.data_pointer = (uintptr_t) bigBuffer;
method2Param.data_length = bigBufferLen;
structureOutputSize = sizeof(method2Results);
#if MAC_OS_X_VERSION_10_5
kr = IOConnectCallStructMethod( connect, kAppleSampleMethod2,
// inputStructure
&method2Param, sizeof(method2Param),
// ouputStructure
&method2Results, &structureOutputSize );
#else
kr = IOConnectMethodStructureIStructureO( connect, kAppleSampleMethod2,
sizeof(method2Param), /* structureInputSize */
&structureOutputSize, /* structureOutputSize */
&method2Param, /* inputStructure */
&method2Results); /* ouputStructure */
#endif
assert( KERN_SUCCESS == kr );
printf("kAppleSampleMethod2 result 0x%" PRIx64 "\n", method2Results.results1);
free( bigBuffer );
}
