projects / pub / USBasp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Update UC3 platform driver support to use the bitmasks defined in the header files...
[pub/USBasp.git] / LUFA / Drivers / USB / Class / Host / StillImage.c
diff --git a/LUFA/Drivers/USB/Class/Host/StillImage.c b/LUFA/Drivers/USB/Class/Host/StillImage.c
index f7f8637..be83497 100644 (file)
--- a/LUFA/Drivers/USB/Class/Host/StillImage.c
+++ b/LUFA/Drivers/USB/Class/Host/StillImage.c
@@ -1,13 +1,13 @@
 /*
              LUFA Library
 /*
              LUFA Library
-     Copyright (C) Dean Camera, 2010.
+     Copyright (C) Dean Camera, 2011.
 
   dean [at] fourwalledcubicle [dot] com
 
   dean [at] fourwalledcubicle [dot] com
-      www.fourwalledcubicle.com
+           www.lufa-lib.org
 */
 
 /*
 */
 
 /*
-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
 
   Permission to use, copy, modify, distribute, and sell this
   software and its documentation for any purpose is hereby granted
 
   Permission to use, copy, modify, distribute, and sell this
   software and its documentation for any purpose is hereby granted
@@ -29,11 +29,12 @@
 */
 
 #define  __INCLUDE_FROM_USB_DRIVER
 */
 
 #define  __INCLUDE_FROM_USB_DRIVER
-#include "../../HighLevel/USBMode.h"
+#include "../../Core/USBMode.h"
+
 #if defined(USB_CAN_BE_HOST)
 
 #if defined(USB_CAN_BE_HOST)
 
-#define  __INCLUDE_FROM_SI_CLASS_HOST_C
 #define  __INCLUDE_FROM_SI_DRIVER
 #define  __INCLUDE_FROM_SI_DRIVER
+#define  __INCLUDE_FROM_STILLIMAGE_HOST_C
 #include "StillImage.h"
 
 uint8_t SI_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 #include "StillImage.h"
 
 uint8_t SI_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
@@ -50,7 +51,7 @@ uint8_t SI_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
        if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
          return SI_ENUMERROR_InvalidConfigDescriptor;
 
        if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
          return SI_ENUMERROR_InvalidConfigDescriptor;
 
