src/main/drivers/timer_common.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "platform.h"
  22
  23 #ifdef USE_TIMER
  24
  25 #include "drivers/dshot_bitbang.h"
  26 #include "drivers/io.h"
  27 #include "timer.h"
  28
  29 #ifdef USE_TIMER_MGMT
  30 #include "pg/timerio.h"
  31
  32 const resourceOwner_t freeOwner = { .owner = OWNER_FREE, .resourceIndex = 0 };
  33
  34 static resourceOwner_t timerOwners[MAX_TIMER_PINMAP_COUNT];
  35
  36 timerIOConfig_t *timerIoConfigByTag(ioTag_t ioTag)
  37 {
  38     for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
  39         if (timerIOConfig(i)->ioTag == ioTag) {
  40             return timerIOConfigMutable(i);
  41         }
  42     }
  43
  44     return NULL;
  45 }
  46
  47 const timerHardware_t *timerGetByTagAndIndex(ioTag_t ioTag, unsigned timerIndex)
  48 {
  49
  50     if (!ioTag || !timerIndex) {
  51         return NULL;
  52     }
  53
  54     uint8_t index = 1;
  55     for (unsigned i = 0; i < TIMER_CHANNEL_COUNT; i++) {
  56         if (TIMER_HARDWARE[i].tag == ioTag) {
  57             if (index == timerIndex) {
  58                 return &TIMER_HARDWARE[i];
  59             }
  60             ++index;
  61         }
  62     }
  63
  64     return NULL;
  65 }
  66
  67 const timerHardware_t *timerGetConfiguredByTag(ioTag_t ioTag)
  68 {
  69     uint8_t timerIndex = 0;
  70     for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
  71         if (timerIOConfig(i)->ioTag == ioTag) {
  72             timerIndex = timerIOConfig(i)->index;
  73
  74             break;
  75         }
  76     }
  77
  78     return timerGetByTagAndIndex(ioTag, timerIndex);
  79 }
  80
  81 const timerHardware_t *timerGetAllocatedByNumberAndChannel(int8_t timerNumber, uint16_t timerChannel)
  82 {
  83     for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
  84         const timerHardware_t *timer = timerGetByTagAndIndex(timerIOConfig(i)->ioTag, timerIOConfig(i)->index);
  85         if (timer && timerGetTIMNumber(timer->tim) == timerNumber && timer->channel == timerChannel && timerOwners[i].owner) {
  86             return timer;
  87         }
  88     }
  89
  90 #if defined(USE_DSHOT_BITBANG)
  91     return dshotBitbangTimerGetAllocatedByNumberAndChannel(timerNumber, timerChannel);
  92 #else
  93     return NULL;
  94 #endif
  95 }
  96
  97 const resourceOwner_t *timerGetOwner(const timerHardware_t *timer)
  98 {
  99     for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
 100         const timerHardware_t *assignedTimer = timerGetByTagAndIndex(timerIOConfig(i)->ioTag, timerIOConfig(i)->index);
 101         if (assignedTimer && assignedTimer == timer) {
 102             return &timerOwners[i];
 103         }
 104     }
 105
 106 #if defined(USE_DSHOT_BITBANG)
 107     return dshotBitbangTimerGetOwner(timer);
 108 #else
 109     return &freeOwner;
 110 #endif
 111 }
 112
 113 const timerHardware_t *timerAllocate(ioTag_t ioTag, resourceOwner_e owner, uint8_t resourceIndex)
 114 {
 115     if (!ioTag) {
 116         return NULL;
 117     }
 118
 119     for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
 120         if (timerIOConfig(i)->ioTag == ioTag) {
 121             const timerHardware_t *timer = timerGetByTagAndIndex(ioTag, timerIOConfig(i)->index);
 122
 123             if (timerGetOwner(timer)->owner) {
 124                 return NULL;
 125             }
 126
 127             timerOwners[i].owner = owner;
 128             timerOwners[i].resourceIndex = resourceIndex;
 129
 130             return timer;
 131         }
 132     }
 133
 134     return NULL;
 135 }
 136 #else
 137
 138 const timerHardware_t *timerGetConfiguredByTag(ioTag_t ioTag)
 139 {
 140 #if TIMER_CHANNEL_COUNT > 0
 141     for (unsigned i = 0; i < TIMER_CHANNEL_COUNT; i++) {
 142         if (TIMER_HARDWARE[i].tag == ioTag) {
 143             return &TIMER_HARDWARE[i];
 144         }
 145     }
 146 #else
 147     UNUSED(ioTag);
 148 #endif
 149     return NULL;
 150 }
 151
 152 const timerHardware_t *timerAllocate(ioTag_t ioTag, resourceOwner_e owner, uint8_t resourceIndex)
 153 {
 154     UNUSED(owner);
 155     UNUSED(resourceIndex);
 156
 157     return timerGetConfiguredByTag(ioTag);
 158 }
 159 #endif
 160
 161 ioTag_t timerioTagGetByUsage(timerUsageFlag_e usageFlag, uint8_t index)
 162 {
 163 #if USABLE_TIMER_CHANNEL_COUNT > 0
 164     uint8_t currentIndex = 0;
 165     for (unsigned i = 0; i < USABLE_TIMER_CHANNEL_COUNT; i++) {
 166         if ((timerHardware[i].usageFlags & usageFlag) == usageFlag) {
 167             if (currentIndex == index) {
 168                 return timerHardware[i].tag;
 169             }
 170             currentIndex++;
 171         }
 172     }
 173 #else
 174     UNUSED(usageFlag);
 175     UNUSED(index);
 176 #endif
 177     return IO_TAG_NONE;
 178 }
 179 #endif