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