flight/pios/stm32f30x/pios_usb.c

   1 /**
   2  ******************************************************************************
   3  * @addtogroup PIOS PIOS Core hardware abstraction layer
   4  * @{
   5  * @addtogroup   PIOS_USB USB Setup Functions
   6  * @brief PIOS USB device implementation
   7  * @{
   8  *
   9  * @file       pios_usb.c
  10  * @author     The LibrePilot Project, http://www.librepilot.org (C) 2017.
  11  *             Tau Labs, http://taulabs.org, Copyright (C) 2012-2013
  12  *             The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
  13  * @brief      USB device functions (STM32 dependent code)
  14  * @see        The GNU Public License (GPL) Version 3
  15  *
  16  *****************************************************************************/
  17 /*
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License as published by
  20  * the Free Software Foundation; either version 3 of the License, or
  21  * (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful, but
  24  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  25  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  26  * for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License along
  29  * with this program; if not, write to the Free Software Foundation, Inc.,
  30  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  31  */
  32
  33 /* Project Includes */
  34 #include "pios.h"
  35
  36 #if defined(PIOS_INCLUDE_USB)
  37
  38 #include "usb_lib.h"
  39 #include "pios_usb_board_data.h"
  40
  41 #include "pios_usb.h"
  42 #include "pios_usb_priv.h"
  43
  44
  45 /* Rx/Tx status */
  46 static bool transfer_possible = false;
  47
  48 #ifdef PIOS_INCLUDE_FREERTOS
  49 struct {
  50     void     (*callback)(bool connected, uint32_t context);
  51     uint32_t context;
  52 } connectionState_cb_list[3];
  53 #endif
  54
  55 /* USB activity detection */
  56 static volatile bool sof_seen_since_reset = false;
  57
  58 enum pios_usb_dev_magic {
  59     PIOS_USB_DEV_MAGIC = 0x17365904,
  60 };
  61
  62 struct pios_usb_dev {
  63     enum pios_usb_dev_magic   magic;
  64     const struct pios_usb_cfg *cfg;
  65 };
  66 #ifdef PIOS_INCLUDE_FREERTOS
  67 static void raiseConnectionStateCallback(bool connected);
  68 #endif
  69
  70 /**
  71  * @brief Validate the usb device structure
  72  * @returns 0 if valid device or -1 otherwise
  73  */
  74 static int32_t PIOS_USB_validate(struct pios_usb_dev *usb_dev)
  75 {
  76     if (usb_dev == NULL) {
  77         return -1;
  78     }
  79
  80     if (usb_dev->magic != PIOS_USB_DEV_MAGIC) {
  81         return -1;
  82     }
  83
  84     return 0;
  85 }
  86
  87 #ifdef PIOS_INCLUDE_FREERTOS
  88 static struct pios_usb_dev *PIOS_USB_alloc(void)
  89 {
  90     struct pios_usb_dev *usb_dev;
  91
  92     usb_dev = (struct pios_usb_dev *)pios_malloc(sizeof(*usb_dev));
  93     if (!usb_dev) {
  94         return NULL;
  95     }
  96
  97     usb_dev->magic = PIOS_USB_DEV_MAGIC;
  98     return usb_dev;
  99 }
 100 #else
 101 static struct pios_usb_dev pios_usb_devs[PIOS_USB_MAX_DEVS];
 102 static uint8_t pios_usb_num_devs;
 103 static struct pios_usb_dev *PIOS_USB_alloc(void)
 104 {
 105     struct pios_usb_dev *usb_dev;
 106
 107     if (pios_usb_num_devs >= PIOS_USB_MAX_DEVS) {
 108         return NULL;
 109     }
 110
 111     usb_dev = &pios_usb_devs[pios_usb_num_devs++];
 112     usb_dev->magic = PIOS_USB_DEV_MAGIC;
 113
 114     return usb_dev;
 115 }
 116 #endif /* ifdef PIOS_INCLUDE_FREERTOS */
 117
 118 /**
 119  * Initialises USB COM layer
 120  * \return < 0 if initialisation failed
 121  * \note Applications shouldn't call this function directly, instead please use \ref PIOS_COM layer functions
 122  */
 123 static uint32_t pios_usb_com_id;
 124 int32_t PIOS_USB_Init(uint32_t *usb_id, const struct pios_usb_cfg *cfg)
 125 {
 126     PIOS_Assert(usb_id);
 127     PIOS_Assert(cfg);
 128
 129     struct pios_usb_dev *usb_dev;
 130
 131     usb_dev = (struct pios_usb_dev *)PIOS_USB_alloc();
 132     if (!usb_dev) {
 133         goto out_fail;
 134     }
 135
 136     /* Bind the configuration to the device instance */
 137     usb_dev->cfg = cfg;
 138
 139     PIOS_USB_Reenumerate();
 140
 141     /*
 142      * This is a horrible hack to make this available to
 143      * the interrupt callbacks.  This should go away ASAP.
 144      */
 145     pios_usb_com_id = (uintptr_t)usb_dev;
 146
 147     /* Enable the USB Interrupts */
 148     NVIC_Init((NVIC_InitTypeDef *)&usb_dev->cfg->irq.init);
 149
 150     /* Configure USB D-/D+ (DM/DP) pins */
 151     GPIO_InitTypeDef GPIO_InitStructure;
 152     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_11 | GPIO_Pin_12;
 153     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 154     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF;
 155     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
 156     GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
 157     GPIO_Init(GPIOA, &GPIO_InitStructure);
 158
 159     GPIO_PinAFConfig(GPIOA, GPIO_PinSource11, GPIO_AF_14);
 160     GPIO_PinAFConfig(GPIOA, GPIO_PinSource12, GPIO_AF_14);
 161
 162     /* Configure VBUS sense pin */
 163     if (usb_dev->cfg->vsense.gpio) {
 164         GPIO_Init(usb_dev->cfg->vsense.gpio, (GPIO_InitTypeDef *)&usb_dev->cfg->vsense.init);
 165     }
 166
 167     /* Select USBCLK source */
 168     RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_1Div5);
 169     /* Enable the USB clock */
 170     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USB, ENABLE);
 171
 172     USB_Init();
 173     USB_SIL_Init();
 174
 175     *usb_id = (uintptr_t)usb_dev;
 176
 177     return 0; /* No error */
 178
 179 out_fail:
 180     return -1;
 181 }
 182
 183 /**
 184  * This function is called by the USB driver on cable connection/disconnection
 185  * \param[in] connected connection status (1 if connected)
 186  * \return < 0 on errors
 187  * \note Applications shouldn't call this function directly, instead please use \ref PIOS_COM layer functions
 188  */
 189 int32_t PIOS_USB_ChangeConnectionState(bool Connected)
 190 {
 191     // In all cases: re-initialise USB HID driver
 192     if (Connected) {
 193         transfer_possible = true;
 194
 195         // TODO: Check SetEPRxValid(ENDP1);
 196
 197 #if defined(USB_LED_ON)
 198         USB_LED_ON; // turn the USB led on
 199 #endif
 200     } else {
 201         // Cable disconnected: disable transfers
 202         transfer_possible = false;
 203
 204 #if defined(USB_LED_OFF)
 205         USB_LED_OFF; // turn the USB led off
 206 #endif
 207     }
 208
 209 #ifdef PIOS_INCLUDE_FREERTOS
 210     raiseConnectionStateCallback(Connected);
 211 #endif
 212
 213     return 0;
 214 }
 215
 216 int32_t PIOS_USB_Reenumerate()
 217 {
 218     /* Force USB reset and power-down (this will also release the USB pins for direct GPIO control) */
 219     _SetCNTR(CNTR_FRES | CNTR_PDWN);
 220
 221     /* Using a "dirty" method to force a re-enumeration: */
 222     /* Force DPM (Pin PA12) low for ca. 10 mS before USB Tranceiver will be enabled */
 223     /* This overrules the external Pull-Up at PA12, and at least Windows & MacOS will enumerate again */
 224     GPIO_InitTypeDef GPIO_InitStructure;
 225     GPIO_StructInit(&GPIO_InitStructure);
 226     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_12;
 227     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_OUT;
 228     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
 229     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 230     GPIO_Init(GPIOA, &GPIO_InitStructure);
 231
 232     PIOS_DELAY_WaitmS(50);
 233
 234     /* Release power-down, still hold reset */
 235     _SetCNTR(CNTR_PDWN);
 236     PIOS_DELAY_WaituS(5);
 237
 238     /* CNTR_FRES = 0 */
 239     _SetCNTR(0);
 240
 241     /* Clear pending interrupts */
 242     _SetISTR(0);
 243
 244     /* set back to alternate function */
 245     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
 246     GPIO_Init(GPIOA, &GPIO_InitStructure);
 247
 248     /* Configure USB clock */
 249     /* USBCLK = PLLCLK / 1.5 */
 250     RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_1Div5);
 251     /* Enable USB clock */
 252     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USB, ENABLE);
 253
 254     return 0;
 255 }
 256
 257 bool PIOS_USB_CableConnected(__attribute__((unused)) uint8_t id)
 258 {
 259     struct pios_usb_dev *usb_dev = (struct pios_usb_dev *)pios_usb_com_id;
 260
 261     if (PIOS_USB_validate(usb_dev) != 0) {
 262         return false;
 263     }
 264
 265     // If board is configured to have a VSENSE pin, use that
 266     if (usb_dev->cfg->vsense.gpio != NULL) {
 267         return GPIO_ReadInputDataBit(usb_dev->cfg->vsense.gpio, usb_dev->cfg->vsense.init.GPIO_Pin) == Bit_SET;
 268     }
 269
 270     return sof_seen_since_reset;
 271 }
 272
 273 /**
 274  * This function returns the connection status of the USB HID interface
 275  * \return 1: interface available
 276  * \return 0: interface not available
 277  * \note Applications shouldn't call this function directly, instead please use \ref PIOS_COM layer functions
 278  */
 279 bool PIOS_USB_CheckAvailable(uint32_t id)
 280 {
 281     struct pios_usb_dev *usb_dev = (struct pios_usb_dev *)pios_usb_com_id;
 282
 283     if (PIOS_USB_validate(usb_dev) != 0) {
 284         return false;
 285     }
 286
 287     return PIOS_USB_CableConnected(id) && transfer_possible;
 288 }
 289
 290 void SOF_Callback(void)
 291 {
 292     sof_seen_since_reset = true;
 293 }
 294
 295 void SUSP_Callback(void)
 296 {
 297     sof_seen_since_reset = false;
 298 }
 299
 300 #ifdef PIOS_INCLUDE_FREERTOS
 301 void PIOS_USB_RegisterConnectionStateCallback(void (*connectionStateCallback)(bool connected, uint32_t context), uint32_t context)
 302 {
 303     PIOS_Assert(connectionStateCallback);
 304
 305     for (uint32_t i = 0; i < NELEMENTS(connectionState_cb_list); i++) {
 306         if (connectionState_cb_list[i].callback == NULL) {
 307             connectionState_cb_list[i].callback = connectionStateCallback;
 308             connectionState_cb_list[i].context  = context;
 309             return;
 310         }
 311     }
 312
 313     PIOS_Assert(0);
 314 }
 315
 316 static void raiseConnectionStateCallback(bool connected)
 317 {
 318     uint32_t i = 0;
 319
 320     while (i < NELEMENTS(connectionState_cb_list) && connectionState_cb_list[i].callback != NULL) {
 321         connectionState_cb_list[i].callback(connected, connectionState_cb_list[i].context);
 322         i++;
 323     }
 324 }
 325 #else /* PIOS_INCLUDE_FREERTOS */
 326 void PIOS_USB_RegisterConnectionStateCallback(__attribute__((unused)) void (*connectionStateCallback)(bool connected, uint32_t context), __attribute__((unused)) uint32_t context)
 327 {}
 328 #endif /* PIOS_INCLUDE_FREERTOS */
 329
 330 #endif /* if defined(PIOS_INCLUDE_USB) */
 331
 332 /**
 333  * @}
 334  * @}
 335  */