void open_drivers(void)
{
/* Code for opening and closing drivers - move to required places in Application Threads */
/* FTDI:SDA Driver Open */
hUSBSLAVE_1 = vos_dev_open(VOS_DEV_USBSLAVE_1);
hUSBSLAVE_2 = vos_dev_open(VOS_DEV_USBSLAVE_2);
hUART = vos_dev_open(VOS_DEV_UART);
/* FTDI:EDA */
}
void StartupDevices(void) {
gpio_ioctl_cb_t gpio_iocb;
common_ioctl_cb_t uart_iocb;
BYTE Status = 0;
// Open GPIO driver and configure it
hDevice[LEDs] = vos_dev_open(LEDs);
// Set LED3 pin to output
gpio_iocb.ioctl_code = VOS_IOCTL_GPIO_SET_MASK;
gpio_iocb.value = LED3;
Status |= vos_dev_ioctl(hDevice[LEDs], &gpio_iocb);
// Open UART driver and configure it
hDevice[UART] = vos_dev_open(UART);
uart_iocb.ioctl_code = VOS_IOCTL_UART_SET_BAUD_RATE;
uart_iocb.set.uart_baud_rate = UART_BAUD_3000000;
Status = vos_dev_ioctl(hDevice[UART], &uart_iocb);
uart_iocb.ioctl_code = VOS_IOCTL_UART_SET_FLOW_CONTROL;
uart_iocb.set.param = UART_FLOW_NONE;
// Status |= vos_dev_ioctl(hDevice[UART], &uart_iocb);
uart_iocb.ioctl_code = VOS_IOCTL_UART_SET_DATA_BITS;
uart_iocb.set.param = UART_DATA_BITS_8;
Status |= vos_dev_ioctl(hDevice[UART], &uart_iocb);
uart_iocb.ioctl_code = VOS_IOCTL_UART_SET_STOP_BITS;
uart_iocb.set.param = UART_STOP_BITS_1;
Status |= vos_dev_ioctl(hDevice[UART], &uart_iocb);
uart_iocb.ioctl_code = VOS_IOCTL_UART_SET_PARITY;
uart_iocb.set.param = UART_PARITY_NONE;
// Status |= vos_dev_ioctl(hDevice[UART], &uart_iocb);
// Since baud rate >= 115200 enable DMA for this channel
uart_iocb.ioctl_code = VOS_IOCTL_COMMON_ENABLE_DMA;
Status |= vos_dev_ioctl(hDevice[UART], &uart_iocb);
// Finally enable UART interrupts are we're ready to go!
vos_enable_interrupts(VOS_UART_INT_IEN);
// Open two more GPIO drivers for the Logic Analyser and configure them
hDevice[LA_In] = vos_dev_open(LA_In);
// Set all port bits to input
gpio_iocb.ioctl_code = VOS_IOCTL_GPIO_SET_MASK;
gpio_iocb.value = 0;
Status |= vos_dev_ioctl(hDevice[LA_In], &gpio_iocb);
hDevice[LA_Out] = vos_dev_open(LA_Out);
// Set all port bits to output
gpio_iocb.ioctl_code = VOS_IOCTL_GPIO_SET_MASK;
gpio_iocb.value = 0xFF;
Status |= vos_dev_ioctl(hDevice[LA_Out], &gpio_iocb);
// Spin up USB Host
hDevice[Host] = vos_dev_open(Host);
// Let other tasks know that devices are initialized
vos_signal_semaphore(&DevicesStarted);
CheckStatus(Status, ErrorStartupDevices);
}
VOS_HANDLE fat_attach(VOS_HANDLE hMSI, unsigned char devFAT)
{
fat_ioctl_cb_t fat_ioctl;
fatdrv_ioctl_cb_attach_t fat_att;
VOS_HANDLE hFAT;
// currently the MSI (BOMS or other) must be open
// open the FAT driver
hFAT = vos_dev_open(devFAT);
// attach the FAT driver to the MSI driver
fat_ioctl.ioctl_code = FAT_IOCTL_FS_ATTACH;
fat_ioctl.set = &fat_att;
fat_att.msi_handle = hMSI;
fat_att.partition = 0;
if (vos_dev_ioctl(hFAT, &fat_ioctl) != FAT_OK)
{
// unable to open the FAT driver
vos_dev_close(hFAT);
hFAT = NULL;
}
return hFAT;
}
//////////////////////////////////////////////////////////////////////
//
// APPLICATION SETUP THREAD FUNCTION
//
//////////////////////////////////////////////////////////////////////
void Setup()
{
common_ioctl_cb_t spis_iocb;
usbhostGeneric_ioctl_t generic_iocb;
gpio_ioctl_cb_t gpio_iocb;
common_ioctl_cb_t uart_iocb;
unsigned char uchLeds;
common_ioctl_cb_t ss_iocb;
hSPISlave = vos_dev_open(VOS_DEV_SPISLAVE);
// Open up the base level drivers
hGpioA = vos_dev_open(VOS_DEV_GPIO_A);
gpio_iocb.ioctl_code = VOS_IOCTL_GPIO_SET_MASK;
gpio_iocb.value = 0b11000110;
vos_dev_ioctl(hGpioA, &gpio_iocb);
setGpioA(0b11000110,0);
ss_iocb.ioctl_code = VOS_IOCTL_SPI_SLAVE_SCK_CPHA;
ss_iocb.set.param = SPI_SLAVE_SCK_CPHA_0;
vos_dev_ioctl(hSPISlave, &ss_iocb);
ss_iocb.ioctl_code = VOS_IOCTL_SPI_SLAVE_SCK_CPOL;
ss_iocb.set.param = SPI_SLAVE_SCK_CPOL_0;
vos_dev_ioctl(hSPISlave, &ss_iocb);
ss_iocb.ioctl_code = VOS_IOCTL_SPI_SLAVE_DATA_ORDER;
ss_iocb.set.param = SPI_SLAVE_DATA_ORDER_MSB;
vos_dev_ioctl(hSPISlave, &ss_iocb);
ss_iocb.ioctl_code = VOS_IOCTL_SPI_SLAVE_SET_MODE;
ss_iocb.set.param = SPI_SLAVE_MODE_FULL_DUPLEX;
vos_dev_ioctl(hSPISlave, &ss_iocb);
ss_iocb.ioctl_code = VOS_IOCTL_SPI_SLAVE_SET_ADDRESS;
ss_iocb.set.param = 0;
vos_dev_ioctl(hSPISlave, &ss_iocb);
ss_iocb.ioctl_code = VOS_IOCTL_COMMON_ENABLE_DMA;
ss_iocb.set.param = DMA_ACQUIRE_AND_RETAIN;
vos_dev_ioctl(hSPISlave, &ss_iocb);
// Release other application threads
vos_signal_semaphore(&setupSem);
}
//////////////////////////////////////////////////////////////////////
//
// APPLICATION SETUP THREAD FUNCTION
//
//////////////////////////////////////////////////////////////////////
void Setup()
{
common_ioctl_cb_t spis_iocb;
usbhostGeneric_ioctl_t generic_iocb;
gpio_ioctl_cb_t gpio_iocb;
common_ioctl_cb_t uart_iocb;
unsigned char uchLeds;
// Open up the base level drivers
hGpioA = vos_dev_open(VOS_DEV_GPIO_A);
PortA.hUSBHOST = vos_dev_open(VOS_DEV_USBHOST_1);
//PortB.hUSBHOST = vos_dev_open(VOS_DEV_USBHOST_2);
gpio_iocb.ioctl_code = VOS_IOCTL_GPIO_SET_MASK;
gpio_iocb.value = 0b00001110;
vos_dev_ioctl(hGpioA, &gpio_iocb);
uchLeds = 0b00001000;
vos_dev_write(hGpioA,&uchLeds,1,NULL);
hUART = vos_dev_open(VOS_DEV_UART);
/* UART ioctl call to enable DMA and link to DMA driver */
uart_iocb.ioctl_code = VOS_IOCTL_COMMON_ENABLE_DMA;
vos_dev_ioctl(hUART, &uart_iocb);
// Set up for MIDI
uart_iocb.ioctl_code = VOS_IOCTL_UART_SET_BAUD_RATE;
uart_iocb.set.uart_baud_rate = 31250;
vos_dev_ioctl(hUART, &uart_iocb);
uart_iocb.ioctl_code = VOS_IOCTL_UART_SET_FLOW_CONTROL;
uart_iocb.set.param = UART_FLOW_NONE;
vos_dev_ioctl(hUART, &uart_iocb);
// Set up the metronome
MetroInit(&metro, VOS_DEV_TIMER0, TIMER_0);
// Release other application threads
vos_signal_semaphore(&setupSem);
}
VOS_HANDLE boms_attach(VOS_HANDLE hUSB, unsigned char devBOMS)
{
usbhost_device_handle_ex ifDisk = 0;
usbhost_ioctl_cb_t hc_iocb;
usbhost_ioctl_cb_class_t hc_iocb_class;
msi_ioctl_cb_t boms_iocb;
boms_ioctl_cb_attach_t boms_att;
int error;
VOS_HANDLE hBOMS;
// find BOMS class device
hc_iocb_class.dev_class = USB_CLASS_MASS_STORAGE;
hc_iocb_class.dev_subclass = USB_SUBCLASS_MASS_STORAGE_SCSI;
hc_iocb_class.dev_protocol = USB_PROTOCOL_MASS_STORAGE_BOMS;
// user ioctl to find first hub device
hc_iocb.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_FIND_HANDLE_BY_CLASS;
hc_iocb.handle.dif = NULL;
hc_iocb.set = &hc_iocb_class;
hc_iocb.get = &ifDisk;
error = vos_dev_ioctl(hUSB, &hc_iocb);
if (error != USBHOST_OK)
{
printf("ERROR: %d\n", error);
printf("USB Bus 1 State: %d\n", getBusState(hUSBHOST_1));
printf("USB Bus 2 State: %d\n", getBusState(hUSBHOST_2));
return NULL;
}
// now we have a device, intialise a BOMS driver with it
hBOMS = vos_dev_open(devBOMS);
// perform attach
boms_att.hc_handle = hUSB;
boms_att.ifDev = ifDisk;
boms_iocb.ioctl_code = MSI_IOCTL_BOMS_ATTACH;
boms_iocb.set = &boms_att;
boms_iocb.get = NULL;
if (vos_dev_ioctl(hBOMS, &boms_iocb) != MSI_OK)
{
vos_dev_close(hBOMS);
hBOMS = NULL;
}
return hBOMS;
}
void open_drivers(void)
{
/* Code for opening and closing drivers - move to required places in Application Threads */
/* FTDI:SDA Driver Open */
hUSBHOST_1 = vos_dev_open(VOS_DEV_USBHOST_1);
hUSBHOST_2 = vos_dev_open(VOS_DEV_USBHOST_2);
hUART = vos_dev_open(VOS_DEV_UART);
hSPI_MASTER = vos_dev_open(VOS_DEV_SPI_MASTER);
hGPIO_PORT_A = vos_dev_open(VOS_DEV_GPIO_PORT_A);
hGPIO_PORT_B = vos_dev_open(VOS_DEV_GPIO_PORT_B);
/* FTDI:EDA */
}
VOS_HANDLE hid_attach(VOS_HANDLE hUSB, unsigned char devHID)
{
usbhost_device_handle_ex ifHID = 0;
usbhost_ioctl_cb_t hc_iocb;
usbhost_ioctl_cb_class_t hc_iocb_class;
usbHostHID_ioctl_t hid_iocb;
usbHostHID_ioctl_cb_attach_t hid_att;
VOS_HANDLE hHID;
// find HID class device
hc_iocb_class.dev_class = USB_CLASS_HID;
hc_iocb_class.dev_subclass = USB_SUBCLASS_ANY;
hc_iocb_class.dev_protocol = USB_PROTOCOL_ANY;
// user ioctl to find first hub device
hc_iocb.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_FIND_HANDLE_BY_CLASS;
hc_iocb.handle.dif = NULL;
hc_iocb.set = &hc_iocb_class;
hc_iocb.get = &ifHID;
if (vos_dev_ioctl(hUSB, &hc_iocb) != USBHOST_OK)
{
return NULL;
}
// now we have a device, intialise a HID driver with it
hHID = vos_dev_open(devHID);
// perform attach
hid_att.hc_handle = hUSB;
hid_att.ifDev = ifHID;
hid_iocb.ioctl_code = VOS_IOCTL_USBHOSTHID_ATTACH;
hid_iocb.set = &hid_att;
hid_iocb.get = NULL;
if (vos_dev_ioctl(hHID, &hid_iocb) != USBHOSTHID_OK)
{
vos_dev_close(hHID);
hHID = NULL;
}
return hHID;
}
//////////////////////////////////////////////////////////////////////
//
// RUN USB HOST PORT
//
//////////////////////////////////////////////////////////////////////
void RunHostPort(HOST_PORT_DATA *pHostData)
{
int i;
int midiParam;
unsigned char status;
unsigned char buf[64];
unsigned short num_bytes;
unsigned int handle;
usbhostGeneric_ioctl_t generic_iocb;
usbhostGeneric_ioctl_cb_attach_t genericAtt;
usbhost_device_handle_ex ifDev;
usbhost_ioctl_cb_t hc_iocb;
usbhost_ioctl_cb_vid_pid_t hc_iocb_vid_pid;
gpio_ioctl_cb_t gpio_iocb;
VOS_HANDLE hUSB;
// wait for setup to complete
vos_wait_semaphore(&setupSem);
vos_signal_semaphore(&setupSem);
// Open the base USB Host driver
pHostData->hUSBHOST = vos_dev_open(pHostData->uchDeviceNumberBase);
// loop forever
while(1)
{
vos_delay_msecs(10);
// is the device enumerated on this port?
if (usbhost_connect_state(pHostData->hUSBHOST) == PORT_STATE_ENUMERATED)
{
// user ioctl to find first hub device
hc_iocb.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_GET_NEXT_HANDLE;
hc_iocb.handle.dif = NULL;
hc_iocb.set = NULL;
hc_iocb.get = &ifDev;
if (vos_dev_ioctl(pHostData->hUSBHOST, &hc_iocb) == USBHOST_OK)
{
// query the device VID/PID
hc_iocb.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_GET_VID_PID;
hc_iocb.handle.dif = ifDev;
hc_iocb.get = &hc_iocb_vid_pid;
// Load the function driver
hUSB = vos_dev_open(pHostData->uchDeviceNumber);
// Attach the function driver to the base driver
genericAtt.hc_handle = pHostData->hUSBHOST;
genericAtt.ifDev = ifDev;
generic_iocb.ioctl_code = VOS_IOCTL_USBHOSTGENERIC_ATTACH;
generic_iocb.set.att = &genericAtt;
if (vos_dev_ioctl(hUSB, &generic_iocb) == USBHOSTGENERIC_OK)
{
// Turn on the LED for this port
setGpioA(pHostData->uchActivityLed, pHostData->uchActivityLed);
// flag that the port is attached
VOS_ENTER_CRITICAL_SECTION;
pHostData->hUSBHOSTGENERIC = hUSB;
VOS_EXIT_CRITICAL_SECTION;
// now we loop until the launchpad is detached
while(1)
{
// listen for data from launchpad
uint16 result = vos_dev_read(hUSB, buf, 64, &num_bytes);
if(0 != result)
break; // break when the launchpad is detached
fifo_write(&stSPIWriteFIFO, buf, (int)num_bytes);
}
// flag that the port is no longer attached
VOS_ENTER_CRITICAL_SECTION;
pHostData->hUSBHOSTGENERIC = NULL;
VOS_EXIT_CRITICAL_SECTION;
// turn off the activity LED
setGpioA(pHostData->uchActivityLed, 0);
}
// close the function driver
vos_dev_close(hUSB);
}
}
}
}
//////////////////////////////////////////////////////////////////////
//
// THREAD FUNCTION TO RUN USB HOST PORT
//
//////////////////////////////////////////////////////////////////////
void RunHostPort(HOST_PORT_DATA *pHostData)
{
unsigned char status;
unsigned char buf[64];
unsigned short num_read;
unsigned int handle;
usbhostGeneric_ioctl_t generic_iocb;
usbhostGeneric_ioctl_cb_attach_t genericAtt;
usbhost_device_handle_ex ifDev;
usbhost_ioctl_cb_t hc_iocb;
usbhost_ioctl_cb_vid_pid_t hc_iocb_vid_pid;
gpio_ioctl_cb_t gpio_iocb;
SMQ_MSG msg;
msg.status = 0x90;
// wait for setup to complete
vos_wait_semaphore(&setupSem);
vos_signal_semaphore(&setupSem);
// loop forever
while(1)
{
// is the device enumerated on this port?
if (usbhost_connect_state(pHostData->hUSBHOST) == PORT_STATE_ENUMERATED)
{
// user ioctl to find first hub device
hc_iocb.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_GET_NEXT_HANDLE;
hc_iocb.handle.dif = NULL;
hc_iocb.set = NULL;
hc_iocb.get = &ifDev;
if (vos_dev_ioctl(pHostData->hUSBHOST, &hc_iocb) == USBHOST_OK)
{
hc_iocb.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_GET_VID_PID;
hc_iocb.handle.dif = ifDev;
hc_iocb.get = &hc_iocb_vid_pid;
// attach the Launchpad device to the USB host device
pHostData->hUSBHOSTGENERIC = vos_dev_open(pHostData->uchDeviceNumber);
genericAtt.hc_handle = pHostData->hUSBHOST;
genericAtt.ifDev = ifDev;
generic_iocb.ioctl_code = VOS_IOCTL_USBHOSTGENERIC_ATTACH;
generic_iocb.set.att = &genericAtt;
if (vos_dev_ioctl(pHostData->hUSBHOSTGENERIC, &generic_iocb) == USBHOSTGENERIC_OK)
{
setLed(pHostData->uchActivityLed, 1);
// now we loop until the launchpad is detached
while(1)
{
int pos = 0;
byte param = 1;
// read data
status = vos_dev_read(pHostData->hUSBHOSTGENERIC, buf, 64, &num_read);
if(status != USBHOSTGENERIC_OK)
break;
setLed(pHostData->uchActivityLed, 0);
// interpret MIDI data and pass to application thread
while(pos < num_read)
{
if(buf[pos] & 0x80)
{
msg.status = buf[pos];
param = 1;
}
else if(param == 1)
{
msg.param1 = buf[pos];
param = 2;
}
else if(param == 2)
{
msg.param2 = buf[pos];
SMQWrite(&msg);
param = 1;
}
++pos;
}
setLed(pHostData->uchActivityLed, 1);
}
}
vos_dev_close(pHostData->hUSBHOSTGENERIC);
}
}
setLed(pHostData->uchActivityLed, 0);
}
}
