//***************************************************************************** // // Set up for operation as a USB host allowing access to Mass Storage Class // devices. // //***************************************************************************** tBoolean ScopeUSBHostInit(void) { // // Set the USB power control pins to be controlled by the USB controller. // SysCtlPeripheralEnable(USB_HOST_GPIO_PERIPH); SysCtlPeripheralEnable(USB_PWR_GPIO_PERIPH); GPIOPinTypeUSBDigital(USB_HOST_GPIO_BASE, USB_HOST_GPIO_PINS); GPIOPinTypeUSBDigital(USB_PWR_GPIO_BASE, USB_PWR_GPIO_PINS); // // Configure the USB mux on the board to put us in host mode. We pull // the relevant pin low to do this. // SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH); GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN); GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_HOST); // // Tell the stack that we will be operating as a host rather than a // device. Note that we expect a callback to ScopeUSBModeCallback // before this function call returns. This will perform additional host // initialization. // USBStackModeSet(0, USB_MODE_HOST, ScopeUSBModeCallback); // // Register the host class drivers. // USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers); // // Set our Mass Storage Class driver callback. // g_ulMSCInstance = USBHMSCDriveOpen(0, MSCCallback); // // Initialize the host controller and give it the memory we have // set aside for it to use for descriptor storage. // USBHCDInit(0, g_pcUSBHostHeap, USB_HOST_HEAP_SIZE); // // All appears well. // return(true); }
//***************************************************************************** // // Set up for operation as a USB host allowing access to Mass Storage Class // devices. // //***************************************************************************** tBoolean ScopeUSBHostInit(void) { // // Enable Clocking to the USB controller and ensure it is reset. // SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); SysCtlPeripheralReset(SYSCTL_PERIPH_USB0); // // Set the USB power control pins to be controlled by the USB controller. // SysCtlPeripheralEnable(USB_HOST_GPIO_PERIPH); SysCtlPeripheralEnable(USB_PWR_GPIO_PERIPH); GPIOPinTypeUSBDigital(USB_HOST_GPIO_BASE, USB_HOST_GPIO_PINS); GPIOPinTypeUSBDigital(USB_PWR_GPIO_BASE, USB_PWR_GPIO_PINS); // // Configure the USB mux on the board to put us in host mode. We pull // the relevant pin low to do this. // SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH); GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN); GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_HOST); // // Turn on USB Phy clock. // SysCtlUSBPLLEnable(); // // Tell the stack that we will be operating as a host rather than a // device. Note that we expect a callback to ScopeUSBModeCallback // before this function call returns. This will perform additional host // initialization. // USBStackModeSet(0, USB_MODE_HOST, ScopeUSBModeCallback); // // All appears well. // return(true); }
//***************************************************************************** // // Initializes the sound output. // // \param ui32Flags is unused as this point but is included for future // functionality. // \param pfnCallback is the event callback function for audio devices. // // This function prepares the sound driver to enumerate an audio device and // prepares to play audio once a valid audio device is detected. The // \e pfnCallback function can be used to receive callbacks when there are // changes related to the audio device. The ui32Event parameter to the callback // will be one of the SOUND_EVENT_* values. // // \return None // //***************************************************************************** void USBSoundInit(uint32_t ui32Flags, tEventCallback pfnCallback) { // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Set the USB power pins to be controlled by the USB controller. // GPIOPinTypeUSBDigital(GPIO_PORTA_BASE, GPIO_PIN_6 | GPIO_PIN_7); // // Enable the uDMA controller and set up the control table base. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA); uDMAEnable(); uDMAControlBaseSet(g_sDMAControlTable); // // Initialize the USB stack mode to OTG. // USBStackModeSet(0, eUSBModeOTG, 0); // // Register the host class drivers. // USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ui32NumHostClassDrivers); // // Open an instance of the audio class driver. // g_psAudioInstance = USBHostAudioOpen(0, AudioCallback); // // Initialize the power configuration. This sets the power enable signal // to be active high and does not enable the power fault. // USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER); // // Initialize the USB controller for OTG operation with a 2ms polling // rate. // USBOTGModeInit(0, 2000, g_pHCDPool, HCD_MEMORY_SIZE); // // Save the event callback function. // g_sAudioState.pfnCallbackEvent = pfnCallback; }
/* * ======== EKS_LM4F232_initUSB ======== * This function just turns on the USB */ Void EKS_LM4F232_initUSB(EKS_LM4F232_USBMode usbMode) { /* Enable the USB peripheral and PLL */ SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); SysCtlUSBPLLEnable(); /* Setup pins for USB operation */ GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7); /* Additional configurations for Host mode */ if (usbMode == EKS_LM4F232_USBHOST) { /* Configure the pins needed */ GPIOPinConfigure(GPIO_PG4_USB0EPEN); GPIOPinConfigure(GPIO_PG5_USB0PFLT); GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4 | GPIO_PIN_5); } }
//***************************************************************************** // // Initialize the host mode stack. // //***************************************************************************** void HostInit(void) { // // Register the host class drivers. // USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers); // // Initialize the button states. // g_ulButtons = 0; // // Update the status on the screen. // UpdateStatus(0, 0, true); // // Open an instance of the mouse driver. The mouse does not need // to be present at this time, this just saves a place for it and allows // the applications to be notified when a mouse is present. // g_ulMouseInstance = USBHMouseOpen(MouseCallback, g_pucBuffer, MOUSE_MEMORY_SIZE); // // Configure the power pins for host mode. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinTypeUSBDigital(GPIO_PORTA_BASE, GPIO_PIN_6 | GPIO_PIN_7); // // Initialize the power configuration. This sets the power enable signal // to be active high and does not enable the power fault. // USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER); // // Call the main loop for the Host controller driver. // eUSBState = STATE_NO_DEVICE; }
//***************************************************************************** // // Initialize the USB library and set things up so that we can handle USB HID // keyboard attachment. // //***************************************************************************** void USBKeyboardInit(void) { // // Initially wait for device connection. // g_eUSBState = STATE_NO_DEVICE; // // Configure the power pins for host controller. // GPIOPinTypeUSBDigital(GPIO_PORTA_BASE, GPIO_PIN_6 | GPIO_PIN_7); // // Register the host class drivers. // USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers); // // Open an instance of the keyboard driver. The keyboard does not need // to be present at this time, this just save a place for it and allows // the applications to be notified when a keyboard is present. // g_ulKeyboardInstance = USBHKeyboardOpen(KeyboardCallback, g_pucBuffer, KEYBOARD_MEMORY_SIZE); // // Initialize the power configuration. This sets the power enable signal // to be active high and does not enable the power fault. // USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER); // // Initialize the USB controller for host mode operation. // USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE); }
//***************************************************************************** // // This is the main loop that runs the application. // //***************************************************************************** int main(void) { tRectangle sRect; // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // // Configure the relevant pins such that UART0 owns them. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Open UART0 for debug output. // UARTStdioInit(0); // // Enable the USB mux GPIO. // SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH); // // The LM3S3748 board uses a USB mux that must be switched to use the // host connector and not the device connector. // GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN); GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_HOST); // // Configure the power pins for host controller. // GPIOPinTypeUSBDigital(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_4); // // Initialize the display driver. // Formike128x128x16Init(); // // Turn on the backlight. // Formike128x128x16BacklightOn(); // // Initialize the graphics context. // GrContextInit(&g_sContext, &g_sFormike128x128x16); // // Fill the top 15 rows of the screen with blue to create the banner. // sRect.sXMin = 0; sRect.sYMin = 0; sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1; sRect.sYMax = DISPLAY_BANNER_HEIGHT; GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG); GrRectFill(&g_sContext, &sRect); // // Put a white box around the banner. // GrContextForegroundSet(&g_sContext, ClrWhite); GrRectDraw(&g_sContext, &sRect); // // Put the application name in the middle of the banner. // GrContextFontSet(&g_sContext, g_pFontFixed6x8); GrStringDrawCentered(&g_sContext, "usb_host_keyboard", -1, GrContextDpyWidthGet(&g_sContext) / 2, 7, 0); // // Calculate the number of characters that will fit on a line. // Make sure to leave a small border for the text box. // g_ulCharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 4) / GrFontMaxWidthGet(g_pFontFixed6x8); // // Calculate the number of lines per usable text screen. This requires // taking off space for the top and bottom banners and adding a small bit // for a border. // g_ulLinesPerScreen = (GrContextDpyHeightGet(&g_sContext) - (2*(DISPLAY_BANNER_HEIGHT + 1)))/ GrFontHeightGet(g_pFontFixed6x8); // // Register the host class drivers. // USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers); // // Open and instance of the keyboard class driver. // UARTprintf("Host Keyboard Application\n"); // // Open an instance of the keyboard driver. The keyboard does not need // to be present at this time, this just save a place for it and allows // the applications to be notified when a keyboard is present. // g_ulKeyboardInstance = USBHKeyboardOpen(KeyboardCallback, g_pucBuffer, KEYBOARD_MEMORY_SIZE); // // Initialize the power configuration. This sets the power enable signal // to be active high and does not enable the power fault. // USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH); // // Initialize the host controller stack. // USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE); // // Call the main loop for the Host controller driver. // USBHCDMain(); // // Initial update of the screen. // UpdateStatus(); // // The main loop for the application. // while(1) { switch(g_eUSBState) { // // This state is entered when they keyboard is first detected. // case STATE_KEYBOARD_INIT: { // // Initialized the newly connected keyboard. // USBHKeyboardInit(g_ulKeyboardInstance); // // Proceed to the keyboard connected state. // g_eUSBState = STATE_KEYBOARD_CONNECTED; USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers); // // Update the screen now that the keyboard has been // initialized. // UpdateStatus(); break; } case STATE_KEYBOARD_UPDATE: { // // If the application detected a change that required an // update to be sent to the keyboard to change the modifier // state then call it and return to the connected state. // g_eUSBState = STATE_KEYBOARD_CONNECTED; USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers); break; } case STATE_KEYBOARD_CONNECTED: { // // Nothing is currently done in the main loop when the keyboard // is connected. // break; } case STATE_UNKNOWN_DEVICE: { // // Nothing to do as the device is unknown. // break; } case STATE_NO_DEVICE: { // // Nothing is currently done in the main loop when the keyboard // is not connected. // break; } default: { break; } } // // Periodic call the main loop for the Host controller driver. // USBHCDMain(); } }
//***************************************************************************** // // This is the main loop that runs the application. // //***************************************************************************** int main(void) { FRESULT FileResult; tRectangle sRect; // // Initially wait for device connection. // g_eState = STATE_NO_DEVICE; // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Enable Clocking to the USB controller. // SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // // Set the USB pins to be controlled by the USB controller. // GPIOPinTypeUSBDigital(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_4); // // The LM3S3748 board uses a USB mux that must be switched to use the // host connecter and not the device connecter. // GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN); GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_HOST); // // Turn on USB Phy clock. // SysCtlUSBPLLEnable(); // // Set the system tick to fire 100 times per second. // SysTickPeriodSet(SysCtlClockGet()/100); SysTickIntEnable(); SysTickEnable(); // // Enable the uDMA controller and set up the control table base. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA); uDMAEnable(); uDMAControlBaseSet(g_sDMAControlTable); // // Initialize the display driver. // Formike128x128x16Init(); // // Turn on the backlight. // Formike128x128x16BacklightOn(); // // Initialize the graphics context. // GrContextInit(&g_sContext, &g_sFormike128x128x16); // // Fill the top 15 rows of the screen with blue to create the banner. // sRect.sXMin = 0; sRect.sYMin = 0; sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1; sRect.sYMax = SPLASH_HEIGHT - 1; GrContextForegroundSet(&g_sContext, ClrDarkBlue); GrRectFill(&g_sContext, &sRect); // // Put a white box around the banner. // GrContextForegroundSet(&g_sContext, ClrWhite); GrRectDraw(&g_sContext, &sRect); // // Put the application name in the middle of the banner. // GrContextFontSet(&g_sContext, &g_sFontFixed6x8); GrStringDrawCentered(&g_sContext, "usb_host_msc", -1, GrContextDpyWidthGet(&g_sContext) / 2, 7, 0); // // Set the color to white and select the 20 point font. // GrContextForegroundSet(&g_sContext, FILE_COLOR); GrStringDraw(&g_sContext, "No Device", 100, 0, TOP_HEIGHT, 1); // // Register the host class drivers. // USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers); // // Open an instance of the mass storage class driver. // g_ulMSCInstance = USBHMSCDriveOpen(0, MSCCallback); // // Initialize the power configuration. This sets the power enable signal // to be active high and does not enable the power fault. // USBHCDPowerConfigInit(0, USB_HOST_PWREN_HIGH); // // Initialize the host controller. // USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE); // // Initialize the pushbuttons. // ButtonsInit(); // // Set the auto repeat rates for the up and down buttons. // ButtonsSetAutoRepeat(UP_BUTTON, 50, 15); ButtonsSetAutoRepeat(DOWN_BUTTON, 50, 15); // // Current directory is "/" // g_DirData.szPWD[0] = '/'; g_DirData.szPWD[1] = 0; // // Initialize the file system. // FileInit(); while(1) { USBHCDMain(); switch(g_eState) { case STATE_DEVICE_ENUM: { // // Reset the root directory. // g_DirData.szPWD[0] = '/'; g_DirData.szPWD[1] = 0; // // Open the root directory. // FileResult = f_opendir(&g_DirData.DirState, g_DirData.szPWD); // // Wait for the root directory to open successfully. The MSC // device can enumerate before being read to be accessed, so // there may be some delay before it is ready. // if(FileResult == FR_OK) { // // Reset the directory state. // g_DirData.ulIndex = 0; g_DirData.ulSelectIndex = 0; g_DirData.ulValidValues = 0; g_eState = STATE_DEVICE_READY; // // Ignore buttons pressed before being ready. // g_ulButtons = 0; // // Update the screen if the root dir opened successfully. // DirUpdate(); UpdateWindow(); } else if(FileResult != FR_NOT_READY) { // some kind of error } // // Set the Device Present flag. // g_ulFlags = FLAGS_DEVICE_PRESENT; break; } // // This is the running state where buttons are checked and the // screen is updated. // case STATE_DEVICE_READY: { // // Down button pressed and released. // if(g_ulButtons & BUTTON_DOWN_CLICK) { // // Update the screen and directory state. // MoveDown(); // // Clear the button pressed event. // g_ulButtons &= ~BUTTON_DOWN_CLICK; } // // Up button pressed and released. // if(g_ulButtons & BUTTON_UP_CLICK) { // // Update the screen and directory state. // MoveUp(); // // Clear the button pressed event. // g_ulButtons &= ~BUTTON_UP_CLICK; } // // Select button pressed and released. // if(g_ulButtons & BUTTON_SELECT_CLICK) { // // If this was a directory go into it. // SelectDir(); // // Clear the button pressed event. // g_ulButtons &= ~BUTTON_SELECT_CLICK; } break; } // // If there is no device then just wait for one. // case STATE_NO_DEVICE: { if(g_ulFlags == FLAGS_DEVICE_PRESENT) { // // Clear the screen and indicate that there is no longer // a device present. // ClearTextBox(); GrStringDraw(&g_sContext, "No Device", 100, 0, TOP_HEIGHT, 1); // // Clear the Device Present flag. // g_ulFlags &= ~FLAGS_DEVICE_PRESENT; } break; } // // An unknown device was connected. // case STATE_UNKNOWN_DEVICE: { // // If this is a new device then change the status. // if((g_ulFlags & FLAGS_DEVICE_PRESENT) == 0) { // // Clear the screen and indicate that an unknown device is // present. // ClearTextBox(); GrStringDraw(&g_sContext, "Unknown Device", 100, 0, TOP_HEIGHT, 1); } // // Set the Device Present flag. // g_ulFlags = FLAGS_DEVICE_PRESENT; break; } // // Something has caused a power fault. // case STATE_POWER_FAULT: { break; } default: { break; } } } }