Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.c

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