Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.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  *  Still Image Device commands, to issue PIMA commands to the device for
  34  *  reading device status, capacity, and other characteristics as well as
  35  *  reading and writing of stored image data.
  36  */
  37
  38 #include "StillImageCommands.h"
  39
  40 /* Globals: */
  41 /** PIMA block container for the block to send to the device */
  42 PIMA_Container_t PIMA_SendBlock;
  43
  44 /** PIMA block container for the last received block from the device */
  45 PIMA_Container_t PIMA_ReceivedBlock;
  46
  47 /** PIMA block container for the last event block received from the device */
  48 PIMA_Container_t PIMA_EventBlock;
  49
  50
  51 /** Function to send the PIMA command container to the attached still image device. */
  52 void SImage_SendBlockHeader(void)
  53 {
  54         /* Unfreeze the data OUT pipe ready for data transmission */
  55         Pipe_SelectPipe(SIMAGE_DATA_OUT_PIPE);
  56         Pipe_Unfreeze();
  57
  58         /* Write the PIMA block to the data OUT pipe */
  59         Pipe_Write_Stream_LE(&PIMA_SendBlock, PIMA_COMMAND_SIZE(0));
  60
  61         /* If the block type is a command, send its parameters (if any) */
  62         if (PIMA_SendBlock.Type == CType_CommandBlock)
  63         {
  64                 /* Determine the size of the parameters in the block via the data length attribute */
  65                 uint8_t ParamBytes = (PIMA_SendBlock.DataLength - PIMA_COMMAND_SIZE(0));
  66
  67                 /* Check if any parameters in the command block */
  68                 if (ParamBytes)
  69                 {
  70                         /* Write the PIMA parameters to the data OUT pipe */
  71                         Pipe_Write_Stream_LE(&PIMA_SendBlock.Params, ParamBytes);
  72                 }
  73
  74                 /* Send the PIMA command block to the attached device */
  75                 Pipe_ClearOUT();
  76         }
  77
  78         /* Freeze pipe after use */
  79         Pipe_Freeze();
  80 }
  81
  82 /** Function to receive a PIMA event container from the attached still image device. */
  83 uint8_t SImage_ReceiveEventHeader(void)
  84 {
  85         uint8_t ErrorCode;
  86
  87         /* Unfreeze the events pipe */
  88         Pipe_SelectPipe(SIMAGE_EVENTS_PIPE);
  89         Pipe_Unfreeze();
  90
  91         /* Read in the event data into the global structure */
  92         ErrorCode = Pipe_Read_Stream_LE(&PIMA_EventBlock, sizeof(PIMA_EventBlock));
  93
  94         /* Clear the pipe after read complete to prepare for next event */
  95         Pipe_ClearIN();
  96
  97         /* Freeze the event pipe again after use */
  98         Pipe_Freeze();
  99
 100         return ErrorCode;
 101 }
 102
 103 /** Function to receive a PIMA response container from the attached still image device. */
 104 uint8_t SImage_ReceiveBlockHeader(void)
 105 {
 106         uint16_t TimeoutMSRem = COMMAND_DATA_TIMEOUT_MS;
 107
 108         /* Unfreeze the data IN pipe */
 109         Pipe_SelectPipe(SIMAGE_DATA_IN_PIPE);
 110         Pipe_Unfreeze();
 111
 112         /* Wait until data received on the IN pipe */
 113         while (!(Pipe_IsReadWriteAllowed()))
 114         {
 115                 /* Check to see if a new frame has been issued (1ms elapsed) */
 116                 if (USB_INT_HasOccurred(USB_INT_HSOFI))
 117                 {
 118                         /* Clear the flag and decrement the timeout period counter */
 119                         USB_INT_Clear(USB_INT_HSOFI);
 120                         TimeoutMSRem--;
 121
 122                         /* Check to see if the timeout period for the command has elapsed */
 123                         if (!(TimeoutMSRem))
 124                         {
 125                                 /* Return error code */
 126                                 return PIPE_RWSTREAM_Timeout;
 127                         }
 128                 }
 129
 130                 Pipe_Freeze();
 131                 Pipe_SelectPipe(SIMAGE_DATA_OUT_PIPE);
 132                 Pipe_Unfreeze();
 133
 134                 /* Check if pipe stalled (command failed by device) */
 135                 if (Pipe_IsStalled())
 136                 {
 137                         /* Clear the stall condition on the OUT pipe */
 138                         USB_Host_ClearPipeStall(SIMAGE_DATA_OUT_PIPE);
 139
 140                         /* Return error code and break out of the loop */
 141                         return PIPE_RWSTREAM_PipeStalled;
 142                 }
 143
 144                 Pipe_Freeze();
 145                 Pipe_SelectPipe(SIMAGE_DATA_IN_PIPE);
 146                 Pipe_Unfreeze();
 147
 148                 /* Check if pipe stalled (command failed by device) */
 149                 if (Pipe_IsStalled())
 150                 {
 151                         /* Clear the stall condition on the IN pipe */
 152                         USB_Host_ClearPipeStall(SIMAGE_DATA_IN_PIPE);
 153
 154                         /* Return error code */
 155                         return PIPE_RWSTREAM_PipeStalled;
 156                 }
 157
 158                 /* Check to see if the device was disconnected, if so exit function */
 159                 if (USB_HostState == HOST_STATE_Unattached)
 160                   return PIPE_RWSTREAM_DeviceDisconnected;
 161         }
 162
 163         /* Load in the response from the attached device */
 164         Pipe_Read_Stream_LE(&PIMA_ReceivedBlock, PIMA_COMMAND_SIZE(0));
 165
 166         /* Check if the returned block type is a response block */
 167         if (PIMA_ReceivedBlock.Type == CType_ResponseBlock)
 168         {
 169                 /* Determine the size of the parameters in the block via the data length attribute */
 170                 uint8_t ParamBytes = (PIMA_ReceivedBlock.DataLength - PIMA_COMMAND_SIZE(0));
 171
 172                 /* Check if the device has returned any parameters */
 173                 if (ParamBytes)
 174                 {
 175                         /* Read the PIMA parameters from the data IN pipe */
 176                         Pipe_Read_Stream_LE(&PIMA_ReceivedBlock.Params, ParamBytes);
 177                 }
 178
 179                 /* Clear pipe bank after use */
 180                 Pipe_ClearIN();
 181         }
 182
 183         /* Freeze the IN pipe after use */
 184         Pipe_Freeze();
 185
 186         return PIPE_RWSTREAM_NoError;
 187 }
 188
 189 /** Function to send the given data to the device, after a command block has been issued.
 190  *
 191  *  \param[in] Buffer  Source data buffer to send to the device
 192  *  \param[in] Bytes   Number of bytes to send
 193  */
 194 uint8_t SImage_SendData(void* Buffer, uint16_t Bytes)
 195 {
 196         uint8_t ErrorCode;
 197
 198         /* Unfreeze the data OUT pipe */
 199         Pipe_SelectPipe(SIMAGE_DATA_OUT_PIPE);
 200         Pipe_Unfreeze();
 201
 202         /* Write the data contents to the pipe */
 203         ErrorCode = Pipe_Write_Stream_LE(Buffer, Bytes);
 204
 205         /* Send the last packet to the attached device */
 206         Pipe_ClearOUT();
 207
 208         /* Freeze the pipe again after use */
 209         Pipe_Freeze();
 210
 211         return ErrorCode;
 212 }
 213
 214 /** Function to receive the given data to the device, after a response block has been received.
 215  *
 216  *  \param[out] Buffer  Destination data buffer to put read bytes from the device
 217  *  \param[in] Bytes    Number of bytes to receive
 218  *
 219  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 220  */
 221 uint8_t SImage_ReadData(void* Buffer, uint16_t Bytes)
 222 {
 223         uint8_t ErrorCode;
 224
 225         /* Unfreeze the data IN pipe */
 226         Pipe_SelectPipe(SIMAGE_DATA_IN_PIPE);
 227         Pipe_Unfreeze();
 228
 229         /* Read in the data into the buffer */
 230         ErrorCode = Pipe_Read_Stream_LE(Buffer, Bytes);
 231
 232         /* Freeze the pipe again after use */
 233         Pipe_Freeze();
 234
 235         return ErrorCode;
 236 }
 237
 238 /** Function to test if a PIMA event block is waiting to be read in from the attached device.
 239  *
 240  *  \return True if an event is waiting to be read in from the device, false otherwise
 241  */
 242 bool SImage_IsEventReceived(void)
 243 {
 244         bool IsEventReceived = false;
 245
 246         /* Unfreeze the Event pipe */
 247         Pipe_SelectPipe(SIMAGE_EVENTS_PIPE);
 248         Pipe_Unfreeze();
 249
 250         /* If the pipe contains data, an event has been received */
 251         if (Pipe_BytesInPipe())
 252           IsEventReceived = true;
 253
 254         /* Freeze the pipe after use */
 255         Pipe_Freeze();
 256
 257         return IsEventReceived;
 258 }