LUFA/Drivers/USB/Core/AVR8/Pipe_AVR8.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2012.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2012  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all 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 "../../../../Common/Common.h"
  32 #if (ARCH == ARCH_AVR8)
  33
  34 #define  __INCLUDE_FROM_USB_DRIVER
  35 #include "../USBMode.h"
  36
  37 #if defined(USB_CAN_BE_HOST)
  38
  39 #include "../Pipe.h"
  40
  41 uint8_t USB_Host_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE;
  42
  43 bool Pipe_ConfigurePipeTable(const USB_Pipe_Table_t* const Table,
  44                              const uint8_t Entries)
  45 {
  46         for (uint8_t i = 0; i < Entries; i++)
  47         {
  48                 if (!(Table[i].Address))
  49                   continue;
  50
  51                 if (!(Pipe_ConfigurePipe(Table[i].Address, Table[i].Type, Table[i].EndpointAddress, Table[i].Size, Table[i].Banks)))
  52                 {
  53                         return false;
  54                 }
  55         }
  56
  57         return true;
  58 }
  59
  60 bool Pipe_ConfigurePipe(const uint8_t Address,
  61                         const uint8_t Type,
  62                         const uint8_t EndpointAddress,
  63                         const uint16_t Size,
  64                         const uint8_t Banks)
  65 {
  66         uint8_t Number = (Address & PIPE_EPNUM_MASK);
  67         uint8_t Token  = (Address & PIPE_DIR_IN) ? PIPE_TOKEN_IN : PIPE_TOKEN_OUT;
  68
  69         if (Type == EP_TYPE_CONTROL)
  70           Token = PIPE_TOKEN_SETUP;
  71
  72 #if defined(ORDERED_EP_CONFIG)
  73         Pipe_SelectPipe(Number);
  74         Pipe_EnablePipe();
  75
  76         UPCFG1X = 0;
  77
  78         UPCFG0X = ((Type << EPTYPE0) | Token | ((EndpointAddress & PIPE_EPNUM_MASK) << PEPNUM0));
  79         UPCFG1X = ((1 << ALLOC) | ((Banks > 1) ? (1 << EPBK0) : 0) | Pipe_BytesToEPSizeMask(Size));
  80
  81         Pipe_SetInfiniteINRequests();
  82
  83         return Pipe_IsConfigured();
  84 #else
  85         for (uint8_t PNum = Number; PNum < PIPE_TOTAL_PIPES; PNum++)
  86         {
  87                 uint8_t UPCFG0XTemp;
  88                 uint8_t UPCFG1XTemp;
  89                 uint8_t UPCFG2XTemp;
  90                 uint8_t UPIENXTemp;
  91
  92                 Pipe_SelectPipe(PNum);
  93
  94                 if (PNum == Number)
  95                 {
  96                         UPCFG0XTemp = ((Type << EPTYPE0) | Token | ((EndpointAddress & PIPE_EPNUM_MASK) << PEPNUM0));
  97                         UPCFG1XTemp = ((1 << ALLOC) | Banks | Pipe_BytesToEPSizeMask(Size));
  98                         UPCFG2XTemp = 0;
  99                         UPIENXTemp  = 0;
 100                 }
 101                 else
 102                 {
 103                         UPCFG0XTemp = UPCFG0X;
 104                         UPCFG1XTemp = UPCFG1X;
 105                         UPCFG2XTemp = UPCFG2X;
 106                         UPIENXTemp  = UPIENX;
 107                 }
 108
 109                 if (!(UPCFG1XTemp & (1 << ALLOC)))
 110                   continue;
 111
 112                 Pipe_DisablePipe();
 113                 UPCFG1X &= ~(1 << ALLOC);
 114
 115                 Pipe_EnablePipe();
 116                 UPCFG0X = UPCFG0XTemp;
 117                 UPCFG1X = UPCFG1XTemp;
 118                 UPCFG2X = UPCFG2XTemp;
 119                 UPIENX  = UPIENXTemp;
 120
 121                 Pipe_SetInfiniteINRequests();
 122
 123                 if (!(Pipe_IsConfigured()))
 124                   return false;
 125         }
 126
 127         Pipe_SelectPipe(Number);
 128         return true;
 129 #endif
 130 }
 131
 132 void Pipe_ClearPipes(void)
 133 {
 134         UPINT = 0;
 135
 136         for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)
 137         {
 138                 Pipe_SelectPipe(PNum);
 139                 UPIENX  = 0;
 140                 UPINTX  = 0;
 141                 UPCFG1X = 0;
 142                 Pipe_DisablePipe();
 143         }
 144 }
 145
 146 bool Pipe_IsEndpointBound(const uint8_t EndpointAddress)
 147 {
 148         uint8_t PrevPipeNumber = Pipe_GetCurrentPipe();
 149
 150         for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)
 151         {
 152                 Pipe_SelectPipe(PNum);
 153
 154                 if (!(Pipe_IsConfigured()))
 155                   continue;
 156
 157                 if (Pipe_GetBoundEndpointAddress() == EndpointAddress)
 158                   return true;
 159         }
 160
 161         Pipe_SelectPipe(PrevPipeNumber);
 162         return false;
 163 }
 164
 165 uint8_t Pipe_WaitUntilReady(void)
 166 {
 167         #if (USB_STREAM_TIMEOUT_MS < 0xFF)
 168         uint8_t  TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
 169         #else
 170         uint16_t TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
 171         #endif
 172
 173         uint16_t PreviousFrameNumber = USB_Host_GetFrameNumber();
 174
 175         for (;;)
 176         {
 177                 if (Pipe_GetPipeToken() == PIPE_TOKEN_IN)
 178                 {
 179                         if (Pipe_IsINReceived())
 180                           return PIPE_READYWAIT_NoError;
 181                 }
 182                 else
 183                 {
 184                         if (Pipe_IsOUTReady())
 185                           return PIPE_READYWAIT_NoError;
 186                 }
 187
 188                 if (Pipe_IsStalled())
 189                   return PIPE_READYWAIT_PipeStalled;
 190                 else if (USB_HostState == HOST_STATE_Unattached)
 191                   return PIPE_READYWAIT_DeviceDisconnected;
 192
 193                 uint16_t CurrentFrameNumber = USB_Host_GetFrameNumber();
 194
 195                 if (CurrentFrameNumber != PreviousFrameNumber)
 196                 {
 197                         PreviousFrameNumber = CurrentFrameNumber;
 198
 199                         if (!(TimeoutMSRem--))
 200                           return PIPE_READYWAIT_Timeout;
 201                 }
 202         }
 203 }
 204
 205 #endif
 206
 207 #endif