LUFA/Drivers/USB/Core/UC3/Pipe_UC3.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_UC3)
  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 volatile uint32_t USB_Pipe_SelectedPipe = PIPE_CONTROLPIPE;
  44 volatile uint8_t* USB_Pipe_FIFOPos[PIPE_TOTAL_PIPES];
  45
  46 bool Pipe_ConfigurePipeTable(const USB_Pipe_Table_t* const Table,
  47                              const uint8_t Entries)
  48 {
  49         for (uint8_t i = 0; i < Entries; i++)
  50         {
  51                 if (!(Table[i].Address))
  52                   continue;
  53
  54                 if (!(Pipe_ConfigurePipe(Table[i].Address, Table[i].Type, Table[i].EndpointAddress, Table[i].Size, Table[i].Banks)))
  55                 {
  56                         return false;
  57                 }
  58         }
  59
  60         return true;
  61 }
  62
  63 bool Pipe_ConfigurePipe(const uint8_t Address,
  64                         const uint8_t Type,
  65                         const uint8_t EndpointAddress,
  66                         const uint16_t Size,
  67                         const uint8_t Banks)
  68 {
  69         uint8_t Number = (Address & PIPE_EPNUM_MASK);
  70         uint8_t Token  = (Address & PIPE_DIR_IN) ? PIPE_TOKEN_IN : PIPE_TOKEN_OUT;
  71
  72         if (Type == EP_TYPE_CONTROL)
  73           Token = PIPE_TOKEN_SETUP;
  74
  75         USB_Pipe_FIFOPos[Number]     = &AVR32_USBB_SLAVE[Number * 0x10000];
  76
  77 #if defined(ORDERED_EP_CONFIG)
  78         Pipe_SelectPipe(Number);
  79         Pipe_EnablePipe();
  80
  81         (&AVR32_USBB.upcfg0)[Number] = 0;
  82         (&AVR32_USBB.upcfg0)[Number] = (AVR32_USBB_ALLOC_MASK |
  83                                         ((uint32_t)Type  << AVR32_USBB_PTYPE_OFFSET)  |
  84                                         ((uint32_t)Token << AVR32_USBB_PTOKEN_OFFSET) |
  85                                         ((Banks > 1) ? AVR32_USBB_PBK_MASK : 0)       |
  86                                         Pipe_BytesToEPSizeMask(Size) |
  87                                         ((EndpointNumber & PIPE_EPNUM_MASK) << AVR32_USBB_PEPNUM_OFFSET));
  88
  89         Pipe_SetInfiniteINRequests();
  90
  91         return Pipe_IsConfigured();
  92 #else
  93         for (uint8_t PNum = Number; PNum < PIPE_TOTAL_PIPES; PNum++)
  94         {
  95                 uint32_t UPCFG0Temp;
  96
  97                 Pipe_SelectPipe(PNum);
  98
  99                 if (PNum == Number)
 100                 {
 101                         UPCFG0Temp = (AVR32_USBB_ALLOC_MASK |
 102                                       ((uint32_t)Type  << AVR32_USBB_PTYPE_OFFSET)  |
 103                                       ((uint32_t)Token << AVR32_USBB_PTOKEN_OFFSET) |
 104                                       ((Banks > 1) ? AVR32_USBB_PBK_MASK : 0)       |
 105                                       Pipe_BytesToEPSizeMask(Size) |
 106                                       ((EndpointAddress & PIPE_EPNUM_MASK) << AVR32_USBB_PEPNUM_OFFSET));
 107                 }
 108                 else
 109                 {
 110                         UPCFG0Temp = (&AVR32_USBB.upcfg0)[PNum];
 111                 }
 112
 113                 if (!(UPCFG0Temp & AVR32_USBB_ALLOC_MASK))
 114                   continue;
 115
 116                 Pipe_DisablePipe();
 117                 (&AVR32_USBB.upcfg0)[PNum] &= ~AVR32_USBB_ALLOC_MASK;
 118
 119                 Pipe_EnablePipe();
 120                 (&AVR32_USBB.upcfg0)[PNum] = UPCFG0Temp;
 121
 122                 Pipe_SetInfiniteINRequests();
 123
 124                 if (!(Pipe_IsConfigured()))
 125                   return false;
 126         }
 127
 128         Pipe_SelectPipe(Number);
 129         return true;
 130 #endif
 131 }
 132
 133 void Pipe_ClearPipes(void)
 134 {
 135         for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)
 136         {
 137                 Pipe_SelectPipe(PNum);
 138                 (&AVR32_USBB.upcfg0)[PNum]    = 0;
 139                 (&AVR32_USBB.upcon0clr)[PNum] = -1;
 140                 USB_Pipe_FIFOPos[PNum]        = &AVR32_USBB_SLAVE[PNum * 0x10000];
 141                 Pipe_DisablePipe();
 142         }
 143 }
 144
 145 bool Pipe_IsEndpointBound(const uint8_t EndpointAddress)
 146 {
 147         uint8_t PrevPipeNumber = Pipe_GetCurrentPipe();
 148
 149         for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)
 150         {
 151                 Pipe_SelectPipe(PNum);
 152
 153                 if (!(Pipe_IsConfigured()))
 154                   continue;
 155
 156                 if (Pipe_GetBoundEndpointAddress() == EndpointAddress)
 157                   return true;
 158         }
 159
 160         Pipe_SelectPipe(PrevPipeNumber);
 161         return false;
 162 }
 163
 164 uint8_t Pipe_WaitUntilReady(void)
 165 {
 166         #if (USB_STREAM_TIMEOUT_MS < 0xFF)
 167         uint8_t  TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
 168         #else
 169         uint16_t TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
 170         #endif
 171
 172         uint16_t PreviousFrameNumber = USB_Host_GetFrameNumber();
 173
 174         for (;;)
 175         {
 176                 if (Pipe_GetPipeToken() == PIPE_TOKEN_IN)
 177                 {
 178                         if (Pipe_IsINReceived())
 179                           return PIPE_READYWAIT_NoError;
 180                 }
 181                 else
 182                 {
 183                         if (Pipe_IsOUTReady())
 184                           return PIPE_READYWAIT_NoError;
 185                 }
 186
 187                 if (Pipe_IsStalled())
 188                   return PIPE_READYWAIT_PipeStalled;
 189                 else if (USB_HostState == HOST_STATE_Unattached)
 190                   return PIPE_READYWAIT_DeviceDisconnected;
 191
 192                 uint16_t CurrentFrameNumber = USB_Host_GetFrameNumber();
 193
 194                 if (CurrentFrameNumber != PreviousFrameNumber)
 195                 {
 196                         PreviousFrameNumber = CurrentFrameNumber;
 197
 198                         if (!(TimeoutMSRem--))
 199                           return PIPE_READYWAIT_Timeout;
 200                 }
 201         }
 202 }
 203
 204 #endif
 205
 206 #endif