/* Entry function for the gpioPWMThread */
void
GpioPWMThread_Entry (
uint32_t input)
{
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
/* Initialize Debug module */
apiRetStatus = CyFxDebugInit();
if (apiRetStatus != CY_U3P_SUCCESS)
{
CyFxAppErrorHandler(apiRetStatus);
}
/* Initialize GPIO module. */
CyFxGpioInit ();
/* Now resume the other two threads. */
CyU3PThreadResume (&gpioMeasureThread);
CyU3PThreadResume (&gpioCounterThread);
for (;;)
{
/* Wait for 1s. */
CyU3PThreadSleep (1000);
/* Change the PWM duty cycle to 75%. */
apiRetStatus = CyU3PGpioComplexUpdate (50,
CY_FX_PWM_75P_THRESHOLD, CY_FX_PWM_PERIOD);
if (apiRetStatus != CY_U3P_SUCCESS)
{
CyU3PDebugPrint (4, "CyU3PGpioComplexUpdate failed, error code = %d\n",
apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Wait for 1s. */
CyU3PThreadSleep (1000);
/* Change the PWM duty cycle to 25%. */
apiRetStatus = CyU3PGpioComplexUpdate (50,
CY_FX_PWM_25P_THRESHOLD, CY_FX_PWM_PERIOD);
if (apiRetStatus != CY_U3P_SUCCESS)
{
CyU3PDebugPrint (4, "CyU3PGpioComplexUpdate failed, error code = %d\n",
apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
}
}
/* Entry function for the gpioOutputThread */
void
GpioOutputThread_Entry (
uint32_t input)
{
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
/* Initialize Debug module */
apiRetStatus = CyFxDebugInit();
if (apiRetStatus != CY_U3P_SUCCESS)
{
/* Error handling */
CyU3PDebugPrint (4, "Debug module initialization failed, error code = %d\n",
apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Initialize GPIO module. */
CyFxGpioInit ();
for (;;)
{
/* Set the GPIO 21 to high */
apiRetStatus = CyU3PGpioSetValue (21, CyTrue);
if (apiRetStatus != CY_U3P_SUCCESS)
{
/* Error handling */
CyU3PDebugPrint (4, "CyU3PGpioSetValue failed, error code = %d\n",
apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Wait for two seconds */
CyU3PThreadSleep(2000);
/* Set the GPIO 21 to low */
apiRetStatus = CyU3PGpioSetValue (21, CyFalse);
if (apiRetStatus != CY_U3P_SUCCESS)
{
/* Error handling */
CyU3PDebugPrint (4, "CyU3PGpioSetValue failed, error code = %d\n",
apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Wait for two seconds */
CyU3PThreadSleep(2000);
}
}
/* Entry function for the gpioCounterThread */
void
GpioCounterThread_Entry (
uint32_t input)
{
uint32_t threshold = 0;
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
for (;;)
{
/* This will retreive the current counter value. */
apiRetStatus = CyU3PGpioComplexSampleNow (52, &threshold);
if (apiRetStatus != CY_U3P_SUCCESS)
{
CyU3PDebugPrint (4, "CyU3PGpioComplexSampleNow failed, error code = %d\n",
apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Print out the counter value. */
CyU3PDebugPrint (4, "GPIO 52 counter reading = %d.\n", threshold);
/* Sample every 2s. */
CyU3PThreadSleep (2000);
}
}
/* This function initializes the USB module. */
CyU3PReturnStatus_t
CyFxApplnInit (void)
{
CyU3POtgConfig_t otgCfg;
CyU3PGpioClock_t clkCfg;
CyU3PGpioSimpleConfig_t simpleCfg;
CyU3PReturnStatus_t status;
/* Initialize GPIO module. */
clkCfg.fastClkDiv = 2;
clkCfg.slowClkDiv = 0;
clkCfg.halfDiv = CyFalse;
clkCfg.simpleDiv = CY_U3P_GPIO_SIMPLE_DIV_BY_2;
clkCfg.clkSrc = CY_U3P_SYS_CLK;
status = CyU3PGpioInit (&clkCfg, NULL);
if (status != CY_U3P_SUCCESS)
{
return status;
}
/* Override GPIO 21 for VBUS control. */
status = CyU3PDeviceGpioOverride (21, CyTrue);
if (status != CY_U3P_SUCCESS)
{
return status;
}
/* Configure GPIO 21 as output for VBUS control. */
simpleCfg.outValue = CY_FX_HOST_VBUS_DISABLE_VALUE;
simpleCfg.driveLowEn = CyTrue;
simpleCfg.driveHighEn = CyTrue;
simpleCfg.inputEn = CyFalse;
simpleCfg.intrMode = CY_U3P_GPIO_NO_INTR;
status = CyU3PGpioSetSimpleConfig (21, &simpleCfg);
if (status != CY_U3P_SUCCESS)
{
return status;
}
/* Wait until VBUS is stabilized. */
CyU3PThreadSleep (100);
/* Initialize the OTG module. */
otgCfg.otgMode = CY_U3P_OTG_MODE_OTG;
otgCfg.chargerMode = CY_U3P_OTG_CHARGER_DETECT_ACA_MODE;
otgCfg.cb = CyFxOtgEventCb;
status = CyU3POtgStart (&otgCfg);
if (status != CY_U3P_SUCCESS)
{
return status;
}
/* Since VBATT or VBUS is required for OTG operation enable it. */
status = CyU3PUsbVBattEnable (CyTrue);
return status;
}
void AR0330_SetHue(int32_t hue) {
CyU3PDebugPrint(4, "AR0330_SetHue: %d\r\n", hue);
#define SetLow(io) CyU3PGpioSetValue(io, CyFalse)
#define SetHigh(io) CyU3PGpioSetValue(io, CyTrue)
#define SetBit(io, value) CyU3PGpioSetValue(io, 0 != (value & 0x80))
#if 0
CyU3PReturnStatus_t status;
status = CyU3PGpioSetValue(LED_DRIVER_SDI, 0 != (hue & 1));
if (CY_U3P_SUCCESS != status) {
CyU3PDebugPrint(4, "AR0330_SetHue: error = %d 0x%x\r\n", status, status);
}
status = CyU3PGpioSetValue(LED_DRIVER_CLK, 0 != (hue & 2));
if (CY_U3P_SUCCESS != status) {
CyU3PDebugPrint(4, "AR0330_SetHue: error = %d 0x%x\r\n", status, status);
}
status = CyU3PGpioSetValue(LED_DRIVER_ED1, 0 != (hue & 4));
if (CY_U3P_SUCCESS != status) {
CyU3PDebugPrint(4, "AR0330_SetHue: error = %d 0x%x\r\n", status, status);
}
status = CyU3PGpioSetValue(LED_DRIVER_ED2, 0 != (hue & 8));
if (CY_U3P_SUCCESS != status) {
CyU3PDebugPrint(4, "AR0330_SetHue: error = %d 0x%x\r\n", status, status);
}
#else
// initialise
SetLow(LED_DRIVER_CLK);
SetHigh(LED_DRIVER_ED2);
SetLow(LED_DRIVER_ED1);
CyU3PThreadSleep(1);
for (int i = 0; i < 8; ++i) {
SetBit(LED_DRIVER_SDI, hue);
hue <<= 1; // output bit big endian
CyU3PBusyWait(10);
//CyU3PThreadSleep(10);
SetHigh(LED_DRIVER_CLK);
CyU3PBusyWait(10);
//CyU3PThreadSleep(10);
SetLow(LED_DRIVER_CLK);
}
//CyU3PThreadSleep(1);
CyU3PBusyWait(10);
SetHigh(LED_DRIVER_ED1);
//CyU3PThreadSleep(10);
CyU3PBusyWait(10);
SetLow(LED_DRIVER_ED1);
//CyU3PThreadSleep(1);
CyU3PBusyWait(10);
SetLow(LED_DRIVER_ED2);
#endif
}
/* Entry function for the gpioMeasureThread. */
void
GpioMeasureThread_Entry (
uint32_t input)
{
uint32_t threshold = 0;
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
for (;;)
{
/* Invoke the measure API. This will measure the low period for the PWM */
apiRetStatus = CyU3PGpioComplexMeasureOnce (51,
CY_U3P_GPIO_MODE_MEASURE_LOW_ONCE);
if (apiRetStatus != CY_U3P_SUCCESS)
{
CyU3PDebugPrint (4, "CyU3PGpioComplexMeasureOnce failed, error code = %d\n",
apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Since this thread should not block other threads, do not wait. */
do
{
CyU3PThreadSleep (1);
apiRetStatus = CyU3PGpioComplexWaitForCompletion (51, &threshold, CyFalse);
} while (apiRetStatus == CY_U3P_ERROR_TIMEOUT);
if (apiRetStatus != CY_U3P_SUCCESS)
{
CyU3PDebugPrint (4, "CyU3PGpioComplexWaitForCompletion failed, error code = %d\n",
apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Print out the threshold value. */
CyU3PDebugPrint (4, "GPIO 51 low threshold = %d.\n", threshold);
/* Sample every 0.5s. */
CyU3PThreadSleep (500);
}
}
/* Entry function for the AppThread. */
void
ApplnThread_Entry (
uint32_t input)
{
CyBool_t isPresent = CyFalse;
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
/* Initialize the debug logger. */
CyFxApplnDebugInit ();
/* Initialize the example application. */
status = CyFxApplnInit();
if (status != CY_U3P_SUCCESS)
{
CyU3PDebugPrint (2, "Application initialization failed. Aborting.\r\n");
CyFxAppErrorHandler (status);
}
for (;;)
{
CyU3PThreadSleep (100);
if (isPresent != glIsPeripheralPresent)
{
/* Stop previously started application. */
if (glIsApplnActive)
{
CyFxApplnStop ();
}
/* If a peripheral got connected, then enumerate
* and start the application. */
if (glIsPeripheralPresent)
{
status = CyU3PUsbHostPortEnable ();
if (status == CY_U3P_SUCCESS)
{
CyFxApplnStart ();
}
}
/* Update the state variable. */
isPresent = glIsPeripheralPresent;
}
/* Since the test needs to be done from a thread,
* this function is called at fixed interval. */
if (glHostOwner == CY_FX_HOST_OWNER_MSC_DRIVER)
{
CyFxMscDriverDoWork ();
}
}
}
/*
* Reset the image sensor using GPIO.
*/
void SensorReset(void) {
CyU3PReturnStatus_t apiRetStatus;
uint16_t preTick, posTick;
/* Drive the GPIO low to reset the sensor. */
//apiRetStatus = CyU3PGpioSetValue(SENSOR_POWER_GPIO, CyFalse);
apiRetStatus = CyU3PGpioSetValue(SENSOR_RESET_GPIO, CyFalse);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "GPIO Set Value Error, Error Code = %d\n",
apiRetStatus);
return;
}
CyU3PDebugPrint(4, "GPIO Set Value\r\n");
/* Wait for some time to allow proper reset. */
uint8_t i = 0;
while (i++ < 2){
preTick = CyU3PGetTime();
CyU3PThreadSleep(500); // change the value into 100 from 10.
posTick = CyU3PGetTime();
CyU3PDebugPrint(4, "The ticks %d %d \r\n", preTick, posTick); //additional debug
//;//CyU3PDebugPrint(4, "cpu pause \r\n");
}
/* Drive the GPIO high to bring the sensor out of reset. */
//apiRetStatus = CyU3PGpioSetValue(SENSOR_POWER_GPIO, CyTrue);
apiRetStatus = CyU3PGpioSetValue(SENSOR_RESET_GPIO, CyTrue);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "GPIO Set Value Error, Error Code = %d\n",
apiRetStatus);
return;
}
/* pause the cpu */
while (i++ < 4){
CyU3PThreadSleep(600); // change the value into 100 from 10.
//;//CyU3PDebugPrint(4, "cpu pause \r\n");
}
return;
}
/* Application error handler. */
void
CyFxAppErrorHandler (
CyU3PReturnStatus_t apiRetStatus /* API return status */
)
{
/* Application failed with the error code apiRetStatus */
/* Add custom debug or recovery actions here */
/* Loop indefinitely */
for (;;)
{
/* Thread sleep : 100 ms */
CyU3PThreadSleep (100);
}
}
/* Application error handler */
void
CyFxGpifAppErrorHandler (
CyU3PReturnStatus_t status)
{
/* Application failed with the error code status */
/* Add custom debug or recovery actions here */
/* Loop Indefinitely */
for (;;)
{
/* Thread Sleep : 100 ms */
CyU3PThreadSleep (100);
}
}
static void step(int direction) {
const uint8_t full_fwd_step[] = {
//0355, 0345, 0344, 0354 // low
0333, 0332, 0322, 0323 // medium
//0311, 0301, 0300, 0310, // high
};
s_index += direction;
if (s_index < 0) {
s_index = sizeof(full_fwd_step) - 1;
} else if (s_index >= sizeof(full_fwd_step)) {
s_index = 0;
}
CyU3PSpiTransmitWords((uint8_t *)&full_fwd_step[s_index], 1);
CyU3PThreadSleep(10);
}
CyBool_t handle_serial_num(uint8_t bReqType, uint16_t wLength) {
CyU3PI2cPreamble_t preamble;
uint32_t reg_addr = FX3_PROM_SERIALNUM0_0;
uint8_t dev_addr = 0x50;
uint8_t size = 17; // size of prom
uint16_t status;
if (wLength != 16) {
log_error("Bad length=%d \n", wLength);
return CY_U3P_ERROR_BAD_ARGUMENT;
}
switch(bReqType) {
case 0xC0:
preamble.length = 4;
preamble.buffer[0] = m24xx_get_dev_addr(dev_addr, reg_addr, size, 0);
preamble.buffer[1] = (uint8_t)(reg_addr >> 8);
preamble.buffer[2] = (uint8_t)(reg_addr & 0xFF);
preamble.buffer[3] = m24xx_get_dev_addr(dev_addr, reg_addr, size, 1);
preamble.ctrlMask = 0x0004;
status = CyU3PI2cReceiveBytes (&preamble, gSerialNum, 16, 1);
if(status) {
log_error("Error reading serial num from prom (%d)\n", status);
return CyFalse;
}
status = CyU3PUsbSendEP0Data(16, gSerialNum);
if(status) {
log_error("Error Sending serial num to EP0 (%d)\n", status);
return CyFalse;
}
return CyTrue;
case 0x40:
status = CyU3PUsbGetEP0Data(wLength, gSerialNum, 0);
if(status) {
log_error("Error getting serial num from EP0 (%d)\n", status);
return status;
}
preamble.length = 3;
preamble.buffer[0] = m24xx_get_dev_addr(dev_addr, reg_addr, size, 0);
preamble.buffer[1] = (uint8_t)(reg_addr >> 8);
preamble.buffer[2] = (uint8_t)(reg_addr & 0xFF);
preamble.ctrlMask = 0x0000;
status = CyU3PI2cTransmitBytes(&preamble, gSerialNum, 16, 1);
if(status) {
log_error("Error writing serial num to I2C (%d)\n", status);
return CyFalse;
}
/* Wait for the write to complete. */
preamble.length = 1;
status = CyU3PI2cWaitForAck(&preamble, 200);
if(status) {
log_error("Error waiting for i2c ACK after writing serial num (%d)\n", status);
return CyFalse;
}
/* An additional delay seems to be required after receiving an ACK. */
CyU3PThreadSleep (1);
return CyTrue;
default:
log_error("Bad ReqType=%d \n", bReqType);
return CY_U3P_ERROR_BAD_ARGUMENT;
}
}
/* This function initializes the mouse driver application. */
void
CyFxApplnStart ()
{
uint16_t length;
CyU3PReturnStatus_t status;
CyU3PUsbHostEpConfig_t epCfg;
/* Add EP0 to the scheduler. */
CyU3PMemSet ((uint8_t *)&epCfg, 0, sizeof(epCfg));
epCfg.type = CY_U3P_USB_EP_CONTROL;
epCfg.mult = 1;
/* Start off with 8 byte EP0 packet size. */
epCfg.maxPktSize = 8;
epCfg.pollingRate = 0;
epCfg.fullPktSize = 8;
epCfg.isStreamMode = CyFalse;
status = CyU3PUsbHostEpAdd (0, &epCfg);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
CyU3PThreadSleep (100);
/* Get the device descriptor. */
status = CyFxSendSetupRqt (0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_DEVICE_DESCR << 8), 0, 8, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Identify the EP0 packet size and update the scheduler. */
if (glEp0Buffer[7] != 8)
{
CyU3PUsbHostEpRemove (0);
epCfg.maxPktSize = glEp0Buffer[7];
epCfg.fullPktSize = glEp0Buffer[7];
status = CyU3PUsbHostEpAdd (0, &epCfg);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
}
/* Read the full device descriptor. */
status = CyFxSendSetupRqt (0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_DEVICE_DESCR << 8), 0, 18, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Set the peripheral device address. */
status = CyFxSendSetupRqt (0x00, CY_U3P_USB_SC_SET_ADDRESS,
CY_FX_HOST_PERIPHERAL_ADDRESS, 0, 0, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostSetDeviceAddress (CY_FX_HOST_PERIPHERAL_ADDRESS);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Read first four bytes of configuration descriptor to determine
* the total length. */
status = CyFxSendSetupRqt (0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_CONFIG_DESCR << 8), 0, 4, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Identify the length of the data received. */
length = CY_U3P_MAKEWORD(glEp0Buffer[3], glEp0Buffer[2]);
if (length > CY_FX_HOST_EP0_BUFFER_SIZE)
{
goto enum_error;
}
/* Read the full configuration descriptor. */
status = CyFxSendSetupRqt (0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_CONFIG_DESCR << 8), 0, length, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Identify if this is an HID mouse or MSC device that can be
* supported. If the device cannot be supported, just disable
* the port and wait for a new device to be attached. We support
* only single interface with interface class = HID(0x03),
* interface sub class = Boot (0x01)
* and interface protocol = Mouse (0x02).
* or single interface with interface class = MSC(0x08),
* interface sub class 0x06 and interface protocol BOT (0x50). */
if ((glEp0Buffer[5] == 1) && (glEp0Buffer[14] == 0x03) &&
(glEp0Buffer[15] == 0x01) && (glEp0Buffer[16] == 0x02) &&
(glEp0Buffer[28] == CY_U3P_USB_ENDPNT_DESCR))
{
status = CyFxMouseDriverInit ();
if (status == CY_U3P_SUCCESS)
{
glIsApplnActive = CyTrue;
glHostOwner = CY_FX_HOST_OWNER_MOUSE_DRIVER;
return;
}
}
else if ((glEp0Buffer[5] == 1) && (glEp0Buffer[14] == 0x08) &&
(glEp0Buffer[15] == 0x06) && (glEp0Buffer[16] == 0x50))
{
status = CyFxMscDriverInit ();
if (status == CY_U3P_SUCCESS)
{
glIsApplnActive = CyTrue;
glHostOwner = CY_FX_HOST_OWNER_MSC_DRIVER;
return;
}
}
else
{
/* Do nothing here. Fall-through to disable the USB port.
* We do not support this device. */
status = CY_U3P_ERROR_NOT_SUPPORTED;
}
enum_error:
/* Remove EP0. and disable the port. */
glHostOwner = CY_FX_HOST_OWNER_NONE;
CyU3PUsbHostEpRemove (0);
CyU3PUsbHostPortDisable ();
CyU3PDebugPrint (4, "Application start failed with error: %d.\r\n", status);
}
CyU3PReturnStatus_t
CyFxMscDriverInit ()
{
uint8_t maxLun = 0, i, retry;
uint16_t length, size, offset;
CyU3PReturnStatus_t status;
CyU3PUsbHostEpConfig_t epCfg;
CyU3PDmaChannelConfig_t dmaCfg;
/* Read first four bytes of configuration descriptor to determine
* the total length. */
status = CyFxSendSetupRqt (0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_CONFIG_DESCR << 8), 0, 4, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Identify the length of the data received. */
length = CY_U3P_MAKEWORD(glEp0Buffer[3], glEp0Buffer[2]);
if (length > CY_FX_HOST_EP0_BUFFER_SIZE)
{
goto enum_error;
}
/* Read the full configuration descriptor. */
status = CyFxSendSetupRqt (0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_CONFIG_DESCR << 8), 0, length, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Identify the EP characteristics. */
offset = 0;
while (offset < length)
{
if (glEp0Buffer[offset + 1] == CY_U3P_USB_ENDPNT_DESCR)
{
if (glEp0Buffer[offset + 3] != CY_U3P_USB_EP_BULK)
{
goto enum_error;
}
/* Retreive the information. */
glMscEpSize = CY_U3P_MAKEWORD(glEp0Buffer[offset + 5],
glEp0Buffer[offset + 4]);
if (glEp0Buffer[offset + 2] & 0x80)
{
glMscInEp = glEp0Buffer[offset + 2];
}
else
{
glMscOutEp = glEp0Buffer[offset + 2];
}
}
/* Advance to next descriptor. */
offset += glEp0Buffer[offset];
}
/* Set the new configuration. */
status = CyFxSendSetupRqt (0x00, CY_U3P_USB_SC_SET_CONFIGURATION,
1, 0, 0, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Identify the number of LUNs available.
* We will use only the first available LUN. */
status = CyFxSendSetupRqt (0xA1, CY_FX_MSC_GET_MAX_LUN,
0, 0, 1, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
maxLun = glEp0Buffer[0];
/* Add the IN endpoint. */
CyU3PMemSet ((uint8_t *)&epCfg, 0, sizeof(epCfg));
epCfg.type = CY_U3P_USB_EP_BULK;
epCfg.mult = 1;
epCfg.maxPktSize = glMscEpSize;
epCfg.pollingRate = 0;
/* Since DMA buffer sizes can only be multiple of 16 bytes and
* also since this is an interrupt endpoint where the max data
* packet size is same as the maxPktSize field, the fullPktSize
* has to be a multiple of 16 bytes. */
size = ((glMscEpSize + 0x0F) & ~0x0F);
epCfg.fullPktSize = size;
epCfg.isStreamMode = CyFalse;
status = CyU3PUsbHostEpAdd (glMscInEp, &epCfg);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Add the OUT EP. */
status = CyU3PUsbHostEpAdd (glMscOutEp, &epCfg);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Create a DMA channel for IN EP. */
CyU3PMemSet ((uint8_t *)&dmaCfg, 0, sizeof(dmaCfg));
dmaCfg.size = glMscEpSize;
dmaCfg.count = 0;
dmaCfg.prodSckId = (CyU3PDmaSocketId_t)(CY_U3P_UIB_SOCKET_PROD_0 + (0x0F & glMscInEp));
dmaCfg.consSckId = CY_U3P_CPU_SOCKET_CONS;
dmaCfg.dmaMode = CY_U3P_DMA_MODE_BYTE;
dmaCfg.notification = 0;
dmaCfg.cb = NULL;
dmaCfg.prodHeader = 0;
dmaCfg.prodFooter = 0;
dmaCfg.consHeader = 0;
dmaCfg.prodAvailCount = 0;
status = CyU3PDmaChannelCreate (&glMscInCh, CY_U3P_DMA_TYPE_MANUAL_IN, &dmaCfg);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
/* Create a DMA channel for OUT EP. */
dmaCfg.prodSckId = CY_U3P_CPU_SOCKET_PROD;
dmaCfg.consSckId = (CyU3PDmaSocketId_t)(CY_U3P_UIB_SOCKET_CONS_0 + (0x0F & glMscOutEp));
status = CyU3PDmaChannelCreate (&glMscOutCh, CY_U3P_DMA_TYPE_MANUAL_OUT, &dmaCfg);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
for (retry = 0; retry < CY_FX_MSC_MAX_RETRY; retry++)
{
/* Give some time for the device to initialize. */
CyU3PThreadSleep (1000);
for (i = 0; i <= maxLun; i++)
{
/* Check if the unit is ready. */
status = CyFxMscTestUnitReady (maxLun);
if (status == CY_U3P_SUCCESS)
{
glMscTestLun = i;
break;
}
}
if (status == CY_U3P_SUCCESS)
{
break;
}
}
if (status != CY_U3P_SUCCESS)
{
glMscTestLun = 0;
goto app_error;
}
/* Read the device capacity. */
status = CyFxMscReadCapacity (glMscTestLun);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
glMscIsActive = CyTrue;
return status;
app_error:
CyU3PDmaChannelDestroy (&glMscInCh);
if (glMscInEp != 0)
{
CyU3PUsbHostEpRemove (glMscInEp);
glMscInEp = 0;
}
CyU3PDmaChannelDestroy (&glMscOutCh);
if (glMscOutEp != 0)
{
CyU3PUsbHostEpRemove (glMscOutEp);
glMscOutEp = 0;
}
glMscEpSize = 0;
glMscSectorSize = 0;
glMscCapacity = 0;
glMscTestLun = 0;
glMscTestSector = 0;
glTimerCount = 0;
enum_error:
return CY_U3P_ERROR_FAILURE;
}
void AR0330_Power_Up(void) {
CyU3PDebugPrint(4, "AR0330_Power_Up\r\n");
// set test mode
#if defined(TEST_MODE)
sensor_write(0x301E, 0x00a8); // data_pedestal
sensor_write(0x3070, 0x0001); // set test mode
#define pedestal 0x80
#define full (0x0fff - pedestal)
#define low (0x001f + pedestal)
#if TEST_MODE == TEST_MODE_IDENTIFY
sensor_write(0x3072, 0x01aa + pedestal); // red
sensor_write(0x3074, 0x02bb + pedestal); // green (in red row)
sensor_write(0x3076, 0x03cc + pedestal); // blue
sensor_write(0x3078, 0x04dd + pedestal); // green (in blue row)
#elif TEST_MODE == TEST_MODE_RED
sensor_write(0x3072, full); // red
sensor_write(0x3074, low); // green (in red row)
sensor_write(0x3076, low); // blue
sensor_write(0x3078, low); // green (in blue row)
#elif TEST_MODE == TEST_MODE_GREEN_RED
sensor_write(0x3072, low); // red
sensor_write(0x3074, full); // green (in red row)
sensor_write(0x3076, low); // blue
sensor_write(0x3078, low); // green (in blue row)
#elif TEST_MODE == TEST_MODE_BLUE
sensor_write(0x3072, low); // red
sensor_write(0x3074, low); // green (in red row)
sensor_write(0x3076, full); // blue
sensor_write(0x3078, low); // green (in blue row)
#elif TEST_MODE == TEST_MODE_GREEN_BLUE
sensor_write(0x3072, low); // red
sensor_write(0x3074, low); // green (in red row)
sensor_write(0x3076, low); // blue
sensor_write(0x3078, full); // green (in blue row)
#elif TEST_MODE == TEST_MODE_GREEN_ALL
sensor_write(0x3072, low); // red
sensor_write(0x3074, full); // green (in red row)
sensor_write(0x3076, low); // blue
sensor_write(0x3078, full); // green (in blue row)
#elif TEST_MODE == TEST_MODE_COLOUR_BARS
sensor_write(0x3070, 0x0002); // set test mode
#else
#error "undefined test mode"
#endif
#else
// normal mode
sensor_write(0x3070, 0x0000); // disable test mode
#endif
// start streaming
//sensor_write(0x301a, 0x005c);
sensor_write(0x301a, 0x0054);
CyU3PThreadSleep(10);
AR0330_Debug();
}
/* This function initializes the mouse driver application. */
static void
CyFxApplnStart ()
{
uint16_t length, size, offset;
CyU3PDmaBuffer_t buf_p;
CyU3PReturnStatus_t status;
CyU3PUsbHostEpConfig_t epCfg;
CyU3PDmaChannelConfig_t dmaCfg;
CyU3PUsbHostEpStatus_t epStatus;
/* Add EP0 to the scheduler. */
CyU3PMemSet ((uint8_t *)&epCfg, 0, sizeof(epCfg));
epCfg.type = CY_U3P_USB_EP_CONTROL;
epCfg.mult = 1;
/* Start off with 8 byte EP0 packet size. */
epCfg.maxPktSize = 8;
epCfg.pollingRate = 0;
epCfg.fullPktSize = 8;
epCfg.isStreamMode = CyFalse;
status = CyU3PUsbHostEpAdd (0, &epCfg);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
CyU3PThreadSleep (100);
/* Get the device descriptor. */
CyFxFormatSetupRqt (glSetupPkt, 0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_DEVICE_DESCR << 8), 0, 8);
status = CyU3PUsbHostSendSetupRqt (glSetupPkt, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostEpWaitForCompletion (0, &epStatus,
CY_FX_HOST_EP0_WAIT_TIMEOUT);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Identify the EP0 packet size and update the scheduler. */
if (glEp0Buffer[7] != 8)
{
status = CyU3PUsbHostEpRemove (0);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Update the correct size. */
epCfg.maxPktSize = glEp0Buffer[7];
epCfg.fullPktSize = glEp0Buffer[7];
status = CyU3PUsbHostEpAdd (0, &epCfg);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
}
/* Read the full device descriptor. */
CyFxFormatSetupRqt (glSetupPkt, 0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_DEVICE_DESCR << 8), 0, 18);
status = CyU3PUsbHostSendSetupRqt (glSetupPkt, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostEpWaitForCompletion (0, &epStatus,
CY_FX_HOST_EP0_WAIT_TIMEOUT);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Check for the VID and PID of the attached peripheral. */
if ((CY_U3P_MAKEWORD(glEp0Buffer[9], glEp0Buffer[8]) != CY_FX_HOST_PERIPHERAL_VID) ||
(CY_U3P_MAKEWORD(glEp0Buffer[11], glEp0Buffer[10]) != CY_FX_HOST_PERIPHERAL_PID))
{
status = CY_U3P_ERROR_NOT_SUPPORTED;
goto enum_error;
}
/* Check for device class, sub-class and protocol all of which has to be zero. */
if ((glEp0Buffer[4] != 0) || (glEp0Buffer[5] != 0) || (glEp0Buffer[6] != 0))
{
status = CY_U3P_ERROR_NOT_SUPPORTED;
goto enum_error;
}
/* Set the peripheral device address. */
CyFxFormatSetupRqt (glSetupPkt, 0x00, CY_U3P_USB_SC_SET_ADDRESS,
CY_FX_HOST_PERIPHERAL_ADDRESS, 0, 0);
status = CyU3PUsbHostSendSetupRqt (glSetupPkt, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostEpWaitForCompletion (0, &epStatus,
CY_FX_HOST_EP0_WAIT_TIMEOUT);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostSetDeviceAddress (CY_FX_HOST_PERIPHERAL_ADDRESS);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Read the OTG descriptor to identify its characteristics.
* Do this only if we are not already in role change. */
glIsHnpSupported = CyFalse;
if (!CyU3POtgIsHnpEnabled ())
{
CyFxFormatSetupRqt (glSetupPkt, 0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_OTG_DESCR << 8), 0, 5);
status = CyU3PUsbHostSendSetupRqt (glSetupPkt, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostEpWaitForCompletion (0, &epStatus,
CY_FX_HOST_EP0_WAIT_TIMEOUT);
/* If the device does not support OTG, the request will be stalled. */
if ((status == CY_U3P_SUCCESS) && (glEp0Buffer[2] & 0x02))
{
/* Let the device know that the host is HNP capable. */
CyFxFormatSetupRqt (glSetupPkt, 0x00, CY_U3P_USB_SC_SET_FEATURE,
CY_U3P_USB2_OTG_A_HNP_SUPPORT, 0, 0);
status = CyU3PUsbHostSendSetupRqt (glSetupPkt, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostEpWaitForCompletion (0, &epStatus,
CY_FX_HOST_EP0_WAIT_TIMEOUT);
}
if (status == CY_U3P_SUCCESS)
{
glIsHnpSupported = CyTrue;
}
}
/* Read first four bytes of configuration descriptor to determine
* the total length. */
CyFxFormatSetupRqt (glSetupPkt, 0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_CONFIG_DESCR << 8), 0, 4);
status = CyU3PUsbHostSendSetupRqt (glSetupPkt, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostEpWaitForCompletion (0, &epStatus,
CY_FX_HOST_EP0_WAIT_TIMEOUT);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Identify the length of the data received. */
length = CY_U3P_MAKEWORD(glEp0Buffer[3], glEp0Buffer[2]);
if (length > CY_FX_HOST_EP0_BUFFER_SIZE)
{
goto enum_error;
}
/* Read the full configuration descriptor. */
CyFxFormatSetupRqt (glSetupPkt, 0x80, CY_U3P_USB_SC_GET_DESCRIPTOR,
(CY_U3P_USB_CONFIG_DESCR << 8), 0, length);
status = CyU3PUsbHostSendSetupRqt (glSetupPkt, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostEpWaitForCompletion (0, &epStatus,
CY_FX_HOST_EP0_WAIT_TIMEOUT);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Check if the device can be supported. Number of interfaces should be 1,
* the intreface class must be vendor (0xFF) and the subclass and protocol
* must be zero. The number of endpoints must be two. Also the endpoints
* should be bulk. */
if ((glEp0Buffer[5] != 1) || (glEp0Buffer[14] != 0xFF) ||
(glEp0Buffer[15] != 0x00) || (glEp0Buffer[16] != 0x00) ||
(glEp0Buffer[13] != 2))
{
status = CY_U3P_ERROR_NOT_SUPPORTED;
goto enum_error;
}
/* Identify the EP characteristics. */
offset = 0;
while (offset < length)
{
if (glEp0Buffer[offset + 1] == CY_U3P_USB_ENDPNT_DESCR)
{
if (glEp0Buffer[offset + 3] != CY_U3P_USB_EP_BULK)
{
status = CY_U3P_ERROR_NOT_SUPPORTED;
goto enum_error;
}
/* Retreive the information. */
glHostEpSize = CY_U3P_MAKEWORD(glEp0Buffer[offset + 5],
glEp0Buffer[offset + 4]);
if (glEp0Buffer[offset + 2] & 0x80)
{
glHostInEp = glEp0Buffer[offset + 2];
}
else
{
glHostOutEp = glEp0Buffer[offset + 2];
}
}
/* Advance to next descriptor. */
offset += glEp0Buffer[offset];
}
/* If there is any error in the configuration abort. */
if ((glHostOutEp == 0) || (glHostInEp == 0))
{
status = CY_U3P_ERROR_NOT_SUPPORTED;
goto enum_error;
}
/* Set the new configuration. */
CyFxFormatSetupRqt (glSetupPkt, 0x00, CY_U3P_USB_SC_SET_CONFIGURATION, 1, 0, 0);
status = CyU3PUsbHostSendSetupRqt (glSetupPkt, glEp0Buffer);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostEpWaitForCompletion (0, &epStatus,
CY_FX_HOST_EP0_WAIT_TIMEOUT);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
/* Initialize the loopback application. */
CyU3PMemSet ((uint8_t *)&epCfg, 0, sizeof(epCfg));
epCfg.type = CY_U3P_USB_EP_BULK;
epCfg.mult = 1;
epCfg.maxPktSize = glHostEpSize;
epCfg.pollingRate = 0;
size = ((glHostEpSize + 0x0F) & ~0x0F);
epCfg.fullPktSize = glHostEpSize;
epCfg.isStreamMode = CyFalse;
status = CyU3PUsbHostEpAdd (glHostOutEp, &epCfg);
if (status != CY_U3P_SUCCESS)
{
goto enum_error;
}
status = CyU3PUsbHostEpAdd (glHostInEp, &epCfg);
if (status != CY_U3P_SUCCESS)
{
glHostInEp = 0;
goto app_error;
}
/* Reset counter to zero. */
glDMARxCount = 0;
glDMATxCount = 0;
/* Create a DMA channels for IN and OUT directions. */
CyU3PMemSet ((uint8_t *)&dmaCfg, 0, sizeof(dmaCfg));
dmaCfg.size = size;
dmaCfg.count = CY_FX_HOST_DMA_BUF_COUNT;
dmaCfg.prodHeader = 0;
dmaCfg.prodFooter = 0;
dmaCfg.consHeader = 0;
dmaCfg.prodAvailCount = 0;
dmaCfg.prodSckId = (CyU3PDmaSocketId_t)(CY_U3P_UIB_SOCKET_PROD_0 + (0x0F & glHostInEp));
dmaCfg.consSckId = CY_U3P_CPU_SOCKET_CONS;
dmaCfg.dmaMode = CY_U3P_DMA_MODE_BYTE;
dmaCfg.notification = CY_U3P_DMA_CB_PROD_EVENT;
dmaCfg.cb = CyFxHostDmaCb;
status = CyU3PDmaChannelCreate (&glHostInCh, CY_U3P_DMA_TYPE_MANUAL_IN, &dmaCfg);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
dmaCfg.prodSckId = CY_U3P_CPU_SOCKET_PROD;
dmaCfg.consSckId = (CyU3PDmaSocketId_t)(CY_U3P_UIB_SOCKET_CONS_0 + (0x0F & glHostOutEp));
dmaCfg.dmaMode = CY_U3P_DMA_MODE_BYTE;
dmaCfg.notification = CY_U3P_DMA_CB_CONS_EVENT;
dmaCfg.cb = CyFxHostDmaCb;
status = CyU3PDmaChannelCreate (&glHostOutCh, CY_U3P_DMA_TYPE_MANUAL_OUT, &dmaCfg);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
/* Set infinite transfer on both the channels. */
status = CyU3PDmaChannelSetXfer (&glHostInCh, 0);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
status = CyU3PDmaChannelSetXfer (&glHostOutCh, 0);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
/* Pre-load all OUT buffers with fixed data. */
for (offset = 0; offset < CY_FX_HOST_DMA_BUF_COUNT; offset++)
{
status = CyU3PDmaChannelGetBuffer (&glHostOutCh, &buf_p, CYU3P_NO_WAIT);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
CyU3PMemSet (buf_p.buffer, (uint8_t)CY_FX_HOST_DATA_BYTE, glHostEpSize);
status = CyU3PDmaChannelCommitBuffer (&glHostOutCh, glHostEpSize, 0);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
}
/* Queue a single read and single write request. */
status = CyU3PUsbHostEpSetXfer (glHostInEp, CY_U3P_USB_HOST_EPXFER_NORMAL, glHostEpSize);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
status = CyU3PUsbHostEpSetXfer (glHostOutEp, CY_U3P_USB_HOST_EPXFER_NORMAL, glHostEpSize);
if (status != CY_U3P_SUCCESS)
{
goto app_error;
}
glTimerCount = 0;
glIsApplnActive = CyTrue;
glIsHnp = CyFalse;
glDoHnp = CyFalse;
if (glIsHnpSupported)
{
CyU3PDebugPrint (4, "USB bulk loopback host mode operation started with HNP enabled.\r\n");
}
else
{
CyU3PDebugPrint (4, "USB bulk loopback host mode operation started with HNP disabled.\r\n");
}
return;
app_error:
CyU3PDmaChannelDestroy (&glHostInCh);
if (glHostInEp != 0)
{
CyU3PUsbHostEpRemove (glHostInEp);
glHostInEp = 0;
}
CyU3PDmaChannelDestroy (&glHostOutCh);
if (glHostOutEp != 0)
{
CyU3PUsbHostEpRemove (glHostOutEp);
glHostOutEp = 0;
}
enum_error:
/* Remove EP0. and disable the port. */
CyU3PUsbHostEpRemove (0);
glHostEpSize = 0;
CyU3PUsbHostPortDisable ();
CyU3PDebugPrint (4, "Host mode application start failed with error: %d.\r\n", status);
}