Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  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
  67         for (;;)
  68         {
  69                 switch (USB_HostState)
  70                 {
  71                         case HOST_STATE_Addressed:
  72                                 LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  73
  74                                 uint16_t ConfigDescriptorSize;
  75                                 uint8_t  ConfigDescriptorData[512];
  76
  77                                 if (USB_Host_GetDeviceConfigDescriptor(1, &ConfigDescriptorSize, ConfigDescriptorData,
  78                                                                        sizeof(ConfigDescriptorData)) != HOST_GETCONFIG_Successful)
  79                                 {
  80                                         printf("Error Retrieving Configuration Descriptor.\r\n");
  81                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
  82                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
  83                                         break;
  84                                 }
  85
  86                                 if (MS_Host_ConfigurePipes(&FlashDisk_MS_Interface,
  87                                                            ConfigDescriptorSize, ConfigDescriptorData) != MS_ENUMERROR_NoError)
  88                                 {
  89                                         printf("Attached Device Not a Valid Mass Storage Device.\r\n");
  90                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
  91                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
  92                                         break;
  93                                 }
  94
  95                                 if (USB_Host_SetDeviceConfiguration(1) != HOST_SENDCONTROL_Successful)
  96                                 {
  97                                         printf("Error Setting Device Configuration.\r\n");
  98                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
  99                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 100                                         break;
 101                                 }
 102
 103                                 printf("Mass Storage Device Enumerated.\r\n");
 104                                 LEDs_SetAllLEDs(LEDMASK_USB_READY);
 105                                 USB_HostState = HOST_STATE_Configured;
 106                                 break;
 107                         case HOST_STATE_Configured:
 108                                 LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 109
 110                                 uint8_t MaxLUNIndex;
 111                                 if (MS_Host_GetMaxLUN(&FlashDisk_MS_Interface, &MaxLUNIndex))
 112                                 {
 113                                         printf("Error retrieving max LUN index.\r\n");
 114                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 115                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 116                                         break;
 117                                 }
 118
 119                                 printf("Total LUNs: %d - Using first LUN in device.\r\n", (MaxLUNIndex + 1));
 120
 121                                 if (MS_Host_ResetMSInterface(&FlashDisk_MS_Interface))
 122                                 {
 123                                         printf("Error resetting Mass Storage interface.\r\n");
 124                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 125                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 126                                         break;
 127                                 }
 128
 129                                 SCSI_Request_Sense_Response_t SenseData;
 130                                 if (MS_Host_RequestSense(&FlashDisk_MS_Interface, 0, &SenseData) != 0)
 131                                 {
 132                                         printf("Error retrieving device sense.\r\n");
 133                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 134                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 135                                         break;
 136                                 }
 137
 138                                 if (MS_Host_PreventAllowMediumRemoval(&FlashDisk_MS_Interface, 0, true))
 139                                 {
 140                                         printf("Error setting Prevent Device Removal bit.\r\n");
 141                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 142                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 143                                         break;
 144                                 }
 145
 146                                 SCSI_Inquiry_Response_t InquiryData;
 147                                 if (MS_Host_GetInquiryData(&FlashDisk_MS_Interface, 0, &InquiryData))
 148                                 {
 149                                         printf("Error retrieving device Inquiry data.\r\n");
 150                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 151                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 152                                         break;
 153                                 }
 154
 155                                 printf("Vendor \"%.8s\", Product \"%.16s\"\r\n", InquiryData.VendorID, InquiryData.ProductID);
 156
 157                                 printf("Waiting until ready...\r\n");
 158
 159                                 for (;;)
 160                                 {
 161                                         uint8_t ErrorCode = MS_Host_TestUnitReady(&FlashDisk_MS_Interface, 0);
 162
 163                                         if (!(ErrorCode))
 164                                           break;
 165
 166                                         /* Check if an error other than a logical command error (device busy) received */
 167                                         if (ErrorCode != MS_ERROR_LOGICAL_CMD_FAILED)
 168                                         {
 169                                                 printf("Error waiting for device to be ready.\r\n");
 170                                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 171                                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 172                                                 break;
 173                                         }
 174                                 }
 175
 176                                 printf("Retrieving Capacity... ");
 177
 178                                 SCSI_Capacity_t DiskCapacity;
 179                                 if (MS_Host_ReadDeviceCapacity(&FlashDisk_MS_Interface, 0, &DiskCapacity))
 180                                 {
 181                                         printf("Error retrieving device capacity.\r\n");
 182                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 183                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 184                                         break;
 185                                 }
 186
 187                                 printf("%lu blocks of %lu bytes.\r\n", DiskCapacity.Blocks, DiskCapacity.BlockSize);
 188
 189                                 uint8_t BlockBuffer[DiskCapacity.BlockSize];
 190
 191                                 if (MS_Host_ReadDeviceBlocks(&FlashDisk_MS_Interface, 0, 0x00000000, 1, DiskCapacity.BlockSize, BlockBuffer))
 192                                 {
 193                                         printf("Error reading device block.\r\n");
 194                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 195                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 196                                         break;
 197                                 }
 198
 199                                 printf("\r\nContents of first block:\r\n");
 200
 201                                 for (uint16_t Chunk = 0; Chunk < (DiskCapacity.BlockSize >> 4); Chunk++)
 202                                 {
 203                                         uint8_t* ChunkPtr = &BlockBuffer[Chunk << 4];
 204
 205                                         /* Print out the 16 bytes of the chunk in HEX format */
 206                                         for (uint8_t ByteOffset = 0; ByteOffset < (1 << 4); ByteOffset++)
 207                                         {
 208                                                 char CurrByte = *(ChunkPtr + ByteOffset);
 209                                                 printf_P(PSTR("%.2X "), CurrByte);
 210                                         }
 211
 212                                         printf("    ");
 213
 214                                         /* Print out the 16 bytes of the chunk in ASCII format */
 215                                         for (uint8_t ByteOffset = 0; ByteOffset < (1 << 4); ByteOffset++)
 216                                         {
 217                                                 char CurrByte = *(ChunkPtr + ByteOffset);
 218                                                 putchar(isprint(CurrByte) ? CurrByte : '.');
 219                                         }
 220
 221                                         printf("\r\n");
 222                                 }
 223
 224                                 LEDs_SetAllLEDs(LEDMASK_USB_READY);
 225                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 226                                 break;
 227                 }
 228
 229                 MS_Host_USBTask(&FlashDisk_MS_Interface);
 230                 USB_USBTask();
 231         }
 232 }
 233
 234 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 235 void SetupHardware(void)
 236 {
 237         /* Disable watchdog if enabled by bootloader/fuses */
 238         MCUSR &= ~(1 << WDRF);
 239         wdt_disable();
 240
 241         /* Disable clock division */
 242         clock_prescale_set(clock_div_1);
 243
 244         /* Hardware Initialization */
 245         SerialStream_Init(9600, false);
 246         LEDs_Init();
 247         USB_Init();
 248 }
 249
 250 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
 251  *  starts the library USB task to begin the enumeration and USB management process.
 252  */
 253 void EVENT_USB_Host_DeviceAttached(void)
 254 {
 255         puts_P(PSTR("Device Attached.\r\n"));
 256         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 257 }
 258
 259 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
 260  *  stops the library USB task management process.
 261  */
 262 void EVENT_USB_Host_DeviceUnattached(void)
 263 {
 264         puts_P(PSTR("\r\nDevice Unattached.\r\n"));
 265         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 266 }
 267
 268 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
 269  *  enumerated by the host and is now ready to be used by the application.
 270  */
 271 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 272 {
 273         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 274 }
 275
 276 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 277 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 278 {
 279         USB_ShutDown();
 280
 281         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 282                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 283
 284         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 285         for(;;);
 286 }
 287
 288 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 289  *  enumerating an attached USB device.
 290  */
 291 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
 292 {
 293         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 294                                  " -- Error Code %d\r\n"
 295                                  " -- Sub Error Code %d\r\n"
 296                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 297
 298         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 299 }