Demos/Host/LowLevel/AndroidAccessoryHost/AndroidAccessoryHost.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2021.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2021  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaims all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Main source file for the AndroidAccessoryHost demo. This file contains the main tasks
  34  *  of the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "AndroidAccessoryHost.h"
  38
  39 /** Main program entry point. This routine configures the hardware required by the application, then
  40  *  enters a loop to run the application tasks in sequence.
  41  */
  42 int main(void)
  43 {
  44         SetupHardware();
  45
  46         puts_P(PSTR(ESC_FG_CYAN "Android Accessory Host Demo running.\r\n" ESC_FG_WHITE));
  47
  48         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  49         GlobalInterruptEnable();
  50
  51         for (;;)
  52         {
  53                 AndroidHost_Task();
  54                 USB_USBTask();
  55         }
  56 }
  57
  58 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  59 void SetupHardware(void)
  60 {
  61 #if (ARCH == ARCH_AVR8)
  62         /* Disable watchdog if enabled by bootloader/fuses */
  63         MCUSR &= ~(1 << WDRF);
  64         wdt_disable();
  65
  66         /* Disable clock division */
  67         clock_prescale_set(clock_div_1);
  68 #endif
  69
  70         /* Hardware Initialization */
  71         Serial_Init(9600, false);
  72         LEDs_Init();
  73         USB_Init();
  74
  75         /* Create a stdio stream for the serial port for stdin and stdout */
  76         Serial_CreateStream(NULL);
  77 }
  78
  79 /** Task to set the configuration of the attached device after it has been enumerated. */
  80 void AndroidHost_Task(void)
  81 {
  82         if (USB_HostState != HOST_STATE_Configured)
  83           return;
  84
  85         /* Select the data IN pipe */
  86         Pipe_SelectPipe(ANDROID_DATA_IN_PIPE);
  87         Pipe_Unfreeze();
  88
  89         /* Check to see if a packet has been received */
  90         if (Pipe_IsINReceived())
  91         {
  92                 /* Re-freeze IN pipe after the packet has been received */
  93                 Pipe_Freeze();
  94
  95                 /* Check if data is in the pipe */
  96                 if (Pipe_IsReadWriteAllowed())
  97                 {
  98                         uint8_t NextReceivedByte = Pipe_Read_8();
  99                         uint8_t LEDMask          = LEDS_NO_LEDS;
 100
 101                         if (NextReceivedByte & 0x01)
 102                           LEDMask |= LEDS_LED1;
 103
 104                         if (NextReceivedByte & 0x02)
 105                           LEDMask |= LEDS_LED2;
 106
 107                         if (NextReceivedByte & 0x04)
 108                           LEDMask |= LEDS_LED3;
 109
 110                         if (NextReceivedByte & 0x08)
 111                           LEDMask |= LEDS_LED4;
 112
 113                         LEDs_SetAllLEDs(LEDMask);
 114                 }
 115                 else
 116                 {
 117                         /* Clear the pipe after all data in the packet has been read, ready for the next packet */
 118                         Pipe_ClearIN();
 119                 }
 120         }
 121
 122         /* Re-freeze IN pipe after use */
 123         Pipe_Freeze();
 124 }
 125
 126 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
 127  *  starts the library USB task to begin the enumeration and USB management process.
 128  */
 129 void EVENT_USB_Host_DeviceAttached(void)
 130 {
 131         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
 132         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 133 }
 134
 135 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
 136  *  stops the library USB task management process.
 137  */
 138 void EVENT_USB_Host_DeviceUnattached(void)
 139 {
 140         puts_P(PSTR(ESC_FG_GREEN "\r\nDevice Unattached.\r\n" ESC_FG_WHITE));
 141         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 142 }
 143
 144 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
 145  *  enumerated by the host and is now ready to be used by the application.
 146  */
 147 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 148 {
 149         puts_P(PSTR("Getting Device Data.\r\n"));
 150
 151         /* Get and process the configuration descriptor data */
 152         uint8_t ErrorCode = ProcessDeviceDescriptor();
 153
 154         bool RequiresModeSwitch = (ErrorCode == NonAccessoryModeAndroidDevice);
 155
 156         /* Error out if the device is not an Android device or an error occurred */
 157         if ((ErrorCode != AccessoryModeAndroidDevice) && (ErrorCode != NonAccessoryModeAndroidDevice))
 158         {
 159                 if (ErrorCode == ControlError)
 160                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Device).\r\n"));
 161                 else
 162                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 163
 164                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 165
 166                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 167                 return;
 168         }
 169
 170         printf_P(PSTR("Android Device Detected - %sAccessory mode.\r\n"), (RequiresModeSwitch ? "Non-" : ""));
 171
 172         /* Check if a valid Android device was attached, but it is not current in Accessory mode */
 173         if (RequiresModeSwitch)
 174         {
 175                 uint16_t AndroidProtocol;
 176
 177                 /* Fetch the version of the Android Accessory Protocol supported by the device */
 178                 if ((ErrorCode = Android_GetAccessoryProtocol(&AndroidProtocol)) != HOST_SENDCONTROL_Successful)
 179                 {
 180                         printf_P(PSTR(ESC_FG_RED "Control Error (Get Protocol).\r\n"
 181                                                  " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 182
 183                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 184                         return;
 185                 }
 186
 187                 /* Validate the returned protocol version */
 188                 if (AndroidProtocol != AOA_PROTOCOL_AccessoryV1)
 189                 {
 190                         puts_P(PSTR(ESC_FG_RED "Accessory Mode Not Supported."));
 191
 192                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 193                         return;
 194                 }
 195
 196                 /* Send the device strings and start the Android Accessory Mode */
 197                 Android_SendString(AOA_STRING_Manufacturer, "Dean Camera");
 198                 Android_SendString(AOA_STRING_Model,        "LUFA Android Demo");
 199                 Android_SendString(AOA_STRING_Description,  "LUFA Android Demo");
 200                 Android_SendString(AOA_STRING_Version,      "1.0");
 201                 Android_SendString(AOA_STRING_URI,          "http://www.lufa-lib.org");
 202                 Android_SendString(AOA_STRING_Serial,       "0000000012345678");
 203
 204                 Android_StartAccessoryMode();
 205                 return;
 206         }
 207
 208         puts_P(PSTR("Getting Config Data.\r\n"));
 209
 210         /* Get and process the configuration descriptor data */
 211         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 212         {
 213                 if (ErrorCode == ControlError)
 214                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 215                 else
 216                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 217
 218                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 219
 220                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 221                 return;
 222         }
 223
 224         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 225         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 226         {
 227                 printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
 228                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 229
 230                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 231                 return;
 232         }
 233
 234         puts_P(PSTR("Accessory Mode Android Enumerated.\r\n"));
 235         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 236 }
 237
 238 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 239 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 240 {
 241         USB_Disable();
 242
 243         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 244                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 245
 246         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 247         for(;;);
 248 }
 249
 250 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 251  *  enumerating an attached USB device.
 252  */
 253 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
 254                                             const uint8_t SubErrorCode)
 255 {
 256         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 257                                  " -- Error Code %d\r\n"
 258                                  " -- Sub Error Code %d\r\n"
 259                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 260
 261         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 262 }
 263