Demos/Host/LowLevel/MassStorageHost/MassStorageHost.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   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 /* Globals */
  40 /** Index of the highest available LUN (Logical Unit) in the attached Mass Storage Device */
  41 uint8_t MassStore_MaxLUNIndex;
  42
  43
  44 /** Main program entry point. This routine configures the hardware required by the application, then
  45  *  starts the scheduler to run the application tasks.
  46  */
  47 int main(void)
  48 {
  49         SetupHardware();
  50
  51         puts_P(PSTR(ESC_FG_CYAN "Mass Storage Host Demo running.\r\n" ESC_FG_WHITE));
  52
  53         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  54
  55         for (;;)
  56         {
  57                 MassStorage_Task();
  58                 USB_USBTask();
  59         }
  60 }
  61
  62 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  63 void SetupHardware(void)
  64 {
  65         /* Disable watchdog if enabled by bootloader/fuses */
  66         MCUSR &= ~(1 << WDRF);
  67         wdt_disable();
  68
  69         /* Disable clock division */
  70         clock_prescale_set(clock_div_1);
  71
  72         /* Hardware Initialization */
  73         SerialStream_Init(9600, false);
  74         LEDs_Init();
  75         Buttons_Init();
  76         USB_Init();
  77 }
  78
  79 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
  80  *  starts the library USB task to begin the enumeration and USB management process.
  81  */
  82 void EVENT_USB_Host_DeviceAttached(void)
  83 {
  84         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
  85         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  86 }
  87
  88 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
  89  *  stops the library USB task management process.
  90  */
  91 void EVENT_USB_Host_DeviceUnattached(void)
  92 {
  93         puts_P(PSTR(ESC_FG_GREEN "\r\nDevice Unattached.\r\n" ESC_FG_WHITE));
  94         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  95 }
  96
  97 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
  98  *  enumerated by the host and is now ready to be used by the application.
  99  */
 100 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 101 {
 102         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 103 }
 104
 105 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 106 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 107 {
 108         USB_ShutDown();
 109
 110         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 111                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 112
 113         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 114         for(;;);
 115 }
 116
 117 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 118  *  enumerating an attached USB device.
 119  */
 120 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
 121 {
 122         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 123                                  " -- Error Code %d\r\n"
 124                                  " -- Sub Error Code %d\r\n"
 125                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 126
 127         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 128 }
 129
 130 /** Task to set the configuration of the attached device after it has been enumerated, and to read in blocks from
 131  *  the device and print them to the serial port.
 132  */
 133 void MassStorage_Task(void)
 134 {
 135         uint8_t ErrorCode;
 136
 137         switch (USB_HostState)
 138         {
 139                 case HOST_STATE_Addressed:
 140                         puts_P(PSTR("Getting Config Data.\r\n"));
 141
 142                         /* Get and process the configuration descriptor data */
 143                         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 144                         {
 145                                 if (ErrorCode == ControlError)
 146                                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 147                                 else
 148                                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 149
 150                                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 151
 152                                 /* Indicate error via status LEDs */
 153                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 154
 155                                 /* Wait until USB device disconnected */
 156                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 157                                 break;
 158                         }
 159
 160                         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 161                         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 162                         {
 163                                 printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
 164                                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 165
 166                                 /* Indicate error via status LEDs */
 167                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 168
 169                                 /* Wait until USB device disconnected */
 170                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 171                                 break;
 172                         }
 173
 174                         puts_P(PSTR("Mass Storage Disk Enumerated.\r\n"));
 175
 176                         USB_HostState = HOST_STATE_Configured;
 177                         break;
 178                 case HOST_STATE_Configured:
 179                         /* Indicate device busy via the status LEDs */
 180                         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 181
 182                         /* Send the request, display error and wait for device detach if request fails */
 183                         if ((ErrorCode = MassStore_GetMaxLUN(&MassStore_MaxLUNIndex)) != HOST_SENDCONTROL_Successful)
 184                         {
 185                                 ShowDiskReadError(PSTR("Get Max LUN"), ErrorCode);
 186
 187                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 188                                 break;
 189                         }
 190
 191                         /* Print number of LUNs detected in the attached device */
 192                         printf_P(PSTR("Total LUNs: %d - Using first LUN in device.\r\n"), (MassStore_MaxLUNIndex + 1));
 193
 194                         /* Reset the Mass Storage device interface, ready for use */
 195                         if ((ErrorCode = MassStore_MassStorageReset()) != HOST_SENDCONTROL_Successful)
 196                         {
 197                                 ShowDiskReadError(PSTR("Mass Storage Reset"), ErrorCode);
 198
 199                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 200                                 break;
 201                         }
 202
 203                         /* Get sense data from the device - many devices will not accept any other commands until the sense data
 204                          * is read - both on start-up and after a failed command */
 205                         SCSI_Request_Sense_Response_t SenseData;
 206                         if ((ErrorCode = MassStore_RequestSense(0, &SenseData)) != 0)
 207                         {
 208                                 ShowDiskReadError(PSTR("Request Sense"), ErrorCode);
 209                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 210                                 break;
 211                         }
 212
 213                         /* Set the prevent removal flag for the device, allowing it to be accessed */
 214                         if ((ErrorCode = MassStore_PreventAllowMediumRemoval(0, true)) != 0)
 215                         {
 216                                 ShowDiskReadError(PSTR("Prevent/Allow Medium Removal"), ErrorCode);
 217
 218                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 219                                 break;
 220                         }
 221
 222                         /* Get inquiry data from the device */
 223                         SCSI_Inquiry_Response_t InquiryData;
 224                         if ((ErrorCode = MassStore_Inquiry(0, &InquiryData)) != 0)
 225                         {
 226                                 ShowDiskReadError(PSTR("Inquiry"), ErrorCode);
 227
 228                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 229                                 break;
 230                         }
 231
 232                         /* Print vendor and product names of attached device */
 233                         printf_P(PSTR("Vendor \"%.8s\", Product \"%.16s\"\r\n"), InquiryData.VendorID, InquiryData.ProductID);
 234
 235                         /* Wait until disk ready */
 236                         puts_P(PSTR("Waiting until ready.."));
 237
 238                         for (;;)
 239                         {
 240                                 Serial_TxByte('.');
 241
 242                                 /* Abort if device removed */
 243                                 if (USB_HostState == HOST_STATE_Unattached)
 244                                   break;
 245
 246                                 /* Check to see if the attached device is ready for new commands */
 247                                 ErrorCode = MassStore_TestUnitReady(0);
 248
 249                                 /* If attached device is ready, abort the loop */
 250                                 if (!(ErrorCode))
 251                                   break;
 252
 253                                 /* If an error othe than a logical command failure (indicating device busy) returned, abort */
 254                                 if (ErrorCode != MASS_STORE_SCSI_COMMAND_FAILED)
 255                                 {
 256                                         ShowDiskReadError(PSTR("Test Unit Ready"), ErrorCode);
 257
 258                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 259                                         break;
 260                                 }
 261                         }
 262
 263                         puts_P(PSTR("\r\nRetrieving Capacity... "));
 264
 265                         /* Create new structure for the disk's capacity in blocks and block size */
 266                         SCSI_Capacity_t DiskCapacity;
 267
 268                         /* Retrieve disk capacity */
 269                         if ((ErrorCode = MassStore_ReadCapacity(0, &DiskCapacity)) != 0)
 270                         {
 271                                 ShowDiskReadError(PSTR("Read Capacity"), ErrorCode);
 272
 273                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 274                                 break;
 275                         }
 276
 277                         /* Display the disk capacity in blocks * block size bytes */
 278                         printf_P(PSTR("%lu blocks of %lu bytes.\r\n"), DiskCapacity.Blocks, DiskCapacity.BlockSize);
 279
 280                         /* Create a new buffer capabable of holding a single block from the device */
 281                         uint8_t BlockBuffer[DiskCapacity.BlockSize];
 282
 283                         /* Read in the first 512 byte block from the device */
 284                         if ((ErrorCode = MassStore_ReadDeviceBlock(0, 0x00000000, 1, DiskCapacity.BlockSize, BlockBuffer)) != 0)
 285                         {
 286                                 ShowDiskReadError(PSTR("Read Device Block"), ErrorCode);
 287
 288                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 289                                 break;
 290                         }
 291
 292                         puts_P(PSTR("\r\nContents of first block:\r\n"));
 293
 294                         /* Print out the first block in both HEX and ASCII, 16 bytes per line */
 295                         for (uint16_t Chunk = 0; Chunk < (DiskCapacity.BlockSize >> 4); Chunk++)
 296                         {
 297                                 /* Pointer to the start of the current 16-byte chunk in the read block of data */
 298                                 uint8_t* ChunkPtr = &BlockBuffer[Chunk << 4];
 299
 300                                 /* Print out the 16 bytes of the chunk in HEX format */
 301                                 for (uint8_t ByteOffset = 0; ByteOffset < (1 << 4); ByteOffset++)
 302                                 {
 303                                         char CurrByte = *(ChunkPtr + ByteOffset);
 304
 305                                         printf_P(PSTR("%.2X "), CurrByte);
 306                                 }
 307
 308                                 puts_P(PSTR("    "));
 309
 310                                 /* Print out the 16 bytes of the chunk in ASCII format */
 311                                 for (uint8_t ByteOffset = 0; ByteOffset < (1 << 4); ByteOffset++)
 312                                 {
 313                                         char CurrByte = *(ChunkPtr + ByteOffset);
 314
 315                                         putchar(isprint(CurrByte) ? CurrByte : '.');
 316                                 }
 317
 318                                 puts_P(PSTR("\r\n"));
 319                         }
 320
 321                         puts_P(PSTR("\r\n\r\nPress board button to read entire ASCII contents of disk...\r\n\r\n"));
 322
 323                         /* Wait for the board button to be pressed */
 324                         while (!(Buttons_GetStatus() & BUTTONS_BUTTON1))
 325                         {
 326                                 /* Abort if device removed */
 327                                 if (USB_HostState == HOST_STATE_Unattached)
 328                                   break;
 329                         }
 330
 331                         /* Abort if device removed */
 332                         if (USB_HostState == HOST_STATE_Unattached)
 333                           break;
 334
 335                         /* Print out the entire disk contents in ASCII format */
 336                         for (uint32_t CurrBlockAddress = 0; CurrBlockAddress < DiskCapacity.Blocks; CurrBlockAddress++)
 337                         {
 338                                 /* Read in the next block of data from the device */
 339                                 if ((ErrorCode = MassStore_ReadDeviceBlock(0, CurrBlockAddress, 1, DiskCapacity.BlockSize, BlockBuffer)) != 0)
 340                                 {
 341                                         ShowDiskReadError(PSTR("Read Device Block"), ErrorCode);
 342
 343                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 344                                         break;
 345                                 }
 346
 347                                 /* Send the ASCII data in the read in block to the serial port */
 348                                 for (uint16_t Byte = 0; Byte < DiskCapacity.BlockSize; Byte++)
 349                                 {
 350                                         char CurrByte = BlockBuffer[Byte];
 351
 352                                         putchar(isprint(CurrByte) ? CurrByte : '.');
 353                                 }
 354
 355                                 /* Abort if device removed */
 356                                 if (USB_HostState == HOST_STATE_Unattached)
 357                                   break;
 358                         }
 359
 360                         /* Indicate device no longer busy */
 361                         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 362
 363                         /* Wait until USB device disconnected */
 364                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 365                         break;
 366         }
 367 }
 368
 369 /** Indicates that a communication error has occurred with the attached Mass Storage Device,
 370  *  printing error codes to the serial port and waiting until the device is removed before
 371  *  continuing.
 372  *
 373  *  \param[in] CommandString  ASCII string located in PROGMEM space indicating what operation failed
 374  *  \param[in] ErrorCode      Error code of the function which failed to complete successfully
 375  */
 376 void ShowDiskReadError(char* CommandString, uint8_t ErrorCode)
 377 {
 378         if (ErrorCode == MASS_STORE_SCSI_COMMAND_FAILED)
 379         {
 380                 /* Display the error code */
 381                 printf_P(PSTR(ESC_FG_RED "SCSI command error (%S).\r\n"), CommandString);
 382         }
 383         else
 384         {
 385                 /* Display the error code */
 386                 printf_P(PSTR(ESC_FG_RED "Command error (%S).\r\n"), CommandString);
 387                 printf_P(PSTR("  -- Error Code: %d" ESC_FG_WHITE), ErrorCode);
 388         }
 389
 390         Pipe_Freeze();
 391
 392         /* Indicate device error via the status LEDs */
 393         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 394 }