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