Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.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 MassStorageHost demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "MassStorageHost.h"
  38
  39 /** LUFA Mass Storage Class driver interface configuration and state information. This structure is
  40  *  passed to all Mass Storage Class driver functions, so that multiple instances of the same class
  41  *  within a device can be differentiated from one another.
  42  */
  43 USB_ClassInfo_MS_Host_t FlashDisk_MS_Interface =
  44         {
  45                 .Config =
  46                         {
  47                                 .DataINPipeNumber       = 1,
  48                                 .DataINPipeDoubleBank   = false,
  49
  50                                 .DataOUTPipeNumber      = 2,
  51                                 .DataOUTPipeDoubleBank  = false,
  52                         },
  53         };
  54
  55
  56 /** Main program entry point. This routine configures the hardware required by the application, then
  57  *  enters a loop to run the application tasks in sequence.
  58  */
  59 int main(void)
  60 {
  61         SetupHardware();
  62
  63         puts_P(PSTR(ESC_FG_CYAN "Mass Storage Host Demo running.\r\n" ESC_FG_WHITE));
  64
  65         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  66         sei();
  67
  68         for (;;)
  69         {
  70                 switch (USB_HostState)
  71                 {
  72                         case HOST_STATE_Addressed:
  73                                 LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  74
  75                                 uint16_t ConfigDescriptorSize;
  76                                 uint8_t  ConfigDescriptorData[512];
  77
  78                                 if (USB_Host_GetDeviceConfigDescriptor(1, &ConfigDescriptorSize, ConfigDescriptorData,
  79                                                                        sizeof(ConfigDescriptorData)) != HOST_GETCONFIG_Successful)
  80                                 {
  81                                         puts_P(PSTR("Error Retrieving Configuration Descriptor.\r\n"));
  82                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
  83                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
  84                                         break;
  85                                 }
  86
  87                                 if (MS_Host_ConfigurePipes(&FlashDisk_MS_Interface,
  88                                                            ConfigDescriptorSize, ConfigDescriptorData) != MS_ENUMERROR_NoError)
  89                                 {
  90                                         puts_P(PSTR("Attached Device Not a Valid Mass Storage Device.\r\n"));
  91                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
  92                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
  93                                         break;
  94                                 }
  95
  96                                 if (USB_Host_SetDeviceConfiguration(1) != HOST_SENDCONTROL_Successful)
  97                                 {
  98                                         puts_P(PSTR("Error Setting Device Configuration.\r\n"));
  99                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 100                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 101                                         break;
 102                                 }
 103
 104                                 puts_P(PSTR("Mass Storage Device Enumerated.\r\n"));
 105                                 LEDs_SetAllLEDs(LEDMASK_USB_READY);
 106                                 USB_HostState = HOST_STATE_Configured;
 107                                 break;
 108                         case HOST_STATE_Configured:
 109                                 LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 110
 111                                 uint8_t MaxLUNIndex;
 112                                 if (MS_Host_GetMaxLUN(&FlashDisk_MS_Interface, &MaxLUNIndex))
 113                                 {
 114                                         puts_P(PSTR("Error retrieving max LUN index.\r\n"));
 115                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 116                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 117                                         break;
 118                                 }
 119
 120                                 printf_P(PSTR("Total LUNs: %d - Using first LUN in device.\r\n"), (MaxLUNIndex + 1));
 121
 122                                 if (MS_Host_ResetMSInterface(&FlashDisk_MS_Interface))
 123                                 {
 124                                         puts_P(PSTR("Error resetting Mass Storage interface.\r\n"));
 125                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 126                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 127                                         break;
 128                                 }
 129
 130                                 SCSI_Request_Sense_Response_t SenseData;
 131                                 if (MS_Host_RequestSense(&FlashDisk_MS_Interface, 0, &SenseData) != 0)
 132                                 {
 133                                         puts_P(PSTR("Error retrieving device sense.\r\n"));
 134                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 135                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 136                                         break;
 137                                 }
 138
 139                                 if (MS_Host_PreventAllowMediumRemoval(&FlashDisk_MS_Interface, 0, true))
 140                                 {
 141                                         puts_P(PSTR("Error setting Prevent Device Removal bit.\r\n"));
 142                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 143                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 144                                         break;
 145                                 }
 146
 147                                 SCSI_Inquiry_Response_t InquiryData;
 148                                 if (MS_Host_GetInquiryData(&FlashDisk_MS_Interface, 0, &InquiryData))
 149                                 {
 150                                         puts_P(PSTR("Error retrieving device Inquiry data.\r\n"));
 151                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 152                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 153                                         break;
 154                                 }
 155
 156                                 printf_P(PSTR("Vendor \"%.8s\", Product \"%.16s\"\r\n"), InquiryData.VendorID, InquiryData.ProductID);
 157
 158                                 puts_P(PSTR("Waiting until ready...\r\n"));
 159
 160                                 for (;;)
 161                                 {
 162                                         uint8_t ErrorCode = MS_Host_TestUnitReady(&FlashDisk_MS_Interface, 0);
 163
 164                                         if (!(ErrorCode))
 165                                           break;
 166
 167                                         /* Check if an error other than a logical command error (device busy) received */
 168                                         if (ErrorCode != MS_ERROR_LOGICAL_CMD_FAILED)
 169                                         {
 170                                                 puts_P(PSTR("Error waiting for device to be ready.\r\n"));
 171                                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 172                                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 173                                                 break;
 174                                         }
 175                                 }
 176
 177                                 puts_P(PSTR("Retrieving Capacity...\r\n"));
 178
 179                                 SCSI_Capacity_t DiskCapacity;
 180                                 if (MS_Host_ReadDeviceCapacity(&FlashDisk_MS_Interface, 0, &DiskCapacity))
 181                                 {
 182                                         puts_P(PSTR("Error retrieving device capacity.\r\n"));
 183                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 184                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 185                                         break;
 186                                 }
 187
 188                                 printf_P(PSTR("%lu blocks of %lu bytes.\r\n"), DiskCapacity.Blocks, DiskCapacity.BlockSize);
 189
 190                                 uint8_t BlockBuffer[DiskCapacity.BlockSize];
 191
 192                                 if (MS_Host_ReadDeviceBlocks(&FlashDisk_MS_Interface, 0, 0x00000000, 1, DiskCapacity.BlockSize, BlockBuffer))
 193                                 {
 194                                         puts_P(PSTR("Error reading device block.\r\n"));
 195                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 196                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 197                                         break;
 198                                 }
 199
 200                                 puts_P(PSTR("\r\nContents of first block:\r\n"));
 201
 202                                 for (uint16_t Chunk = 0; Chunk < (DiskCapacity.BlockSize >> 4); Chunk++)
 203                                 {
 204                                         uint8_t* ChunkPtr = &BlockBuffer[Chunk << 4];
 205
 206                                         /* Print out the 16 bytes of the chunk in HEX format */
 207                                         for (uint8_t ByteOffset = 0; ByteOffset < (1 << 4); ByteOffset++)
 208                                         {
 209                                                 char CurrByte = *(ChunkPtr + ByteOffset);
 210                                                 printf_P(PSTR("%.2X "), CurrByte);
 211                                         }
 212
 213                                         printf_P(PSTR("    "));
 214
 215                                         /* Print out the 16 bytes of the chunk in ASCII format */
 216                                         for (uint8_t ByteOffset = 0; ByteOffset < (1 << 4); ByteOffset++)
 217                                         {
 218                                                 char CurrByte = *(ChunkPtr + ByteOffset);
 219                                                 putchar(isprint(CurrByte) ? CurrByte : '.');
 220                                         }
 221
 222                                         printf_P(PSTR("\r\n"));
 223                                 }
 224
 225                                 LEDs_SetAllLEDs(LEDMASK_USB_READY);
 226                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 227                                 break;
 228                 }
 229
 230                 MS_Host_USBTask(&FlashDisk_MS_Interface);
 231                 USB_USBTask();
 232         }
 233 }
 234
 235 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 236 void SetupHardware(void)
 237 {
 238         /* Disable watchdog if enabled by bootloader/fuses */
 239         MCUSR &= ~(1 << WDRF);
 240         wdt_disable();
 241
 242         /* Disable clock division */
 243         clock_prescale_set(clock_div_1);
 244
 245         /* Hardware Initialization */
 246         Serial_Init(9600, false);
 247         LEDs_Init();
 248         USB_Init();
 249
 250         /* Create a stdio stream for the serial port for stdin and stdout */
 251         Serial_CreateStream(NULL);
 252 }
 253
 254 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
 255  *  starts the library USB task to begin the enumeration and USB management process.
 256  */
 257 void EVENT_USB_Host_DeviceAttached(void)
 258 {
 259         puts_P(PSTR("Device Attached.\r\n"));
 260         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 261 }
 262
 263 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
 264  *  stops the library USB task management process.
 265  */
 266 void EVENT_USB_Host_DeviceUnattached(void)
 267 {
 268         puts_P(PSTR("\r\nDevice Unattached.\r\n"));
 269         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 270 }
 271
 272 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
 273  *  enumerated by the host and is now ready to be used by the application.
 274  */
 275 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 276 {
 277         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 278 }
 279
 280 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 281 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 282 {
 283         USB_Disable();
 284
 285         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 286                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 287
 288         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 289         for(;;);
 290 }
 291
 292 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 293  *  enumerating an attached USB device.
 294  */
 295 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
 296                                             const uint8_t SubErrorCode)
 297 {
 298         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 299                                  " -- Error Code %d\r\n"
 300                                  " -- Sub Error Code %d\r\n"
 301                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 302
 303         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 304 }
 305