LUFA/Drivers/USB/Class/Device/MassStorage.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 #include "../../HighLevel/USBMode.h"
  32 #if defined(USB_CAN_BE_DEVICE)
  33
  34 #define  INCLUDE_FROM_MS_CLASS_DEVICE_C
  35 #include "MassStorage.h"
  36
  37 static USB_ClassInfo_MS_Device_t* CallbackMSInterfaceInfo;
  38
  39 void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
  40 {
  41         if (!(Endpoint_IsSETUPReceived()))
  42           return;
  43
  44         if (USB_ControlRequest.wIndex != MSInterfaceInfo->Config.InterfaceNumber)
  45           return;
  46
  47         switch (USB_ControlRequest.bRequest)
  48         {
  49                 case REQ_MassStorageReset:
  50                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  51                         {
  52                                 Endpoint_ClearSETUP();
  53
  54                                 MSInterfaceInfo->State.IsMassStoreReset = true;
  55
  56                                 while (!(Endpoint_IsINReady()));
  57                                 Endpoint_ClearIN();
  58                         }
  59
  60                         break;
  61                 case REQ_GetMaxLUN:
  62                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
  63                         {
  64                                 Endpoint_ClearSETUP();
  65
  66                                 Endpoint_Write_Byte(MSInterfaceInfo->Config.TotalLUNs - 1);
  67
  68                                 Endpoint_ClearIN();
  69
  70                                 while (!(Endpoint_IsOUTReceived()));
  71                                 Endpoint_ClearOUT();
  72                         }
  73
  74                         break;
  75         }
  76 }
  77
  78 bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
  79 {
  80         if (!(Endpoint_ConfigureEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,
  81                                                                  ENDPOINT_DIR_IN, MSInterfaceInfo->Config.DataINEndpointSize,
  82                                                                  ENDPOINT_BANK_SINGLE)))
  83         {
  84                 return false;
  85         }
  86
  87         if (!(Endpoint_ConfigureEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber, EP_TYPE_BULK,
  88                                          ENDPOINT_DIR_OUT, MSInterfaceInfo->Config.DataOUTEndpointSize,
  89                                          ENDPOINT_BANK_SINGLE)))
  90         {
  91                 return false;
  92         }
  93
  94         return true;
  95 }
  96
  97 void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
  98 {
  99         if (!(USB_IsConnected) || !(USB_ConfigurationNumber))
 100           return;
 101
 102         Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
 103
 104         if (Endpoint_IsReadWriteAllowed())
 105         {
 106                 if (MS_Device_ReadInCommandBlock(MSInterfaceInfo))
 107                 {
 108                         if (MSInterfaceInfo->State.CommandBlock.Flags & MS_COMMAND_DIR_DATA_IN)
 109                           Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
 110
 111                         MSInterfaceInfo->State.CommandStatus.Status = CALLBACK_MS_Device_SCSICommandReceived(MSInterfaceInfo) ?
 112                                                                                          SCSI_Command_Pass : SCSI_Command_Fail;
 113                         MSInterfaceInfo->State.CommandStatus.Signature           = MS_CSW_SIGNATURE;
 114                         MSInterfaceInfo->State.CommandStatus.Tag                 = MSInterfaceInfo->State.CommandBlock.Tag;
 115                         MSInterfaceInfo->State.CommandStatus.DataTransferResidue = MSInterfaceInfo->State.CommandBlock.DataTransferLength;
 116
 117                         if ((MSInterfaceInfo->State.CommandStatus.Status == SCSI_Command_Fail) &&
 118                             (MSInterfaceInfo->State.CommandStatus.DataTransferResidue))
 119                         {
 120                                 Endpoint_StallTransaction();
 121                         }
 122
 123                         MS_Device_ReturnCommandStatus(MSInterfaceInfo);
 124
 125                         if (MSInterfaceInfo->State.IsMassStoreReset)
 126                         {
 127                                 Endpoint_ResetFIFO(MSInterfaceInfo->Config.DataOUTEndpointNumber);
 128                                 Endpoint_ResetFIFO(MSInterfaceInfo->Config.DataINEndpointNumber);
 129
 130                                 Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
 131                                 Endpoint_ClearStall();
 132                                 Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
 133                                 Endpoint_ClearStall();
 134                         }
 135                 }
 136         }
 137
 138         MSInterfaceInfo->State.IsMassStoreReset = false;
 139 }
 140
 141 static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
 142 {
 143         Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
 144
 145         CallbackMSInterfaceInfo = MSInterfaceInfo;
 146         Endpoint_Read_Stream_LE(&MSInterfaceInfo->State.CommandBlock,
 147                                 (sizeof(MS_CommandBlockWrapper_t) - 16),
 148                                 StreamCallback_MS_Device_AbortOnMassStoreReset);
 149
 150         if ((MSInterfaceInfo->State.CommandBlock.Signature         != MS_CBW_SIGNATURE)                  ||
 151             (MSInterfaceInfo->State.CommandBlock.LUN               >= MSInterfaceInfo->Config.TotalLUNs) ||
 152                 (MSInterfaceInfo->State.CommandBlock.Flags              & 0x1F)                              ||
 153                 (MSInterfaceInfo->State.CommandBlock.SCSICommandLength == 0)                                 ||
 154                 (MSInterfaceInfo->State.CommandBlock.SCSICommandLength >  16))
 155         {
 156                 Endpoint_StallTransaction();
 157                 Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
 158                 Endpoint_StallTransaction();
 159
 160                 return false;
 161         }
 162
 163         CallbackMSInterfaceInfo = MSInterfaceInfo;
 164         Endpoint_Read_Stream_LE(&MSInterfaceInfo->State.CommandBlock.SCSICommandData,
 165                                 MSInterfaceInfo->State.CommandBlock.SCSICommandLength,
 166                                 StreamCallback_MS_Device_AbortOnMassStoreReset);
 167
 168         Endpoint_ClearOUT();
 169
 170         if (MSInterfaceInfo->State.IsMassStoreReset)
 171           return false;
 172
 173         return true;
 174 }
 175
 176 static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
 177 {
 178         Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
 179
 180         while (Endpoint_IsStalled())
 181         {
 182                 USB_USBTask();
 183
 184                 if (MSInterfaceInfo->State.IsMassStoreReset)
 185                   return;
 186         }
 187
 188         Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
 189
 190         while (Endpoint_IsStalled())
 191         {
 192                 USB_USBTask();
 193
 194                 if (MSInterfaceInfo->State.IsMassStoreReset)
 195                   return;
 196         }
 197
 198         CallbackMSInterfaceInfo = MSInterfaceInfo;
 199         Endpoint_Write_Stream_LE(&MSInterfaceInfo->State.CommandStatus, sizeof(MS_CommandStatusWrapper_t),
 200                                  StreamCallback_MS_Device_AbortOnMassStoreReset);
 201
 202         Endpoint_ClearIN();
 203
 204         if (MSInterfaceInfo->State.IsMassStoreReset)
 205           return;
 206 }
 207
 208 static uint8_t StreamCallback_MS_Device_AbortOnMassStoreReset(void)
 209 {
 210         MS_Device_USBTask(CallbackMSInterfaceInfo);
 211
 212         if (CallbackMSInterfaceInfo->State.IsMassStoreReset)
 213           return STREAMCALLBACK_Abort;
 214         else
 215           return STREAMCALLBACK_Continue;
 216 }
 217
 218 #endif