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_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_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_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_HostError(const uint8_t ErrorCode)
 107 {
 108         USB_ShutDown();
 109
 110         puts_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"));
 111         printf_P(PSTR(" -- 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_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
 121 {
 122         puts_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"));
 123         printf_P(PSTR(" -- Error Code %d\r\n"), ErrorCode);
 124         printf_P(PSTR(" -- Sub Error Code %d\r\n"), SubErrorCode);
 125         printf_P(PSTR(" -- In State %d\r\n" ESC_FG_WHITE), 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                                 puts_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"));
 164                                 printf_P(PSTR(" -- 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"), false, 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"), false, 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) || (SCSICommandStatus.Status != Command_Pass))
 207                         {
 208                                 ShowDiskReadError(PSTR("Request Sense"), (SCSICommandStatus.Status != Command_Pass), ErrorCode);
 209                                 break;
 210                         }
 211
 212                         /* Set the prevent removal flag for the device, allowing it to be accessed */
 213                         if (((ErrorCode = MassStore_PreventAllowMediumRemoval(0, true)) != 0) || (SCSICommandStatus.Status != Command_Pass))
 214                         {
 215                                 ShowDiskReadError(PSTR("Prevent/Allow Medium Removal"), (SCSICommandStatus.Status != Command_Pass), ErrorCode);
 216
 217                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 218                                 break;
 219                         }
 220
 221                         /* Get inquiry data from the device */
 222                         SCSI_Inquiry_Response_t InquiryData;
 223                         if (((ErrorCode = MassStore_Inquiry(0, &InquiryData)) != 0) || (SCSICommandStatus.Status != Command_Pass))
 224                         {
 225                                 ShowDiskReadError(PSTR("Inquiry"), (SCSICommandStatus.Status != Command_Pass), ErrorCode);
 226
 227                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 228                                 break;
 229                         }
 230
 231                         /* Print vendor and product names of attached device */
 232                         printf_P(PSTR("Vendor \"%.8s\", Product \"%.16s\"\r\n"), InquiryData.VendorID, InquiryData.ProductID);
 233
 234                         /* Wait until disk ready */
 235                         puts_P(PSTR("Waiting until ready.."));
 236
 237                         do
 238                         {
 239                                 Serial_TxByte('.');
 240
 241                                 /* Abort if device removed */
 242                                 if (USB_HostState == HOST_STATE_Unattached)
 243                                   break;
 244
 245                                 if ((ErrorCode = MassStore_TestUnitReady(0)) != PIPE_RWSTREAM_NoError)
 246                                 {
 247                                         ShowDiskReadError(PSTR("Test Unit Ready"), false, ErrorCode);
 248
 249                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 250                                         break;
 251                                 }
 252                         }
 253                         while (SCSICommandStatus.Status != Command_Pass);
 254
 255                         puts_P(PSTR("\r\nRetrieving Capacity... "));
 256
 257                         /* Create new structure for the disk's capacity in blocks and block size */
 258                         SCSI_Capacity_t DiskCapacity;
 259
 260                         /* Retrieve disk capacity */
 261                         if (((ErrorCode = MassStore_ReadCapacity(0, &DiskCapacity)) != 0) || (SCSICommandStatus.Status != Command_Pass))
 262                         {
 263                                 ShowDiskReadError(PSTR("Read Capacity"), (SCSICommandStatus.Status != Command_Pass), ErrorCode);
 264
 265                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 266                                 break;
 267                         }
 268
 269                         /* Display the disk capacity in blocks * block size bytes */
 270                         printf_P(PSTR("%lu blocks of %lu bytes.\r\n"), DiskCapacity.Blocks, DiskCapacity.BlockSize);
 271
 272                         /* Create a new buffer capabable of holding a single block from the device */
 273                         uint8_t BlockBuffer[DiskCapacity.BlockSize];
 274
 275                         /* Read in the first 512 byte block from the device */
 276                         if (((ErrorCode = MassStore_ReadDeviceBlock(0, 0x00000000, 1, DiskCapacity.BlockSize, BlockBuffer)) != 0) ||
 277                             (SCSICommandStatus.Status != Command_Pass))
 278                         {
 279                                 ShowDiskReadError(PSTR("Read Device Block"), (SCSICommandStatus.Status != Command_Pass), ErrorCode);
 280
 281                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 282                                 break;
 283                         }
 284
 285                         puts_P(PSTR("\r\nContents of first block:\r\n"));
 286
 287                         /* Print out the first block in both HEX and ASCII, 16 bytes per line */
 288                         for (uint16_t Chunk = 0; Chunk < (DiskCapacity.BlockSize >> 4); Chunk++)
 289                         {
 290                                 /* Pointer to the start of the current 16-byte chunk in the read block of data */
 291                                 uint8_t* ChunkPtr = &BlockBuffer[Chunk << 4];
 292
 293                                 /* Print out the 16 bytes of the chunk in HEX format */
 294                                 for (uint8_t ByteOffset = 0; ByteOffset < (1 << 4); ByteOffset++)
 295                                 {
 296                                         char CurrByte = *(ChunkPtr + ByteOffset);
 297
 298                                         printf_P(PSTR("%.2X "), CurrByte);
 299                                 }
 300
 301                                 puts_P(PSTR("    "));
 302
 303                                 /* Print out the 16 bytes of the chunk in ASCII format */
 304                                 for (uint8_t ByteOffset = 0; ByteOffset < (1 << 4); ByteOffset++)
 305                                 {
 306                                         char CurrByte = *(ChunkPtr + ByteOffset);
 307
 308                                         putchar(isprint(CurrByte) ? CurrByte : '.');
 309                                 }
 310
 311                                 puts_P(PSTR("\r\n"));
 312                         }
 313
 314                         puts_P(PSTR("\r\n\r\nPress board button to read entire ASCII contents of disk...\r\n\r\n"));
 315
 316                         /* Wait for the board button to be pressed */
 317                         while (!(Buttons_GetStatus() & BUTTONS_BUTTON1))
 318                         {
 319                                 /* Abort if device removed */
 320                                 if (USB_HostState == HOST_STATE_Unattached)
 321                                   break;
 322                         }
 323
 324                         /* Print out the entire disk contents in ASCII format */
 325                         for (uint32_t CurrBlock = 0; CurrBlock < DiskCapacity.Blocks; CurrBlock++)
 326                         {
 327                                 /* Read in the next block of data from the device */
 328                                 if (((ErrorCode = MassStore_ReadDeviceBlock(0, CurrBlock, 1, DiskCapacity.BlockSize, BlockBuffer)) != 0) ||
 329                                     (SCSICommandStatus.Status != Command_Pass))
 330                                 {
 331                                         ShowDiskReadError(PSTR("Read Device Block"), (SCSICommandStatus.Status != Command_Pass), ErrorCode);
 332
 333                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 334                                         break;
 335                                 }
 336
 337                                 /* Send the ASCII data in the read in block to the serial port */
 338                                 for (uint16_t Byte = 0; Byte < DiskCapacity.BlockSize; Byte++)
 339                                 {
 340                                         char CurrByte = BlockBuffer[Byte];
 341
 342                                         putchar(isprint(CurrByte) ? CurrByte : '.');
 343                                 }
 344
 345                                 /* Abort if device removed */
 346                                 if (USB_HostState == HOST_STATE_Unattached)
 347                                   break;
 348                         }
 349
 350                         /* Indicate device no longer busy */
 351                         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 352
 353                         /* Wait until USB device disconnected */
 354                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 355                         break;
 356         }
 357 }
 358
 359 /** Indicates that a communication error has occurred with the attached Mass Storage Device,
 360  *  printing error codes to the serial port and waiting until the device is removed before
 361  *  continuing.
 362  *
 363  *  \param[in] CommandString      ASCII string located in PROGMEM space indicating what operation failed
 364  *  \param[in] FailedAtSCSILayer  Indicates if the command failed at the (logical) SCSI layer or at the physical USB layer
 365  *  \param[in] ErrorCode          Error code of the function which failed to complete successfully
 366  */
 367 void ShowDiskReadError(char* CommandString, bool FailedAtSCSILayer, uint8_t ErrorCode)
 368 {
 369         if (FailedAtSCSILayer)
 370         {
 371                 /* Display the error code */
 372                 printf_P(PSTR(ESC_FG_RED "SCSI command error (%S).\r\n"), CommandString);
 373                 printf_P(PSTR("  -- Status Code: %d" ESC_FG_WHITE), ErrorCode);
 374         }
 375         else
 376         {
 377                 /* Display the error code */
 378                 printf_P(PSTR(ESC_FG_RED "Command error (%S).\r\n"), CommandString);
 379                 printf_P(PSTR("  -- Error Code: %d" ESC_FG_WHITE), ErrorCode);
 380         }
 381
 382         Pipe_Freeze();
 383
 384         /* Indicate device error via the status LEDs */
 385         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 386 }