-       while (!(DataINEndpoint) || !(DataOUTEndpoint))
+       while (!(DataINEndpoint) || !(DataOUTEndpoint) || !(EventsEndpoint))
        {
                if (!(StillImageInterface) ||
                    USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
        {
                if (!(StillImageInterface) ||
                    USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
@@ -88,31 +89,59 @@ uint8_t SI_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 
        for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
        {
 
        for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
        {
+               uint16_t Size;
+               uint8_t  Type;
+               uint8_t  Token;
+               uint8_t  EndpointAddress;
+               uint8_t  InterruptPeriod;
+               bool     DoubleBanked;
+
                if (PipeNum == SIInterfaceInfo->Config.DataINPipeNumber)
                {
                if (PipeNum == SIInterfaceInfo->Config.DataINPipeNumber)
                {
-                       Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_IN,
-                                          DataINEndpoint->EndpointAddress, DataINEndpoint->EndpointSize,
-                                          SIInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
+                       Size            = DataINEndpoint->EndpointSize;
+                       EndpointAddress = DataINEndpoint->EndpointAddress;
+                       Token           = PIPE_TOKEN_IN;
+                       Type            = EP_TYPE_BULK;
+                       DoubleBanked    = SIInterfaceInfo->Config.DataINPipeDoubleBank;
+                       InterruptPeriod = 0;
 
                        SIInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
                }
                else if (PipeNum == SIInterfaceInfo->Config.DataOUTPipeNumber)
                {
 
                        SIInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
                }
                else if (PipeNum == SIInterfaceInfo->Config.DataOUTPipeNumber)
                {
-                       Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_OUT,
-                                          DataOUTEndpoint->EndpointAddress, DataOUTEndpoint->EndpointSize,
-                                          SIInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
+                       Size            = DataOUTEndpoint->EndpointSize;
+                       EndpointAddress = DataOUTEndpoint->EndpointAddress;
+                       Token           = PIPE_TOKEN_OUT;
+                       Type            = EP_TYPE_BULK;
+                       DoubleBanked    = SIInterfaceInfo->Config.DataOUTPipeDoubleBank;
+                       InterruptPeriod = 0;
 
                        SIInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
                }
                else if (PipeNum == SIInterfaceInfo->Config.EventsPipeNumber)
                {
 
                        SIInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
                }
                else if (PipeNum == SIInterfaceInfo->Config.EventsPipeNumber)
                {
-                       Pipe_ConfigurePipe(PipeNum, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
-                                          EventsEndpoint->EndpointAddress, EventsEndpoint->EndpointSize,
-                                          SIInterfaceInfo->Config.EventsPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
-                       Pipe_SetInterruptPeriod(EventsEndpoint->PollingIntervalMS);
+                       Size            = EventsEndpoint->EndpointSize;
+                       EndpointAddress = EventsEndpoint->EndpointAddress;
+                       Token           = PIPE_TOKEN_IN;
+                       Type            = EP_TYPE_INTERRUPT;
+                       DoubleBanked    = SIInterfaceInfo->Config.EventsPipeDoubleBank;
+                       InterruptPeriod = EventsEndpoint->PollingIntervalMS;
 
                        SIInterfaceInfo->State.EventsPipeSize = EventsEndpoint->EndpointSize;
                }
 
                        SIInterfaceInfo->State.EventsPipeSize = EventsEndpoint->EndpointSize;
                }
+               else
+               {
+                       continue;
+               }
+               
+               if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
+                                        DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
+               {
+                       return SI_ENUMERROR_PipeConfigurationFailed;
+               }
+               
+               if (InterruptPeriod)
+                 Pipe_SetInterruptPeriod(InterruptPeriod);
        }
 
        SIInterfaceInfo->State.InterfaceNumber = StillImageInterface->InterfaceNumber;
        }
 
        SIInterfaceInfo->State.InterfaceNumber = StillImageInterface->InterfaceNumber;
@@ -123,14 +152,15 @@ uint8_t SI_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 
 uint8_t DCOMP_SI_Host_NextSIInterface(void* const CurrentDescriptor)
 {
 
 uint8_t DCOMP_SI_Host_NextSIInterface(void* const CurrentDescriptor)
 {
-       if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
+       USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
+
+       if (Header->Type == DTYPE_Interface)
        {
        {
-               USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
-                                                                               USB_Descriptor_Interface_t);
+               USB_Descriptor_Interface_t* Interface = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Interface_t);
 
 
-               if ((CurrentInterface->Class    == STILL_IMAGE_CLASS)    &&
-                   (CurrentInterface->SubClass == STILL_IMAGE_SUBCLASS) &&
-                   (CurrentInterface->Protocol == STILL_IMAGE_PROTOCOL))
+               if ((Interface->Class    == SI_CSCP_StillImageClass)    &&
+                   (Interface->SubClass == SI_CSCP_StillImageSubclass) &&
+                   (Interface->Protocol == SI_CSCP_BulkOnlyProtocol))
                {
                        return DESCRIPTOR_SEARCH_Found;
                }
                {
                        return DESCRIPTOR_SEARCH_Found;
                }
@@ -141,20 +171,21 @@ uint8_t DCOMP_SI_Host_NextSIInterface(void* const CurrentDescriptor)
 
 uint8_t DCOMP_SI_Host_NextSIInterfaceEndpoint(void* const CurrentDescriptor)
 {
 
 uint8_t DCOMP_SI_Host_NextSIInterfaceEndpoint(void* const CurrentDescriptor)
 {
-       if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
+       USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
+
+       if (Header->Type == DTYPE_Endpoint)
        {
        {
-               USB_Descriptor_Endpoint_t* CurrentEndpoint = DESCRIPTOR_PCAST(CurrentDescriptor,
-                                                                             USB_Descriptor_Endpoint_t);
+               USB_Descriptor_Endpoint_t* Endpoint = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Endpoint_t);
 
 
-               uint8_t EndpointType = (CurrentEndpoint->Attributes & EP_TYPE_MASK);
+               uint8_t EndpointType = (Endpoint->Attributes & EP_TYPE_MASK);
 
                if (((EndpointType == EP_TYPE_BULK) || (EndpointType == EP_TYPE_INTERRUPT)) &&
 
                if (((EndpointType == EP_TYPE_BULK) || (EndpointType == EP_TYPE_INTERRUPT)) &&
-                   (!(Pipe_IsEndpointBound(CurrentEndpoint->EndpointAddress))))
+                   (!(Pipe_IsEndpointBound(Endpoint->EndpointAddress))))
                {
                        return DESCRIPTOR_SEARCH_Found;
                }
        }
                {
                        return DESCRIPTOR_SEARCH_Found;
                }
        }
-       else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
+       else if (Header->Type == DTYPE_Interface)
        {
                return DESCRIPTOR_SEARCH_Fail;
        }
        {
                return DESCRIPTOR_SEARCH_Fail;
        }
@@ -163,7 +194,7 @@ uint8_t DCOMP_SI_Host_NextSIInterfaceEndpoint(void* const CurrentDescriptor)
 }
 
 uint8_t SI_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 }
 
 uint8_t SI_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
-                                SI_PIMA_Container_t* const PIMAHeader)
+                                PIMA_Container_t* const PIMAHeader)
 {
        uint8_t ErrorCode;
 
 {
        uint8_t ErrorCode;
 
@@ -171,19 +202,19 @@ uint8_t SI_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
          return PIPE_RWSTREAM_DeviceDisconnected;
 
        if (SIInterfaceInfo->State.IsSessionOpen)
          return PIPE_RWSTREAM_DeviceDisconnected;
 
        if (SIInterfaceInfo->State.IsSessionOpen)
-         PIMAHeader->TransactionID = SIInterfaceInfo->State.TransactionID++;
+         PIMAHeader->TransactionID = cpu_to_le32(SIInterfaceInfo->State.TransactionID++);
 
        Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
        Pipe_Unfreeze();
 
 
        Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
        Pipe_Unfreeze();
 
-       if ((ErrorCode = Pipe_Write_Stream_LE(PIMAHeader, PIMA_COMMAND_SIZE(0), NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
+       if ((ErrorCode = Pipe_Write_Stream_LE(PIMAHeader, PIMA_COMMAND_SIZE(0), NULL)) != PIPE_RWSTREAM_NoError)
          return ErrorCode;
 
        uint8_t ParamBytes = (PIMAHeader->DataLength - PIMA_COMMAND_SIZE(0));
 
        if (ParamBytes)
        {
          return ErrorCode;
 
        uint8_t ParamBytes = (PIMAHeader->DataLength - PIMA_COMMAND_SIZE(0));
 
        if (ParamBytes)
        {
-               if ((ErrorCode = Pipe_Write_Stream_LE(&PIMAHeader->Params, ParamBytes, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
+               if ((ErrorCode = Pipe_Write_Stream_LE(&PIMAHeader->Params, ParamBytes, NULL)) != PIPE_RWSTREAM_NoError)
                  return ErrorCode;
        }
 
                  return ErrorCode;
        }
 
@@ -194,9 +225,9 @@ uint8_t SI_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 }
 
 uint8_t SI_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 }
 
 uint8_t SI_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
-                                   SI_PIMA_Container_t* const PIMAHeader)
+                                   PIMA_Container_t* const PIMAHeader)
 {
 {
-       uint16_t TimeoutMSRem        = COMMAND_DATA_TIMEOUT_MS;
+       uint16_t TimeoutMSRem        = SI_COMMAND_DATA_TIMEOUT_MS;
        uint16_t PreviousFrameNumber = USB_Host_GetFrameNumber();
 
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
        uint16_t PreviousFrameNumber = USB_Host_GetFrameNumber();
 
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
@@ -241,14 +272,14 @@ uint8_t SI_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInf
                  return PIPE_RWSTREAM_DeviceDisconnected;
        }
 
                  return PIPE_RWSTREAM_DeviceDisconnected;
        }
 
-       Pipe_Read_Stream_LE(PIMAHeader, PIMA_COMMAND_SIZE(0), NO_STREAM_CALLBACK);
+       Pipe_Read_Stream_LE(PIMAHeader, PIMA_COMMAND_SIZE(0), NULL);
 
 
-       if (PIMAHeader->Type == SI_PIMA_CONTAINER_ResponseBlock)
+       if (PIMAHeader->Type == CPU_TO_LE16(PIMA_CONTAINER_ResponseBlock))
        {
                uint8_t ParamBytes = (PIMAHeader->DataLength - PIMA_COMMAND_SIZE(0));
 
                if (ParamBytes)
        {
                uint8_t ParamBytes = (PIMAHeader->DataLength - PIMA_COMMAND_SIZE(0));
 
                if (ParamBytes)
-                 Pipe_Read_Stream_LE(&PIMAHeader->Params, ParamBytes, NO_STREAM_CALLBACK);
+                 Pipe_Read_Stream_LE(&PIMAHeader->Params, ParamBytes, NULL);
 
                Pipe_ClearIN();
        }
 
                Pipe_ClearIN();
        }
@@ -270,7 +301,7 @@ uint8_t SI_Host_SendData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
        Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
        Pipe_Unfreeze();
 
        Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
        Pipe_Unfreeze();
 
-       ErrorCode = Pipe_Write_Stream_LE(Buffer, Bytes, NO_STREAM_CALLBACK);
+       ErrorCode = Pipe_Write_Stream_LE(Buffer, Bytes, NULL);
 
        Pipe_ClearOUT();
        Pipe_Freeze();
 
        Pipe_ClearOUT();
        Pipe_Freeze();
@@ -290,7 +321,7 @@ uint8_t SI_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
        Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
        Pipe_Unfreeze();
 
        Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
        Pipe_Unfreeze();
 
-       ErrorCode = Pipe_Read_Stream_LE(Buffer, Bytes, NO_STREAM_CALLBACK);
+       ErrorCode = Pipe_Read_Stream_LE(Buffer, Bytes, NULL);
 
        Pipe_Freeze();
 
 
        Pipe_Freeze();
 
@@ -316,7 +347,7 @@ bool SI_Host_IsEventReceived(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 }
 
 uint8_t SI_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 }
 
 uint8_t SI_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
-                                   SI_PIMA_Container_t* const PIMAHeader)
+                                   PIMA_Container_t* const PIMAHeader)
 {
        uint8_t ErrorCode;
 
 {
        uint8_t ErrorCode;
 
@@ -326,7 +357,7 @@ uint8_t SI_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInf
        Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
        Pipe_Unfreeze();
 
        Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
        Pipe_Unfreeze();
 
-       ErrorCode = Pipe_Read_Stream_LE(PIMAHeader, sizeof(SI_PIMA_Container_t), NO_STREAM_CALLBACK);
+       ErrorCode = Pipe_Read_Stream_LE(PIMAHeader, sizeof(PIMA_Container_t), NULL);
 
        Pipe_ClearIN();
        Pipe_Freeze();
 
        Pipe_ClearIN();
        Pipe_Freeze();
@@ -337,19 +368,19 @@ uint8_t SI_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInf
 uint8_t SI_Host_OpenSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 {
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 uint8_t SI_Host_OpenSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 {
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
-         return HOST_SENDCONTROL_DeviceDisconnected;
+         return PIPE_RWSTREAM_DeviceDisconnected;
 
        uint8_t ErrorCode;
 
        SIInterfaceInfo->State.TransactionID = 0;
        SIInterfaceInfo->State.IsSessionOpen = false;
 
 
        uint8_t ErrorCode;
 
        SIInterfaceInfo->State.TransactionID = 0;
        SIInterfaceInfo->State.IsSessionOpen = false;
 
-       SI_PIMA_Container_t PIMABlock = (SI_PIMA_Container_t)
+       PIMA_Container_t PIMABlock = (PIMA_Container_t)
                {
                {
-                       .DataLength    = PIMA_COMMAND_SIZE(1),
-                       .Type          = SI_PIMA_CONTAINER_CommandBlock,
-                       .Code          = 0x1002,
-                       .Params        = {1},
+                       .DataLength    = CPU_TO_LE32(PIMA_COMMAND_SIZE(1)),
+                       .Type          = CPU_TO_LE16(PIMA_CONTAINER_CommandBlock),
+                       .Code          = CPU_TO_LE16(0x1002),
+                       .Params        = {CPU_TO_LE32(1)},
                };
 
        if ((ErrorCode = SI_Host_SendBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
                };
 
        if ((ErrorCode = SI_Host_SendBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
@@ -358,7 +389,7 @@ uint8_t SI_Host_OpenSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
        if ((ErrorCode = SI_Host_ReceiveBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
          return ErrorCode;
 
        if ((ErrorCode = SI_Host_ReceiveBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
          return ErrorCode;
 
-       if ((PIMABlock.Type != SI_PIMA_CONTAINER_ResponseBlock) || (PIMABlock.Code != 0x2001))
+       if ((PIMABlock.Type != CPU_TO_LE16(PIMA_CONTAINER_ResponseBlock)) || (PIMABlock.Code != CPU_TO_LE16(0x2001)))
          return SI_ERROR_LOGICAL_CMD_FAILED;
 
        SIInterfaceInfo->State.IsSessionOpen = true;
          return SI_ERROR_LOGICAL_CMD_FAILED;
 
        SIInterfaceInfo->State.IsSessionOpen = true;
@@ -369,16 +400,16 @@ uint8_t SI_Host_OpenSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 uint8_t SI_Host_CloseSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 {
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 uint8_t SI_Host_CloseSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 {
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
-         return HOST_SENDCONTROL_DeviceDisconnected;
+         return PIPE_RWSTREAM_DeviceDisconnected;
 
        uint8_t ErrorCode;
 
 
        uint8_t ErrorCode;
 
-       SI_PIMA_Container_t PIMABlock = (SI_PIMA_Container_t)
+       PIMA_Container_t PIMABlock = (PIMA_Container_t)
                {
                {
-                       .DataLength    = PIMA_COMMAND_SIZE(1),
-                       .Type          = SI_PIMA_CONTAINER_CommandBlock,
-                       .Code          = 0x1003,
-                       .Params        = {1},
+                       .DataLength    = CPU_TO_LE32(PIMA_COMMAND_SIZE(1)),
+                       .Type          = CPU_TO_LE16(PIMA_CONTAINER_CommandBlock),
+                       .Code          = CPU_TO_LE16(0x1003),
+                       .Params        = {CPU_TO_LE32(1)},
                };
 
        if ((ErrorCode = SI_Host_SendBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
                };
 
        if ((ErrorCode = SI_Host_SendBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
@@ -389,7 +420,7 @@ uint8_t SI_Host_CloseSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 
        SIInterfaceInfo->State.IsSessionOpen = false;
 
 
        SIInterfaceInfo->State.IsSessionOpen = false;
 
-       if ((PIMABlock.Type != SI_PIMA_CONTAINER_ResponseBlock) || (PIMABlock.Code != 0x2001))
+       if ((PIMABlock.Type != CPU_TO_LE16(PIMA_CONTAINER_ResponseBlock)) || (PIMABlock.Code != CPU_TO_LE16(0x2001)))
          return SI_ERROR_LOGICAL_CMD_FAILED;
 
        return PIPE_RWSTREAM_NoError;
          return SI_ERROR_LOGICAL_CMD_FAILED;
 
        return PIPE_RWSTREAM_NoError;
@@ -401,15 +432,15 @@ uint8_t SI_Host_SendCommand(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
                             uint32_t* const Params)
 {
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
                             uint32_t* const Params)
 {
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
-         return HOST_SENDCONTROL_DeviceDisconnected;
+         return PIPE_RWSTREAM_DeviceDisconnected;
 
        uint8_t ErrorCode;
 
 
        uint8_t ErrorCode;
 
-       SI_PIMA_Container_t PIMABlock = (SI_PIMA_Container_t)
+       PIMA_Container_t PIMABlock = (PIMA_Container_t)
                {
                {
-                       .DataLength    = PIMA_COMMAND_SIZE(TotalParams),
-                       .Type          = SI_PIMA_CONTAINER_CommandBlock,
-                       .Code          = Operation,
+                       .DataLength    = cpu_to_le32(PIMA_COMMAND_SIZE(TotalParams)),
+                       .Type          = CPU_TO_LE16(PIMA_CONTAINER_CommandBlock),
+                       .Code          = cpu_to_le16(Operation),
                };
 
        memcpy(&PIMABlock.Params, Params, sizeof(uint32_t) * TotalParams);
                };
 
        memcpy(&PIMABlock.Params, Params, sizeof(uint32_t) * TotalParams);
@@ -423,15 +454,15 @@ uint8_t SI_Host_SendCommand(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
 uint8_t SI_Host_ReceiveResponse(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 {
        uint8_t ErrorCode;
 uint8_t SI_Host_ReceiveResponse(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 {
        uint8_t ErrorCode;
-       SI_PIMA_Container_t PIMABlock;
+       PIMA_Container_t PIMABlock;
 
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 
        if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
-         return HOST_SENDCONTROL_DeviceDisconnected;
+         return PIPE_RWSTREAM_DeviceDisconnected;
 
        if ((ErrorCode = SI_Host_ReceiveBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
          return ErrorCode;
 
 
        if ((ErrorCode = SI_Host_ReceiveBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
          return ErrorCode;
 
-       if ((PIMABlock.Type != SI_PIMA_CONTAINER_ResponseBlock) || (PIMABlock.Code != 0x2001))
+       if ((PIMABlock.Type != CPU_TO_LE16(PIMA_CONTAINER_ResponseBlock)) || (PIMABlock.Code != CPU_TO_LE16(0x2001)))
          return SI_ERROR_LOGICAL_CMD_FAILED;
 
        return PIPE_RWSTREAM_NoError;
          return SI_ERROR_LOGICAL_CMD_FAILED;
 
        return PIPE_RWSTREAM_NoError;
USB isp AVR programmer