flight/pios/stm32f10x/pios_usb_hid.c

   1 /**
   2  ******************************************************************************
   3  * @addtogroup PIOS PIOS Core hardware abstraction layer
   4  * @{
   5  * @addtogroup   PIOS_USB_HID USB COM Functions
   6  * @brief PIOS USB COM implementation for HID interfaces
   7  * @notes      This implements serial emulation over HID reports
   8  * @{
   9  *
  10  * @file       pios_usb_hid.c
  11  * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
  12  * @brief      USB COM functions (STM32 dependent code)
  13  * @see        The GNU Public License (GPL) Version 3
  14  *
  15  *****************************************************************************/
  16 /*
  17  * This program is free software; you can redistribute it and/or modify
  18  * it under the terms of the GNU General Public License as published by
  19  * the Free Software Foundation; either version 3 of the License, or
  20  * (at your option) any later version.
  21  *
  22  * This program is distributed in the hope that it will be useful, but
  23  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  24  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  25  * for more details.
  26  *
  27  * You should have received a copy of the GNU General Public License along
  28  * with this program; if not, write to the Free Software Foundation, Inc.,
  29  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  30  */
  31
  32 #include "pios.h"
  33
  34 #ifdef PIOS_INCLUDE_USB_HID
  35
  36 #include "pios_usb_hid_priv.h"
  37 #include "pios_usb_board_data.h" /* PIOS_BOARD_*_DATA_LENGTH */
  38
  39 /* STM32 USB Library Definitions */
  40 #include "usb_lib.h"
  41
  42 static void PIOS_USB_HID_RegisterTxCallback(uint32_t usbhid_id, pios_com_callback tx_out_cb, uint32_t context);
  43 static void PIOS_USB_HID_RegisterRxCallback(uint32_t usbhid_id, pios_com_callback rx_in_cb, uint32_t context);
  44 static void PIOS_USB_HID_TxStart(uint32_t usbhid_id, uint16_t tx_bytes_avail);
  45 static void PIOS_USB_HID_RxStart(uint32_t usbhid_id, uint16_t rx_bytes_avail);
  46 static uint32_t PIOS_USB_HID_Available(uint32_t usbhid_id);
  47
  48 const struct pios_com_driver pios_usb_hid_com_driver = {
  49     .tx_start   = PIOS_USB_HID_TxStart,
  50     .rx_start   = PIOS_USB_HID_RxStart,
  51     .bind_tx_cb = PIOS_USB_HID_RegisterTxCallback,
  52     .bind_rx_cb = PIOS_USB_HID_RegisterRxCallback,
  53     .available  = PIOS_USB_HID_Available,
  54 };
  55
  56 enum pios_usb_hid_dev_magic {
  57     PIOS_USB_HID_DEV_MAGIC = 0xAA00BB00,
  58 };
  59
  60 struct pios_usb_hid_dev {
  61     enum pios_usb_hid_dev_magic   magic;
  62     const struct pios_usb_hid_cfg *cfg;
  63
  64     uint32_t lower_id;
  65
  66     pios_com_callback rx_in_cb;
  67     uint32_t rx_in_context;
  68     pios_com_callback tx_out_cb;
  69     uint32_t tx_out_context;
  70
  71     uint8_t  rx_packet_buffer[PIOS_USB_BOARD_HID_DATA_LENGTH];
  72     uint8_t  tx_packet_buffer[PIOS_USB_BOARD_HID_DATA_LENGTH];
  73
  74     uint32_t rx_dropped;
  75     uint32_t rx_oversize;
  76 };
  77
  78 static bool PIOS_USB_HID_validate(struct pios_usb_hid_dev *usb_hid_dev)
  79 {
  80     return usb_hid_dev->magic == PIOS_USB_HID_DEV_MAGIC;
  81 }
  82
  83 #ifdef PIOS_INCLUDE_FREERTOS
  84 static struct pios_usb_hid_dev *PIOS_USB_HID_alloc(void)
  85 {
  86     struct pios_usb_hid_dev *usb_hid_dev;
  87
  88     usb_hid_dev = (struct pios_usb_hid_dev *)pios_malloc(sizeof(struct pios_usb_hid_dev));
  89     if (!usb_hid_dev) {
  90         return NULL;
  91     }
  92
  93     memset(usb_hid_dev, 0, sizeof(struct pios_usb_hid_dev));
  94     usb_hid_dev->magic = PIOS_USB_HID_DEV_MAGIC;
  95     return usb_hid_dev;
  96 }
  97 #else
  98 static struct pios_usb_hid_dev pios_usb_hid_devs[PIOS_USB_HID_MAX_DEVS];
  99 static uint8_t pios_usb_hid_num_devs;
 100 static struct pios_usb_hid_dev *PIOS_USB_HID_alloc(void)
 101 {
 102     struct pios_usb_hid_dev *usb_hid_dev;
 103
 104     if (pios_usb_hid_num_devs >= PIOS_USB_HID_MAX_DEVS) {
 105         return NULL;
 106     }
 107
 108     usb_hid_dev = &pios_usb_hid_devs[pios_usb_hid_num_devs++];
 109
 110     memset(usb_hid_dev, 0, sizeof(struct pios_usb_hid_dev));
 111     usb_hid_dev->magic = PIOS_USB_HID_DEV_MAGIC;
 112
 113     return usb_hid_dev;
 114 }
 115 #endif /* ifdef PIOS_INCLUDE_FREERTOS */
 116
 117 static void PIOS_USB_HID_EP_IN_Callback(void);
 118 static void PIOS_USB_HID_EP_OUT_Callback(void);
 119
 120 static uint32_t pios_usb_hid_id;
 121
 122 /* Need a better way to pull these in */
 123 extern void(*pEpInt_IN[7]) (void);
 124 extern void(*pEpInt_OUT[7]) (void);
 125
 126 int32_t PIOS_USB_HID_Init(uint32_t *usbhid_id, const struct pios_usb_hid_cfg *cfg, uint32_t lower_id)
 127 {
 128     PIOS_Assert(usbhid_id);
 129     PIOS_Assert(cfg);
 130
 131     struct pios_usb_hid_dev *usb_hid_dev;
 132
 133     usb_hid_dev = (struct pios_usb_hid_dev *)PIOS_USB_HID_alloc();
 134     if (!usb_hid_dev) {
 135         goto out_fail;
 136     }
 137
 138     /* Bind the configuration to the device instance */
 139     usb_hid_dev->cfg = cfg;
 140     usb_hid_dev->lower_id = lower_id;
 141
 142     pios_usb_hid_id  = (uint32_t)usb_hid_dev;
 143
 144     /* Bind lower level callbacks into the USB infrastructure */
 145     pEpInt_IN[cfg->data_tx_ep - 1]  = PIOS_USB_HID_EP_IN_Callback;
 146     pEpInt_OUT[cfg->data_rx_ep - 1] = PIOS_USB_HID_EP_OUT_Callback;
 147
 148     *usbhid_id = (uint32_t)usb_hid_dev;
 149
 150     return 0;
 151
 152 out_fail:
 153     return -1;
 154 }
 155
 156
 157 static void PIOS_USB_HID_SendReport(struct pios_usb_hid_dev *usb_hid_dev)
 158 {
 159     uint16_t bytes_to_tx;
 160
 161     if (!usb_hid_dev->tx_out_cb) {
 162         return;
 163     }
 164
 165     bool need_yield = false;
 166 #ifdef PIOS_USB_BOARD_BL_HID_HAS_NO_LENGTH_BYTE
 167     bytes_to_tx = (usb_hid_dev->tx_out_cb)(usb_hid_dev->tx_out_context,
 168                                            &usb_hid_dev->tx_packet_buffer[1],
 169                                            sizeof(usb_hid_dev->tx_packet_buffer) - 1,
 170                                            NULL,
 171                                            &need_yield);
 172 #else
 173     bytes_to_tx = (usb_hid_dev->tx_out_cb)(usb_hid_dev->tx_out_context,
 174                                            &usb_hid_dev->tx_packet_buffer[2],
 175                                            sizeof(usb_hid_dev->tx_packet_buffer) - 2,
 176                                            NULL,
 177                                            &need_yield);
 178 #endif
 179     if (bytes_to_tx == 0) {
 180         return;
 181     }
 182
 183     /* Always set type as report ID */
 184     usb_hid_dev->tx_packet_buffer[0] = 1;
 185
 186 #ifdef PIOS_USB_BOARD_BL_HID_HAS_NO_LENGTH_BYTE
 187     UserToPMABufferCopy(usb_hid_dev->tx_packet_buffer,
 188                         GetEPTxAddr(usb_hid_dev->cfg->data_tx_ep),
 189                         bytes_to_tx + 1);
 190 #else
 191     usb_hid_dev->tx_packet_buffer[1] = bytes_to_tx;
 192     UserToPMABufferCopy(usb_hid_dev->tx_packet_buffer,
 193                         GetEPTxAddr(usb_hid_dev->cfg->data_tx_ep),
 194                         bytes_to_tx + 2);
 195 #endif
 196     /* Is this correct?  Why do we always send the whole buffer? */
 197     SetEPTxCount(usb_hid_dev->cfg->data_tx_ep, sizeof(usb_hid_dev->tx_packet_buffer));
 198     SetEPTxValid(usb_hid_dev->cfg->data_tx_ep);
 199
 200 #ifdef PIOS_INCLUDE_FREERTOS
 201     if (need_yield) {
 202         vPortYield();
 203     }
 204 #endif /* PIOS_INCLUDE_FREERTOS */
 205 }
 206
 207 static void PIOS_USB_HID_RxStart(uint32_t usbhid_id, uint16_t rx_bytes_avail)
 208 {
 209     struct pios_usb_hid_dev *usb_hid_dev = (struct pios_usb_hid_dev *)usbhid_id;
 210
 211     bool valid = PIOS_USB_HID_validate(usb_hid_dev);
 212
 213     PIOS_Assert(valid);
 214
 215     if (!PIOS_USB_CheckAvailable(usb_hid_dev->lower_id)) {
 216         return;
 217     }
 218
 219     // If endpoint was stalled and there is now space make it valid
 220 #ifdef PIOS_USB_BOARD_BL_HID_HAS_NO_LENGTH_BYTE
 221     uint16_t max_payload_length = PIOS_USB_BOARD_HID_DATA_LENGTH - 1;
 222 #else
 223     uint16_t max_payload_length = PIOS_USB_BOARD_HID_DATA_LENGTH - 2;
 224 #endif
 225
 226     PIOS_IRQ_Disable();
 227     if ((GetEPRxStatus(usb_hid_dev->cfg->data_rx_ep) != EP_RX_VALID) &&
 228         (rx_bytes_avail >= max_payload_length)) {
 229         SetEPRxStatus(usb_hid_dev->cfg->data_rx_ep, EP_RX_VALID);
 230     }
 231     PIOS_IRQ_Enable();
 232 }
 233
 234 static void PIOS_USB_HID_TxStart(uint32_t usbhid_id, __attribute__((unused)) uint16_t tx_bytes_avail)
 235 {
 236     struct pios_usb_hid_dev *usb_hid_dev = (struct pios_usb_hid_dev *)usbhid_id;
 237
 238     bool valid = PIOS_USB_HID_validate(usb_hid_dev);
 239
 240     PIOS_Assert(valid);
 241
 242     if (!PIOS_USB_CheckAvailable(usb_hid_dev->lower_id)) {
 243         return;
 244     }
 245
 246     if (GetEPTxStatus(usb_hid_dev->cfg->data_tx_ep) == EP_TX_VALID) {
 247         /* Endpoint is already transmitting */
 248         return;
 249     }
 250
 251     PIOS_USB_HID_SendReport(usb_hid_dev);
 252 }
 253
 254 static void PIOS_USB_HID_RegisterRxCallback(uint32_t usbhid_id, pios_com_callback rx_in_cb, uint32_t context)
 255 {
 256     struct pios_usb_hid_dev *usb_hid_dev = (struct pios_usb_hid_dev *)usbhid_id;
 257
 258     bool valid = PIOS_USB_HID_validate(usb_hid_dev);
 259
 260     PIOS_Assert(valid);
 261
 262     /*
 263      * Order is important in these assignments since ISR uses _cb
 264      * field to determine if it's ok to dereference _cb and _context
 265      */
 266     usb_hid_dev->rx_in_context = context;
 267     usb_hid_dev->rx_in_cb = rx_in_cb;
 268 }
 269
 270 static void PIOS_USB_HID_RegisterTxCallback(uint32_t usbhid_id, pios_com_callback tx_out_cb, uint32_t context)
 271 {
 272     struct pios_usb_hid_dev *usb_hid_dev = (struct pios_usb_hid_dev *)usbhid_id;
 273
 274     bool valid = PIOS_USB_HID_validate(usb_hid_dev);
 275
 276     PIOS_Assert(valid);
 277
 278     /*
 279      * Order is important in these assignments since ISR uses _cb
 280      * field to determine if it's ok to dereference _cb and _context
 281      */
 282     usb_hid_dev->tx_out_context = context;
 283     usb_hid_dev->tx_out_cb = tx_out_cb;
 284 }
 285
 286 /**
 287  * @brief Callback used to indicate a transmission from device INto host completed
 288  * Checks if any data remains, pads it into HID packet and sends.
 289  */
 290 static void PIOS_USB_HID_EP_IN_Callback(void)
 291 {
 292     struct pios_usb_hid_dev *usb_hid_dev = (struct pios_usb_hid_dev *)pios_usb_hid_id;
 293
 294     bool valid = PIOS_USB_HID_validate(usb_hid_dev);
 295
 296     PIOS_Assert(valid);
 297
 298     if (!PIOS_USB_CheckAvailable(usb_hid_dev->lower_id)) {
 299         return;
 300     }
 301
 302     PIOS_USB_HID_SendReport(usb_hid_dev);
 303 }
 304
 305 /**
 306  * EP1 OUT Callback Routine
 307  */
 308 static void PIOS_USB_HID_EP_OUT_Callback(void)
 309 {
 310     struct pios_usb_hid_dev *usb_hid_dev = (struct pios_usb_hid_dev *)pios_usb_hid_id;
 311
 312     bool valid = PIOS_USB_HID_validate(usb_hid_dev);
 313
 314     PIOS_Assert(valid);
 315
 316     uint32_t DataLength;
 317
 318     /* Read received data (63 bytes) */
 319     /* Get the number of received data on the selected Endpoint */
 320     DataLength = GetEPRxCount(usb_hid_dev->cfg->data_rx_ep);
 321     if (DataLength > sizeof(usb_hid_dev->rx_packet_buffer)) {
 322         DataLength = sizeof(usb_hid_dev->rx_packet_buffer);
 323     }
 324
 325     /* Use the memory interface function to read from the selected endpoint */
 326     PMAToUserBufferCopy((uint8_t *)usb_hid_dev->rx_packet_buffer,
 327                         GetEPRxAddr(usb_hid_dev->cfg->data_rx_ep),
 328                         DataLength);
 329
 330     if (!usb_hid_dev->rx_in_cb) {
 331         /* No Rx call back registered, disable the receiver */
 332         SetEPRxStatus(usb_hid_dev->cfg->data_rx_ep, EP_RX_NAK);
 333         return;
 334     }
 335
 336     /* The first byte is report ID (not checked), the second byte is the valid data length */
 337     uint16_t headroom;
 338     bool need_yield = false;
 339 #ifdef PIOS_USB_BOARD_BL_HID_HAS_NO_LENGTH_BYTE
 340     (usb_hid_dev->rx_in_cb)(usb_hid_dev->rx_in_context,
 341                             &usb_hid_dev->rx_packet_buffer[1],
 342                             sizeof(usb_hid_dev->rx_packet_buffer) - 1,
 343                             &headroom,
 344                             &need_yield);
 345 #else
 346     (usb_hid_dev->rx_in_cb)(usb_hid_dev->rx_in_context,
 347                             &usb_hid_dev->rx_packet_buffer[2],
 348                             usb_hid_dev->rx_packet_buffer[1],
 349                             &headroom,
 350                             &need_yield);
 351 #endif
 352
 353 #ifdef PIOS_USB_BOARD_BL_HID_HAS_NO_LENGTH_BYTE
 354     uint16_t max_payload_length = PIOS_USB_BOARD_HID_DATA_LENGTH - 1;
 355 #else
 356     uint16_t max_payload_length = PIOS_USB_BOARD_HID_DATA_LENGTH - 2;
 357 #endif
 358
 359     if (headroom >= max_payload_length) {
 360         /* We have room for a maximum length message */
 361         SetEPRxStatus(usb_hid_dev->cfg->data_rx_ep, EP_RX_VALID);
 362     } else {
 363         /* Not enough room left for a message, apply backpressure */
 364         SetEPRxStatus(usb_hid_dev->cfg->data_rx_ep, EP_RX_NAK);
 365     }
 366
 367 #ifdef PIOS_INCLUDE_FREERTOS
 368     if (need_yield) {
 369         vPortYield();
 370     }
 371 #endif /* PIOS_INCLUDE_FREERTOS */
 372 }
 373
 374 static uint32_t PIOS_USB_HID_Available(uint32_t usbhid_id)
 375 {
 376     return PIOS_USB_CheckAvailable(usbhid_id) ? COM_AVAILABLE_RXTX : COM_AVAILABLE_NONE;
 377 }
 378
 379 #endif /* PIOS_INCLUDE_USB_HID */