// Sleeps until we receive USB resume signaling.
// This uses PM1. ( PM2 and PM3 are not usable because they will reset the USB module. )
// NOTE: For some reason, USB suspend does not work if you plug your device into a computer
// that is already sleeping. If you do that, the device will remain awake with
// usbDeviceState == USB_STATE_POWERED and it will draw more power than it should from USB.
// TODO: figure out how to wake up when self power is connected. Probably we should use the
// sleep timer to wake up regularly and check (that's going to be easier than using a P2
// interrupt I think).
// TODO: make sure suspend mode doesn't interfere with the radio libraries. We should
// probably make a simple power-event registration thing using function pointers,
// (either an array, or a linked list where the memory is contributed by the modules using it).
// When going to sleep, we would call these functions in the order they were added;
// when waking up, we would call them in the opposite order. Look at how we handle power
// on the jrk, maestros, and simple motor controller to see if this pattern works.
void usbSleep()
{
uint8 savedPICTL = PICTL;
BIT savedP0IE = P0IE;
// The USB resume interrupt is mapped to the non-existent pin, P0_7.
P0IE = 0; // Disable the P0 interrupt while we are reconfiguring it (maybe not necessary).
PICTL |= (1<<4); // PICTL.P0IENH = 1 Enable the Port 0 interrupts for inputs 4-7 (USB_RESUME is #7).
PICTL &= ~(1<<0); // PICTL.P0ICON = 0 Detect rising edges (this is required for waking up).
do
{
// Clear the P0 interrupt flag that might prevent us from sleeping.
P0IFG = 0; // Clear Port 0 module interrupt flags.
P0IF = 0; // Clear Port 0 CPU interrupt flag (IRCON.P0IF = 0).
P0IE = 1; // Enable the Port 0 interrupt (IEN1.P0IE = 1) so we can wake up.
// Put the device to sleep by following the recommended pseudo code in the datasheet section 12.1.3:
SLEEP = (SLEEP & ~3) | 1; // SLEEP.MODE = 1 : Selects Power Mode 1 (PM1).
__asm nop __endasm; __asm nop __endasm; __asm nop __endasm;
if (SLEEP & 3)
{
P1_0 = 1;
PCON |= 1; // PCON.IDLE = 1 : Actually go to sleep.
P1_0 = 0;
}
// Disable the Port 0 interrupt. If we don't do this, and there is no ISR
// (just a reti), then the non-existent ISR could run many times while we
// are awake, slowing down this loop.
P0IE = 0; // (IEN1.P0IE = 1)
// Check to see if the USB_RESUME bit is set. If it is set, then there was
// activity detected on the USB and it is time to wake up.
// NOTE: The P0INT ISR might also set usbSuspendMode to 0 if the user defines
// that ISR. See the comment about P0INT in usb.h for more info.
if (P0IFG & 0x80)
{
usbSuspendMode = 0;
}
}
while(usbSuspendMode && !vinPowerPresent());
// Wait for the high speed crystal oscillator to become stable again
// because we can't write to USB registers until that happens.
while(!(SLEEP & (1<<6))){};
// Restore the interrupt registers to their original states.
PICTL = savedPICTL;
P0IE = savedP0IE;
}
void updateSerialMode()
{
if ((uint8)param_serial_mode > 0 && (uint8)param_serial_mode <= 3)
{
currentSerialMode = (uint8)param_serial_mode;
return;
}
if (usbPowerPresent())
{
if (vinPowerPresent())
{
currentSerialMode = SERIAL_MODE_USB_SPI;
}
else
{
currentSerialMode = SERIAL_MODE_USB_RADIO;
}
}
else
{
currentSerialMode = SERIAL_MODE_SPI_RADIO;
}
}
// usbStandardDeviceRequestHandler(): Implementation of USB2.0 Section 9.4, Standard Device Requests.
// This function gets called whenever we receive a SETUP packet on endpoint zero with the requestType
// field set to STANDARD. This function reads the SETUP packet and uses that to set the control
// transfer state variables with all the information needed to respond to the request.
// Assumption: controlTransferState is CONTROL_TRANSFER_STATE_NONE when this function is called.
static void usbStandardDeviceRequestHandler()
{
// Prepare a convenient two-byte buffer for sending 1 or 2 byte responses.
static XDATA uint8 response[2];
response[0] = 0;
response[1] = 0;
// Now we decide how to handle the new setup packet. There are several possibilities:
// * Invalid: The SETUP packet had a problem with it, or we don't support the feature,
// so we need to STALL the next transaction to indicate an request error to the host.
// * Control Read: We must send some data to the computer, so we need to decide
// where the data is coming from (address, plus RAM/ROM selection)
// * Control Write with no data phase: We need to prepare for the status phase, where
// our device must send a zero-length EP0 IN packet to indicate success.
// * Control Write with data phase: The computer will send data to us, and we need to
// decide where in RAM to put it. (No standard device requests use this type,
// so ignore this case.)
switch(usbSetupPacket.bRequest)
{
case USB_REQUEST_GET_DESCRIPTOR: // USB Spec 9.4.3 Get Descriptor
{
switch(usbSetupPacket.wValue >> 8)
{
case USB_DESCRIPTOR_TYPE_DEVICE:
{
controlTransferPointer = (uint8 XDATA *)&usbDeviceDescriptor;
controlTransferBytesLeft = sizeof(USB_DESCRIPTOR_DEVICE);
break;
}
case USB_DESCRIPTOR_TYPE_CONFIGURATION:
{
if ((usbSetupPacket.wValue & 0xFF) != 0)
{
// Invalid configuration index.
return;
}
// The configuration descriptor has an application-dependent size, which
// we determine by reading the 3rd and 4th byte.
controlTransferPointer = (uint8 XDATA *)usbConfigurationDescriptor;
controlTransferBytesLeft = *(uint16 *)&usbConfigurationDescriptor[2];
break;
}
case USB_DESCRIPTOR_TYPE_STRING:
{
if ((usbSetupPacket.wValue & 0xFF) >= usbStringDescriptorCount)
{
// This is either an invalid string index or it is 0xEE,
// which is defined by Microsoft OS Descriptors 1.0.
// This library provides no features for handling such requests,
// but we call the user's callback in case they want to.
usbCallbackClassDescriptorHandler();
return;
}
controlTransferPointer = (uint8 XDATA *)usbStringDescriptors[usbSetupPacket.wValue & 0xFF];
controlTransferBytesLeft = controlTransferPointer[0];
break;
}
default:
{
// see if the class recognizes the descriptor type; it should call usbControlRead if it does
usbCallbackClassDescriptorHandler();
if (controlTransferState == CONTROL_TRANSFER_STATE_NONE)
{
// unknown type of descriptor
return;
}
break;
}
}
controlTransferState = CONTROL_TRANSFER_STATE_READ;
return;
}
case USB_REQUEST_SET_ADDRESS: // USB Spec, 9.4.6 Set Address
{
// Get ready to set the address when the status phase is complete.
// We always set the most siginificant bit, because .device_address might be 0
// and that is a valid request, meaning we should revert to address 0.
//pendingDeviceAddress = (usbSetupPacket.wValue & 0xFF) | 0x80;
USBADDR = (uint8)usbSetupPacket.wValue;
usbDeviceState = ((uint8)usbSetupPacket.wValue) ? USB_STATE_ADDRESS : USB_STATE_DEFAULT;
// Get ready to provide a handshake.
usbControlAcknowledge();
return;
}
case USB_REQUEST_SET_CONFIGURATION: // USB Spec, 9.4.7 Set Configuration
{
// Assumption: there is only one configuration and its value is 1.
switch(usbSetupPacket.wValue)
{
case 0:
{
// We have been deconfigured.
// TODO: Add resetNonzeroEndpoints() and call it here.
if (usbDeviceState > USB_STATE_ADDRESS)
{
usbDeviceState = USB_STATE_ADDRESS;
}
break;
}
case 1:
{
// The device has been configured. This is normal operating
// state of a USB device. We can now start using non-zero
// endpoints.
usbDeviceState = USB_STATE_CONFIGURED;
usbCallbackInitEndpoints();
break;
}
default:
{
// Invalid configuration value, so STALL.
return;
}
}
// Get ready to provide a handshake.
usbControlAcknowledge();
return;
}
case USB_REQUEST_GET_CONFIGURATION: // USB Spec 9.4.2 Get Configuration
{
// Assumption: there is only one configuration and its value is 1.
response[0] = (usbDeviceState == USB_STATE_CONFIGURED) ? 1 : 0;
usbControlRead(1, response);
return;
}
case USB_REQUEST_GET_INTERFACE: // USB Spec 9.4.4 Get Interface
{
// Assumption: the "alternate setting number" of each interface
// is zero and there are no alternate settings.
// Assumption: interface numbers go from 0 to
// config->interface_count-1, with no gaps.
if (usbDeviceState < USB_STATE_CONFIGURED)
{
// Invalid request because we have not reached the configured state.
return;
}
if (usbSetupPacket.wIndex >= ((USB_DESCRIPTOR_CONFIGURATION *)&usbConfigurationDescriptor)->bNumInterfaces)
{
// Invalid index: there is no such interface.
return;
}
// Send a single-byte response of "0".
// Assumption: response[0] == 0
usbControlRead(1, response);
return;
}
case USB_REQUEST_GET_STATUS: // USB Spec 9.4.5 Get Status
{
switch(usbSetupPacket.recipient)
{
case USB_RECIPIENT_DEVICE:
{
// See USB Spec Table 9-4.
response[0] = vinPowerPresent() ? 1 : 0;
// Assumption: response[1] == 0
usbControlRead(2, response);
return;
}
case USB_RECIPIENT_INTERFACE:
{
if (usbDeviceState < USB_STATE_CONFIGURED && usbSetupPacket.wIndex != 0)
{
// It is invalid to ask about interfaces other than 0 before the
// configured state.
return;
}
if (usbSetupPacket.wIndex >= ((USB_DESCRIPTOR_CONFIGURATION *)&usbConfigurationDescriptor)->bNumInterfaces)
{
// Invalid index: there is no such interface.
return;
}
// Send a 2-byte response of 0,0 (all of the bits are reserved)
// Assumption: response[0] == 0 and response[1] == 0
usbControlRead(2, response);
return;
}
case USB_RECIPIENT_ENDPOINT:
{
if ((usbSetupPacket.wValue & 15) == 0)
{
// We don't support the halt feature on Endpoint 0
// (the USB Spec does not require or recommend it).
return;
}
if (usbDeviceState < USB_STATE_CONFIGURED)
{
// It is invalid to ask about non-zero endpoints before
// the configured state.
return;
}
// Assumption: We don't have a USB halt feature, i.e. we
// don't stall on non-zero endpoints.
// Send a 2-byte response of 0,0.
// Assumption: response[0] == 0 and response[1] == 0
usbControlRead(2, response);
return;
}
}
return;
}
// Here are some more standard device requests we would need
// to be USB compliant. We didn't use them yet on any of our
// PIC devices and it has not caused a problem as far as I
// know. We pay lip service to them here just in case they are
// needed by some future driver.
case USB_REQUEST_SET_FEATURE:
case USB_REQUEST_CLEAR_FEATURE:
{
// Acknowledge the request but don't do anything.
usbControlAcknowledge();
return;
}
case USB_REQUEST_SYNCH_FRAME:
{
// Send a two-byte response of 0,0.
usbControlRead(2, response);
return;
}
}
}
