void useUSBDevice(IOUSBDeviceInterface245 **dev, UInt32 configuration)
{
io_iterator_t interfaceIterator;
IOUSBFindInterfaceRequest req;
IOReturn err;
err = (*dev)->SetConfiguration(dev, configuration);
if(err != kIOReturnSuccess)
{
printInterpretedError("Could not set configuration on device", err);
return;
}
req.bInterfaceClass = kIOUSBFindInterfaceDontCare;
req.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
req.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
req.bAlternateSetting = kIOUSBFindInterfaceDontCare;
err = (*dev)->CreateInterfaceIterator(dev, &req, &interfaceIterator);
if(err != kIOReturnSuccess)
{
printInterpretedError("Could not create interface iterator", err);
return;
}
err = iterateinterfaces(interfaceIterator);
IOObjectRelease(interfaceIterator);
}
UInt32 openUSBInterface(IOUSBInterfaceInterface245 **intf)
{
IOReturn ret;
#if VERBOSE
UInt8 n;
int i;
UInt8 direction;
UInt8 number;
UInt8 transferType;
UInt16 maxPacketSize;
UInt8 interval;
static char *types[]={
"Control",
"Isochronous",
"Bulk",
"Interrupt"};
static char *directionStr[]={
"Out",
"In",
"Control"};
#endif
ret = (*intf)->USBInterfaceOpen(intf);
if(ret != kIOReturnSuccess)
{
printInterpretedError("Could not set configuration on device", ret);
return(-1);
}
#if VERBOSE
// We don't use the endpoints in our device, but it has some anyway
ret = (*intf)->GetNumEndpoints(intf, &n);
if(ret != kIOReturnSuccess)
{
printInterpretedError("Could not get number of endpoints in interface", ret);
return(0);
}
printf("%d endpoints found\n", n);
for(i = 1; i<=n; i++)
{
ret = (*intf)->GetPipeProperties(intf, i, &direction, &number, &transferType, &maxPacketSize, &interval);
if(ret != kIOReturnSuccess)
{
fprintf(stderr, "Endpoint %d -", n);
printInterpretedError("Could not get endpoint properties", ret);
return(0);
}
printf("Endpoint %d: %s %s %d, max packet %d, interval %d\n", i, types[transferType], directionStr[direction], number, maxPacketSize, interval);
}
#endif
return(0);
}
SInt32 openUSBDevice(IOUSBDeviceInterface245 **dev)
{
UInt8 numConfig;
IOReturn err;
IOUSBConfigurationDescriptorPtr desc;
err = (*dev)->GetNumberOfConfigurations(dev, &numConfig);
if(err != kIOReturnSuccess)
{
printInterpretedError("Could not number of configurations from device", err);
return(-1);
}
if(numConfig != 1)
{
fprintf(stderr, "This does not look like the right device, it has %d configurations (we want 1)\n", numConfig);
return(-1);
}
err = (*dev)->GetConfigurationDescriptorPtr(dev, 0, &desc);
if(err != kIOReturnSuccess)
{
printInterpretedError("Could not get configuration descriptor from device", err);
return(-1);
}
#if VERBOSE
printf("Configuration value is %d\n", desc->bConfigurationValue);
#endif
// We should really try to do classic arbitration here
err = (*dev)->USBDeviceOpen(dev);
if(err == kIOReturnExclusiveAccess)
{
#if VERBOSE
printf("Exclusive error opening device, we may come back to this later\n");
#endif
return(-2);
}
if(err != kIOReturnSuccess)
{
printInterpretedError("Could not open device", err);
return(-1);
}
return(desc->bConfigurationValue);
}
void finallyDoSomethingWithThisDevice(IOUSBInterfaceInterface245 **intf)
{
#if PUMPKIN
IOReturn err;
UInt32 IOBits, currState;
UInt32 state, bit;
int i;
void *hBits;
// Now set all bits output.
err = DevaSetIoPortsConfig(intf, 0);
if (kIOReturnSuccess != err)
{
printInterpretedError("unable to do SetIoPortsConfig", err);
return;
}
err = DevaWriteIoPorts(intf, 0x000FFFFF, 0x000FFFFF);
if(kIOReturnSuccess != err)
{
printInterpretedError("unable to do WriteIoPorts", err);
return;
}
usleep(100 * 1000);
state = 0;
while(!quitFlag)
{
bit = 1;
IOBits = 0;
currState = states[state].state +constState;
for(i= 0; i<20; i++)
{
if((currState & bit) != 0)
{
IOBits |= lights[i];
}
bit <<= 1;
}
hBits = (void *)IOBits;
err = DevaWriteIoPorts(intf, IOBits, 0x000FFFFF);
if(kIOReturnSuccess != err)
{
printInterpretedError("unable to write walking bit", err);
return;
}
usleep(states[state].time*100 * 1000*dwellTenths);
if(++state >= numStates)
{
state = 0;
}
}
#else
IOReturn err;
UInt32 portBits, IOBits, IOBits1;
UInt32 light, light2;
Boolean dirn;
// First set all ports to input
err = DevaSetIoPortsConfig(intf, 0x000FFFFF);
if (kIOReturnSuccess != err)
{
printInterpretedError("unable to do bulk write", err);
return;
}
// Next read IO bits, switches which are on should be 1 everything else 0
err = DevaReadIoPorts(intf, &IOBits);
if (kIOReturnSuccess != err)
{
printInterpretedError("unable to do ReadIoPorts", err);
return;
}
printf("Port IO read gives: %08lx\n", IOBits);
// Now set all free bits output.
err = DevaSetIoPortsConfig(intf, IOBits);
if (kIOReturnSuccess != err)
{
printInterpretedError("unable to do SetIoPortsConfig", err);
return;
}
while(1)
{
// Now set all free bits to 1.
err = DevaWriteIoPorts(intf, 0x000FFFFF, 0x000FFFFF);
if(kIOReturnSuccess != err)
{
printInterpretedError("unable to do WriteIoPorts", err);
return;
}
//sleep(9);
sleep(1);
portBits = 0;
light = 0;
light2 = 8;
dirn= false;
// IOBits1 = IOBits;
do{
IOBits1 = IOBits;
#if 0
do{
portBits <<= 1;
// portBits2 >>= 1;
if((portBits & 0x000FFFFF)== 0)
{
portBits = 1;
// portBits2 = (0x000FFFFF+1)/2;
}
}while((portBits & ~IOBits) == 0);
#endif
if( (light >= 7) || (light <= 0) )
{
// light = 0;
// light2 = 19;
dirn = !dirn;
}
light2++;
if(light2 > 19)
{
light2 = 8;
}
portBits = lights[light] | lights[light2];
if(dirn)
{
light++;
}
else
{
light--;
}
err = DevaWriteIoPorts(intf, portBits, 0x000FFFFF);
if(kIOReturnSuccess != err)
{
printInterpretedError("unable to write walking bit", err);
return;
}
// sleep(1);
usleep(100 * 1000);
err = DevaWriteIoPorts(intf, 0, 0x000FFFFF);
if(kIOReturnSuccess != err)
{
printInterpretedError("unable to write zero bits", err);
return;
}
// set all to input
err = DevaSetIoPortsConfig(intf, 0x000FFFFF);
if (kIOReturnSuccess != err)
{
printInterpretedError("unable to do bulk write", err);
return;
}
if(quitFlag) return; // We've been interupted
// Next read IO bits, switches which are on should be 1 everything else 0
err = DevaReadIoPorts(intf, &IOBits);
if (kIOReturnSuccess != err)
{
printInterpretedError("unable to do ReadIoPorts", err);
return;
}
// printf("Port IO read 2 gives: %08lx (old %08lx)\n", IOBits1, IOBits);
// Now set all free bits output.
err = DevaSetIoPortsConfig(intf, IOBits);
if (kIOReturnSuccess != err)
{
printInterpretedError("unable to do SetIoPortsConfig", err);
return;
}
} while(IOBits1 == IOBits);
}
#endif
}
int main (int argc, const char * argv[])
{
IOReturn err;
mach_port_t masterPort;
CFMutableDictionaryRef dict;
SInt32 usbVID;
SInt32 usbPID;
#if MATCH_INTERFACE
SInt32 usbConfig;
SInt32 usbIntNum;
#endif
io_iterator_t anIterator;
sig_t oldHandler;
if(argc < 3)
{
#if VERBOSE
int i;
printf("argc %d\n", argc);
for(i= 0; i<argc; i++)
{
printf("argv[%d]:\"%s\"\n", i, argv[i]);
}
#endif
fprintf(stderr, "Usage: filename VID PID\n");
return(-1);
}
usbVID = atoi(argv[1]);
usbPID = atoi(argv[2]);
// Set up a signal handler so we can clean up when we're interrupted from the command line
// Otherwise we stay in our run loop forever.
oldHandler = signal(SIGINT, SignalHandler);
if (oldHandler == SIG_ERR)
fprintf(stderr, "Could not establish new signal handler (err = %d)\n", errno);
err = IOMasterPort(MACH_PORT_NULL, &masterPort);
if(err != kIOReturnSuccess)
{
printInterpretedError("Could not get master port", err);
return(-1);
}
#if MATCH_INTERFACE
dict = IOServiceMatching("IOUSBInterface");
#else
dict = IOServiceMatching("IOUSBDevice");
#endif
if(dict == nil)
{
fprintf(stderr, "Could create matching dictionary\n");
return(-1);
}
CFDictionarySetValue(
dict,
CFSTR(kUSBVendorID),
CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &usbVID)
);
CFDictionarySetValue(dict, CFSTR(kUSBProductID),
CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &usbPID));
#if MATCH_INTERFACE
// Look for interface 0 in config 1.
// These should really come from parameters.
usbConfig = 1;
usbIntNum = 0;
CFDictionarySetValue(dict, CFSTR(kUSBConfigurationValue),
CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &usbConfig));
CFDictionarySetValue(dict, CFSTR(kUSBInterfaceNumber),
CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &usbIntNum));
#endif
err = IOServiceGetMatchingServices(masterPort, dict, &anIterator);
if(err != kIOReturnSuccess)
{
printInterpretedError("Could not get device iterator", err);
return(-1);
}
#if MATCH_INTERFACE
err = iterateinterfaces(anIterator);
#else
err = iterateDevices(anIterator);
#endif
IOObjectRelease(anIterator);
return err;
}