Demos/Host/Incomplete/AndroidAccessoryHost/AndroidAccessoryHost.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2011.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2011  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 disclaim 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         sei();
  50
  51         for (;;)
  52         {
  53                 Android_Host_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         /* Disable watchdog if enabled by bootloader/fuses */
  62         MCUSR &= ~(1 << WDRF);
  63         wdt_disable();
  64
  65         /* Disable clock division */
  66         clock_prescale_set(clock_div_1);
  67
  68         /* Hardware Initialization */
  69         Serial_Init(9600, false);
  70         LEDs_Init();
  71         USB_Init();
  72
  73         /* Create a stdio stream for the serial port for stdin and stdout */
  74         Serial_CreateStream(NULL);
  75 }
  76
  77 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
  78  *  starts the library USB task to begin the enumeration and USB management process.
  79  */
  80 void EVENT_USB_Host_DeviceAttached(void)
  81 {
  82         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
  83         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  84 }
  85
  86 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
  87  *  stops the library USB task management process.
  88  */
  89 void EVENT_USB_Host_DeviceUnattached(void)
  90 {
  91         puts_P(PSTR(ESC_FG_GREEN "\r\nDevice Unattached.\r\n" ESC_FG_WHITE));
  92         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  93 }
  94
  95 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
  96  *  enumerated by the host and is now ready to be used by the application.
  97  */
  98 void EVENT_USB_Host_DeviceEnumerationComplete(void)
  99 {
 100         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 101 }
 102
 103 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 104 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 105 {
 106         USB_Disable();
 107
 108         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 109                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 110
 111         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 112         for(;;);
 113 }
 114
 115 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 116  *  enumerating an attached USB device.
 117  */
 118 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
 119                                             const uint8_t SubErrorCode)
 120 {
 121         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 122                                  " -- Error Code %d\r\n"
 123                                  " -- Sub Error Code %d\r\n"
 124                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 125
 126         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 127 }
 128
 129 /** Task to set the configuration of the attached device after it has been enumerated. */
 130 void Android_Host_Task(void)
 131 {
 132         uint8_t ErrorCode;
 133
 134         switch (USB_HostState)
 135         {
 136                 case HOST_STATE_Addressed:
 137                         puts_P(PSTR("Getting Device Data.\r\n"));
 138
 139                         /* Get and process the configuration descriptor data */
 140                         ErrorCode = ProcessDeviceDescriptor();
 141
 142                         bool RequiresModeSwitch = (ErrorCode == NonAccessoryModeAndroidDevice);
 143
 144                         /* Error out if the device is not an Android device or an error occurred */
 145                         if ((ErrorCode != AccessoryModeAndroidDevice) && !(RequiresModeSwitch))
 146                         {
 147                                 if (ErrorCode == DevControlError)
 148                                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Device).\r\n"));
 149                                 else
 150                                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 151
 152                                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 153
 154                                 /* Indicate error via status LEDs */
 155                                 LEDs_SetAllLEDs(LEDS_LED1);
 156
 157                                 /* Wait until USB device disconnected */
 158                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 159                                 break;
 160                         }
 161
 162                         printf_P(PSTR("Android Device Detected - %sAccessory mode.\r\n"), (RequiresModeSwitch ? "Non-" : ""));
 163
 164                         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 165                         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 166                         {
 167                                 printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
 168                                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 169
 170                                 /* Indicate error via status LEDs */
 171                                 LEDs_SetAllLEDs(LEDS_LED1);
 172
 173                                 /* Wait until USB device disconnected */
 174                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 175                                 break;
 176                         }
 177
 178                         /* Check if a valid Android device was attached, but it is not current in Accessory mode */
 179                         if (RequiresModeSwitch)
 180                         {
 181                                 uint16_t AndroidProtocol;
 182
 183                                 /* Fetch the version of the Android Accessory Protocol supported by the device */
 184                                 if ((ErrorCode = Android_GetAccessoryProtocol(&AndroidProtocol)) != HOST_SENDCONTROL_Successful)
 185                                 {
 186                                         printf_P(PSTR(ESC_FG_RED "Control Error (Get Protocol).\r\n"
 187                                                                  " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 188
 189                                         /* Indicate error via status LEDs */
 190                                         LEDs_SetAllLEDs(LEDS_LED1);
 191
 192                                         /* Wait until USB device disconnected */
 193                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 194                                         break;
 195                                 }
 196
 197                                 /* Validate the returned protocol version */
 198                                 if (AndroidProtocol != ANDROID_PROTOCOL_Accessory)
 199                                 {
 200                                         puts_P(PSTR(ESC_FG_RED "Accessory Mode Not Supported."));
 201
 202                                         /* Indicate error via status LEDs */
 203                                         LEDs_SetAllLEDs(LEDS_LED1);
 204
 205                                         /* Wait until USB device disconnected */
 206                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 207                                         break;
 208                                 }
 209
 210                                 /* Send the device strings and start the Android Accessory Mode */
 211                                 Android_SendString(ANDROID_STRING_Manufacturer, "Dean Camera");
 212                                 Android_SendString(ANDROID_STRING_Model,        "LUFA Android Demo");
 213                                 Android_SendString(ANDROID_STRING_Description,  "LUFA Android Demo");
 214                                 Android_SendString(ANDROID_STRING_Version,      "1.0");
 215                                 Android_SendString(ANDROID_STRING_URI,          "http://www.lufa-lib.org");
 216                                 Android_SendString(ANDROID_STRING_Serial,       "0000000012345678");
 217                                 Android_StartAccessoryMode();
 218
 219                                 /* Wait until USB device disconnected */
 220                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 221                                 break;
 222                         }
 223
 224                         puts_P(PSTR("Getting Config Data.\r\n"));
 225
 226                         /* Get and process the configuration descriptor data */
 227                         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 228                         {
 229                                 if (ErrorCode == ControlError)
 230                                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 231                                 else
 232                                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 233
 234                                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 235
 236                                 /* Indicate error via status LEDs */
 237                                 LEDs_SetAllLEDs(LEDS_LED1);
 238
 239                                 /* Wait until USB device disconnected */
 240                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 241                                 break;
 242                         }
 243
 244                         puts_P(PSTR("Accessory Mode Android Enumerated.\r\n"));
 245
 246                         USB_HostState = HOST_STATE_Configured;
 247                         break;
 248                 case HOST_STATE_Configured:
 249                         /* Select the data IN pipe */
 250                         Pipe_SelectPipe(ANDROID_DATA_IN_PIPE);
 251                         Pipe_Unfreeze();
 252
 253                         /* Check to see if a packet has been received */
 254                         if (Pipe_IsINReceived())
 255                         {
 256                                 /* Re-freeze IN pipe after the packet has been received */
 257                                 Pipe_Freeze();
 258
 259                                 /* Check if data is in the pipe */
 260                                 if (Pipe_IsReadWriteAllowed())
 261                                 {
 262                                         uint8_t NextReceivedByte = Pipe_BytesInPipe();
 263                                         uint8_t LEDMask          = LEDS_NO_LEDS;
 264
 265                                         if (NextReceivedByte & 0x01)
 266                                                 LEDMask |= LEDS_LED1;
 267
 268                                         if (NextReceivedByte & 0x02)
 269                                                 LEDMask |= LEDS_LED2;
 270
 271                                         if (NextReceivedByte & 0x04)
 272                                                 LEDMask |= LEDS_LED3;
 273
 274                                         if (NextReceivedByte & 0x08)
 275                                                 LEDMask |= LEDS_LED4;
 276
 277                                         LEDs_SetAllLEDs(LEDMask);
 278                                 }
 279                                 else
 280                                 {
 281                                         /* Clear the pipe after all data in the packet has been read, ready for the next packet */
 282                                         Pipe_ClearIN();
 283                                 }
 284                         }
 285
 286                         /* Re-freeze IN pipe after use */
 287                         Pipe_Freeze();
 288                         break;
 289         }
 290 }
 291