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 static uint8_t timerIndexByTag(ioTag_t ioTag)
  48 {
  49     for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
  50         if (timerIOConfig(i)->ioTag == ioTag) {
  51             return timerIOConfig(i)->index;
  52         }
  53     }
  54     return 0;
  55 }
  56
  57 const timerHardware_t *timerGetByTagAndIndex(ioTag_t ioTag, unsigned timerIndex)
  58 {
  59
  60     if (!ioTag || !timerIndex) {
  61         return NULL;
  62     }
  63
  64     uint8_t index = 1;
  65     for (unsigned i = 0; i < TIMER_CHANNEL_COUNT; i++) {
  66         if (TIMER_HARDWARE[i].tag == ioTag) {
  67             if (index == timerIndex) {
  68                 return &TIMER_HARDWARE[i];
  69             }
  70             ++index;
  71         }
  72     }
  73
  74     return NULL;
  75 }
  76
  77 const timerHardware_t *timerGetByTag(ioTag_t ioTag)
  78 {
  79     uint8_t timerIndex = timerIndexByTag(ioTag);
  80
  81     return timerGetByTagAndIndex(ioTag, timerIndex);
  82 }
  83
  84 const resourceOwner_t *timerGetOwner(int8_t timerNumber, uint16_t timerChannel)
  85 {
  86     const resourceOwner_t *timerOwner = &freeOwner;
  87     for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
  88         const timerHardware_t *timer = timerGetByTagAndIndex(timerIOConfig(i)->ioTag, timerIOConfig(i)->index);
  89         if (timer && timerGetTIMNumber(timer->tim) == timerNumber && timer->channel == timerChannel) {
  90             timerOwner = &timerOwners[i];
  91
  92             break;
  93         }
  94     }
  95
  96 #if defined(USE_DSHOT_BITBANG)
  97     if (!timerOwner->owner) {
  98         timerOwner = dshotBitbangTimerGetOwner(timerNumber, timerChannel);
  99     }
 100 #endif
 101
 102     return timerOwner;
 103 }
 104
 105 const timerHardware_t *timerAllocate(ioTag_t ioTag, resourceOwner_e owner, uint8_t resourceIndex)
 106 {
 107     if (!ioTag) {
 108         return NULL;
 109     }
 110
 111     for (unsigned i = 0; i < MAX_TIMER_PINMAP_COUNT; i++) {
 112         if (timerIOConfig(i)->ioTag == ioTag) {
 113             const timerHardware_t *timer = timerGetByTagAndIndex(ioTag, timerIOConfig(i)->index);
 114
 115             if (timerGetOwner(timerGetTIMNumber(timer->tim), timer->channel)->owner) {
 116                 return NULL;
 117             }
 118
 119             timerOwners[i].owner = owner;
 120             timerOwners[i].resourceIndex = resourceIndex;
 121
 122             return timer;
 123         }
 124     }
 125
 126     return NULL;
 127 }
 128 #else
 129
 130 const timerHardware_t *timerGetByTag(ioTag_t ioTag)
 131 {
 132 #if TIMER_CHANNEL_COUNT > 0
 133     for (unsigned i = 0; i < TIMER_CHANNEL_COUNT; i++) {
 134         if (TIMER_HARDWARE[i].tag == ioTag) {
 135             return &TIMER_HARDWARE[i];
 136         }
 137     }
 138 #else
 139     UNUSED(ioTag);
 140 #endif
 141     return NULL;
 142 }
 143
 144 const timerHardware_t *timerAllocate(ioTag_t ioTag, resourceOwner_e owner, uint8_t resourceIndex)
 145 {
 146     UNUSED(owner);
 147     UNUSED(resourceIndex);
 148
 149     return timerGetByTag(ioTag);
 150 }
 151 #endif
 152
 153 ioTag_t timerioTagGetByUsage(timerUsageFlag_e usageFlag, uint8_t index)
 154 {
 155 #if !defined(USE_UNIFIED_TARGET) && USABLE_TIMER_CHANNEL_COUNT > 0
 156     uint8_t currentIndex = 0;
 157     for (unsigned i = 0; i < USABLE_TIMER_CHANNEL_COUNT; i++) {
 158         if ((timerHardware[i].usageFlags & usageFlag) == usageFlag) {
 159             if (currentIndex == index) {
 160                 return timerHardware[i].tag;
 161             }
 162             currentIndex++;
 163         }
 164     }
 165 #else
 166     UNUSED(usageFlag);
 167     UNUSED(index);
 168 #endif
 169     return IO_TAG_NONE;
 170 }
 171 #endif