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* 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* 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* MSInterfaceInfo)
  98 {
  99         if (!(USB_IsConnected))
 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                                 MSInterfaceInfo->State.IsMassStoreReset = false;
 136                         }
 137                 }
 138         }
 139 }
 140
 141 static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
 142 {
 143         Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
 144
 145         CallbackMSInterfaceInfo = MSInterfaceInfo;
 146         Endpoint_Read_Stream_LE(&MSInterfaceInfo->State.CommandBlock,
 147                                 (sizeof(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.SCSICommandLength >  16))
 153         {
 154                 Endpoint_StallTransaction();
 155                 Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
 156                 Endpoint_StallTransaction();
 157
 158                 return false;
 159         }
 160
 161         CallbackMSInterfaceInfo = MSInterfaceInfo;
 162         Endpoint_Read_Stream_LE(&MSInterfaceInfo->State.CommandBlock.SCSICommandData,
 163                                 MSInterfaceInfo->State.CommandBlock.SCSICommandLength,
 164                                 StreamCallback_MS_Device_AbortOnMassStoreReset);
 165
 166         Endpoint_ClearOUT();
 167
 168         if (MSInterfaceInfo->State.IsMassStoreReset)
 169           return false;
 170
 171         return true;
 172 }
 173
 174 static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
 175 {
 176         Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
 177
 178         while (Endpoint_IsStalled())
 179         {
 180                 USB_USBTask();
 181
 182                 if (MSInterfaceInfo->State.IsMassStoreReset)
 183                   return;
 184         }
 185
 186         Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
 187
 188         while (Endpoint_IsStalled())
 189         {
 190                 USB_USBTask();
 191
 192                 if (MSInterfaceInfo->State.IsMassStoreReset)
 193                   return;
 194         }
 195
 196         CallbackMSInterfaceInfo = MSInterfaceInfo;
 197         Endpoint_Write_Stream_LE(&MSInterfaceInfo->State.CommandStatus, sizeof(CommandStatusWrapper_t),
 198                                  StreamCallback_MS_Device_AbortOnMassStoreReset);
 199
 200         Endpoint_ClearIN();
 201
 202         if (MSInterfaceInfo->State.IsMassStoreReset)
 203           return;
 204 }
 205
 206 static uint8_t StreamCallback_MS_Device_AbortOnMassStoreReset(void)
 207 {
 208         MS_Device_USBTask(CallbackMSInterfaceInfo);
 209
 210         if (CallbackMSInterfaceInfo->State.IsMassStoreReset)
 211           return STREAMCALLBACK_Abort;
 212         else
 213           return STREAMCALLBACK_Continue;
 214 }
 215
 216 #endif