mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/hal/TARGET_Atmel/TARGET_SAM21/dma_api.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 579:53297373a894 1 /* mbed Microcontroller Library
mbed_official 579:53297373a894 2 * Copyright (c) 2006-2013 ARM Limited
mbed_official 579:53297373a894 3 *
mbed_official 579:53297373a894 4 * Licensed under the Apache License, Version 2.0 (the "License");
mbed_official 579:53297373a894 5 * you may not use this file except in compliance with the License.
mbed_official 579:53297373a894 6 * You may obtain a copy of the License at
mbed_official 579:53297373a894 7 *
mbed_official 579:53297373a894 8 * http://www.apache.org/licenses/LICENSE-2.0
mbed_official 579:53297373a894 9 *
mbed_official 579:53297373a894 10 * Unless required by applicable law or agreed to in writing, software
mbed_official 579:53297373a894 11 * distributed under the License is distributed on an "AS IS" BASIS,
mbed_official 579:53297373a894 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
mbed_official 579:53297373a894 13 * See the License for the specific language governing permissions and
mbed_official 579:53297373a894 14 * limitations under the License.
mbed_official 579:53297373a894 15 */
mbed_official 579:53297373a894 16 #include "mbed_assert.h"
mbed_official 579:53297373a894 17 #include "system.h"
mbed_official 579:53297373a894 18 #include "dma_api.h"
mbed_official 579:53297373a894 19 #include "dma_api_HAL.h"
mbed_official 579:53297373a894 20
mbed_official 579:53297373a894 21 #include <math.h>
mbed_official 579:53297373a894 22
mbed_official 579:53297373a894 23 #include "cmsis.h"
mbed_official 579:53297373a894 24 #include "pinmap.h"
mbed_official 579:53297373a894 25
mbed_official 579:53297373a894 26 /**
mbed_official 579:53297373a894 27 * \internal
mbed_official 579:53297373a894 28 * Structure redefinition, already defined in dma.c.
mbed_official 579:53297373a894 29 * Redefining as that definition is not available here
mbed_official 579:53297373a894 30 */
mbed_official 579:53297373a894 31 struct _dma_module {
mbed_official 579:53297373a894 32 volatile bool _dma_init;
mbed_official 579:53297373a894 33 volatile uint32_t allocated_channels;
mbed_official 579:53297373a894 34 uint8_t free_channels;
mbed_official 579:53297373a894 35 };
mbed_official 579:53297373a894 36
mbed_official 579:53297373a894 37 extern struct _dma_module _dma_inst;
mbed_official 579:53297373a894 38 extern uint8_t g_sys_init;
mbed_official 579:53297373a894 39
mbed_official 579:53297373a894 40 static struct dma_instance_s dma_channels[CONF_MAX_USED_CHANNEL_NUM];
mbed_official 579:53297373a894 41
mbed_official 579:53297373a894 42 /**
mbed_official 579:53297373a894 43 * \internal
mbed_official 579:53297373a894 44 * Get resource index from channel id
mbed_official 579:53297373a894 45 *
mbed_official 579:53297373a894 46 * @param[in] channelid Valid DMA channel id
mbed_official 579:53297373a894 47 * @return index to DMA instance
mbed_official 579:53297373a894 48 */
mbed_official 579:53297373a894 49 static uint8_t get_index_from_id(int channelid)
mbed_official 579:53297373a894 50 {
mbed_official 579:53297373a894 51 /* Sanity check arguments */
mbed_official 579:53297373a894 52 MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
mbed_official 579:53297373a894 53
mbed_official 579:53297373a894 54 uint8_t i;
mbed_official 579:53297373a894 55
mbed_official 579:53297373a894 56 for (i=0; i<CONF_MAX_USED_CHANNEL_NUM; i++) {
mbed_official 579:53297373a894 57 if ((dma_channels[i].status & DMA_ALLOCATED)
mbed_official 579:53297373a894 58 && (dma_channels[i].resource.channel_id == channelid)) {
mbed_official 579:53297373a894 59 break;
mbed_official 579:53297373a894 60 }
mbed_official 579:53297373a894 61 }
mbed_official 579:53297373a894 62
mbed_official 579:53297373a894 63 return i;
mbed_official 579:53297373a894 64 }
mbed_official 579:53297373a894 65
mbed_official 579:53297373a894 66 /**
mbed_official 579:53297373a894 67 * \internal
mbed_official 579:53297373a894 68 * Handler function for DMA callback
mbed_official 579:53297373a894 69 *
mbed_official 579:53297373a894 70 * @param[in] resource pointer to the resource
mbed_official 579:53297373a894 71 * @return void
mbed_official 579:53297373a894 72 */
mbed_official 579:53297373a894 73 static void dma_handler(const struct dma_resource* const resource)
mbed_official 579:53297373a894 74 {
mbed_official 579:53297373a894 75 MBED_ASSERT(resource);
mbed_official 579:53297373a894 76 void (*callback_func)(void);
mbed_official 579:53297373a894 77
mbed_official 579:53297373a894 78 uint8_t channelid = resource->channel_id;
mbed_official 579:53297373a894 79 uint8_t channel_index;
mbed_official 579:53297373a894 80
mbed_official 579:53297373a894 81 channel_index = get_index_from_id(channelid);
mbed_official 579:53297373a894 82 if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
mbed_official 579:53297373a894 83 return;
mbed_official 579:53297373a894 84 }
mbed_official 579:53297373a894 85
mbed_official 579:53297373a894 86 callback_func = dma_channels[channel_index].handler;
mbed_official 579:53297373a894 87 if (callback_func) {
mbed_official 579:53297373a894 88 callback_func();
mbed_official 579:53297373a894 89 }
mbed_official 579:53297373a894 90 }
mbed_official 579:53297373a894 91
mbed_official 579:53297373a894 92 /**
mbed_official 579:53297373a894 93 * \internal
mbed_official 579:53297373a894 94 * Configure a DMA channel for specified resource
mbed_official 579:53297373a894 95 *
mbed_official 579:53297373a894 96 * @param[in] channel_index index to the resource
mbed_official 579:53297373a894 97 * @return void
mbed_official 579:53297373a894 98 */
mbed_official 579:53297373a894 99 static void configure_dma_resource(uint8_t channel_index)
mbed_official 579:53297373a894 100 {
mbed_official 579:53297373a894 101 /* Sanity check arguments */
mbed_official 579:53297373a894 102 MBED_ASSERT(channel_index < CONF_MAX_USED_CHANNEL_NUM);
mbed_official 579:53297373a894 103
mbed_official 579:53297373a894 104 enum status_code ret;
mbed_official 579:53297373a894 105 struct dma_resource_config config;
mbed_official 579:53297373a894 106
mbed_official 579:53297373a894 107 if (dma_channels[channel_index].status & DMA_ALLOCATED) {
mbed_official 579:53297373a894 108 return;
mbed_official 579:53297373a894 109 }
mbed_official 579:53297373a894 110
mbed_official 579:53297373a894 111 /* Get default configuration for DMA */
mbed_official 579:53297373a894 112 dma_get_config_defaults(&config);
mbed_official 579:53297373a894 113
mbed_official 579:53297373a894 114 /* Allocate a free channel */
mbed_official 579:53297373a894 115 ret = dma_allocate(&dma_channels[channel_index].resource, &config);
mbed_official 579:53297373a894 116
mbed_official 579:53297373a894 117 if (ret == STATUS_OK) {
mbed_official 579:53297373a894 118 dma_channels[channel_index].status = DMA_ALLOCATED;
mbed_official 579:53297373a894 119 }
mbed_official 579:53297373a894 120 }
mbed_official 579:53297373a894 121
mbed_official 579:53297373a894 122 /** Setup a DMA descriptor for specified resource
mbed_official 579:53297373a894 123 *
mbed_official 579:53297373a894 124 * @param[in] channel_index DMA channel id
mbed_official 579:53297373a894 125 * @param[in] src source address
mbed_official 579:53297373a894 126 * @param[in] src_inc_enable source address auto increment enable flag
mbed_official 579:53297373a894 127 * @param[in] desc destination address
mbed_official 579:53297373a894 128 * @param[in] desc_inc_enable destination address auto increment enable flag
mbed_official 579:53297373a894 129 * @param[in] length length of data to be transferred
mbed_official 579:53297373a894 130 * @param[in] beat_size beat size to be set
mbed_official 579:53297373a894 131 * @return void
mbed_official 579:53297373a894 132 */
mbed_official 579:53297373a894 133 void dma_setup_transfer(uint8_t channelid, uint32_t src, bool src_inc_enable, uint32_t desc, bool desc_inc_enable, uint32_t length, uint8_t beat_size)
mbed_official 579:53297373a894 134 {
mbed_official 579:53297373a894 135 enum status_code result;
mbed_official 579:53297373a894 136 uint8_t channel_index;
mbed_official 579:53297373a894 137 struct dma_descriptor_config descriptor_config;
mbed_official 579:53297373a894 138
mbed_official 579:53297373a894 139 /* Sanity check arguments */
mbed_official 579:53297373a894 140 MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
mbed_official 579:53297373a894 141 MBED_ASSERT(src);
mbed_official 579:53297373a894 142 MBED_ASSERT(desc);
mbed_official 579:53297373a894 143
mbed_official 579:53297373a894 144 channel_index = get_index_from_id(channelid);
mbed_official 579:53297373a894 145
mbed_official 579:53297373a894 146 dma_descriptor_get_config_defaults(&descriptor_config);
mbed_official 579:53297373a894 147
mbed_official 579:53297373a894 148 if (beat_size <= 8) {
mbed_official 579:53297373a894 149 descriptor_config.beat_size = DMA_BEAT_SIZE_BYTE;
mbed_official 579:53297373a894 150 } else if ((beat_size > 8) && (beat_size <= 16)) {
mbed_official 579:53297373a894 151 descriptor_config.beat_size = DMA_BEAT_SIZE_HWORD;
mbed_official 579:53297373a894 152 } else {
mbed_official 579:53297373a894 153 descriptor_config.beat_size = DMA_BEAT_SIZE_WORD;
mbed_official 579:53297373a894 154 }
mbed_official 579:53297373a894 155 descriptor_config.block_transfer_count = length;
mbed_official 579:53297373a894 156 descriptor_config.source_address = src;
mbed_official 579:53297373a894 157 descriptor_config.destination_address = desc;
mbed_official 579:53297373a894 158
mbed_official 579:53297373a894 159 /* Source address auto-increment is enabled by default */
mbed_official 579:53297373a894 160 if (!src_inc_enable) {
mbed_official 579:53297373a894 161 descriptor_config.src_increment_enable = false;
mbed_official 579:53297373a894 162 }
mbed_official 579:53297373a894 163
mbed_official 579:53297373a894 164 /* Destination address auto-increment is enabled by default */
mbed_official 579:53297373a894 165 if (!desc_inc_enable) {
mbed_official 579:53297373a894 166 descriptor_config.dst_increment_enable = false;
mbed_official 579:53297373a894 167 }
mbed_official 579:53297373a894 168
mbed_official 579:53297373a894 169 dma_descriptor_create(&dma_channels[channel_index].descriptor, &descriptor_config);
mbed_official 579:53297373a894 170
mbed_official 579:53297373a894 171 /* Add descriptor to resource */
mbed_official 579:53297373a894 172 if (dma_channels[channel_index].resource.descriptor == NULL) {
mbed_official 579:53297373a894 173 /* Multiple calls to this function without releasing already allocated channel is not handled now */
mbed_official 579:53297373a894 174 result = dma_add_descriptor(&dma_channels[channel_index].resource, &dma_channels[channel_index].descriptor);
mbed_official 579:53297373a894 175 if (result != STATUS_OK) {
mbed_official 579:53297373a894 176 dma_channels[channel_index].status |= DMA_ERROR;
mbed_official 579:53297373a894 177 }
mbed_official 579:53297373a894 178 }
mbed_official 579:53297373a894 179 }
mbed_official 579:53297373a894 180
mbed_official 579:53297373a894 181
mbed_official 579:53297373a894 182 /** Initialize the DMA
mbed_official 579:53297373a894 183 *
mbed_official 579:53297373a894 184 * Configures clock for DMAC
mbed_official 579:53297373a894 185 */
mbed_official 579:53297373a894 186 void dma_init()
mbed_official 579:53297373a894 187 {
mbed_official 579:53297373a894 188 int i;
mbed_official 579:53297373a894 189
mbed_official 579:53297373a894 190 if (g_sys_init == 0) {
mbed_official 579:53297373a894 191 system_init();
mbed_official 579:53297373a894 192 g_sys_init = 1;
mbed_official 579:53297373a894 193 }
mbed_official 579:53297373a894 194
mbed_official 579:53297373a894 195 if (!_dma_inst._dma_init) {
mbed_official 579:53297373a894 196 for (i=0; i<CONF_MAX_USED_CHANNEL_NUM; i++) {
mbed_official 579:53297373a894 197 dma_channels[i].status = DMA_NOT_USED;
mbed_official 579:53297373a894 198 }
mbed_official 579:53297373a894 199 }
mbed_official 579:53297373a894 200 /* Do nothing for now. ASF does the clock init when allocating channel */
mbed_official 579:53297373a894 201 }
mbed_official 579:53297373a894 202
mbed_official 579:53297373a894 203 /** Allocates channel for DMA
mbed_official 579:53297373a894 204 *
mbed_official 579:53297373a894 205 * Allocates channel for DMA with specified capability
mbed_official 579:53297373a894 206 * @param[in] capabilities Capability of DMA channel
mbed_official 579:53297373a894 207 */
mbed_official 579:53297373a894 208 int dma_channel_allocate(uint32_t capabilities)
mbed_official 579:53297373a894 209 {
mbed_official 579:53297373a894 210 uint8_t channel_index = 0;
mbed_official 579:53297373a894 211
mbed_official 579:53297373a894 212 for (channel_index=0; channel_index<CONF_MAX_USED_CHANNEL_NUM; channel_index++) {
mbed_official 579:53297373a894 213 if (dma_channels[channel_index].status == DMA_NOT_USED) {
mbed_official 579:53297373a894 214 break;
mbed_official 579:53297373a894 215 }
mbed_official 579:53297373a894 216 }
mbed_official 579:53297373a894 217
mbed_official 579:53297373a894 218 if (channel_index != CONF_MAX_USED_CHANNEL_NUM) {
mbed_official 579:53297373a894 219 configure_dma_resource(channel_index);
mbed_official 579:53297373a894 220 if (dma_channels[channel_index].status & DMA_ALLOCATED) {
mbed_official 579:53297373a894 221 return dma_channels[channel_index].resource.channel_id;
mbed_official 579:53297373a894 222 }
mbed_official 579:53297373a894 223 }
mbed_official 579:53297373a894 224
mbed_official 579:53297373a894 225 /* Couldn't find a channel. */
mbed_official 579:53297373a894 226 return DMA_ERROR_OUT_OF_CHANNELS;
mbed_official 579:53297373a894 227 }
mbed_official 579:53297373a894 228
mbed_official 579:53297373a894 229 /** Start DMA transfer
mbed_official 579:53297373a894 230 *
mbed_official 579:53297373a894 231 * Kick starts transfer in DMA channel with specified channel id
mbed_official 579:53297373a894 232 * @param[in] channelid Channel id of DMA channel
mbed_official 579:53297373a894 233 * @return zero if success otherwise non zero
mbed_official 579:53297373a894 234 */
mbed_official 579:53297373a894 235 bool dma_start_transfer(int channelid)
mbed_official 579:53297373a894 236 {
mbed_official 579:53297373a894 237 /* Sanity check arguments */
mbed_official 579:53297373a894 238 MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
mbed_official 579:53297373a894 239
mbed_official 579:53297373a894 240 uint8_t channel_index;
mbed_official 579:53297373a894 241
mbed_official 579:53297373a894 242 channel_index = get_index_from_id(channelid);
mbed_official 579:53297373a894 243
mbed_official 579:53297373a894 244 if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
mbed_official 579:53297373a894 245 /* Return invalid value for now */
mbed_official 579:53297373a894 246 return false;
mbed_official 579:53297373a894 247 }
mbed_official 579:53297373a894 248
mbed_official 579:53297373a894 249 if (!(dma_channels[channel_index].status & DMA_ALLOCATED)) {
mbed_official 579:53297373a894 250 /* DMA not allocated, return invalid value for now */
mbed_official 579:53297373a894 251 return false;
mbed_official 579:53297373a894 252 }
mbed_official 579:53297373a894 253
mbed_official 579:53297373a894 254 /* Start DMA transfer */
mbed_official 579:53297373a894 255 if (STATUS_OK != dma_start_transfer_job(&dma_channels[channel_index].resource)) {
mbed_official 579:53297373a894 256 /* Error in starting DMA transfer */
mbed_official 579:53297373a894 257 return false;
mbed_official 579:53297373a894 258 }
mbed_official 579:53297373a894 259
mbed_official 579:53297373a894 260 return true;
mbed_official 579:53297373a894 261 }
mbed_official 579:53297373a894 262
mbed_official 579:53297373a894 263 /** DMA channel busy check
mbed_official 579:53297373a894 264 *
mbed_official 579:53297373a894 265 * To check whether DMA channel is busy with a job or not
mbed_official 579:53297373a894 266 * @param[in] channelid Channel id of DMA channel
mbed_official 579:53297373a894 267 * @return non zero if busy otherwise zero
mbed_official 579:53297373a894 268 */
mbed_official 579:53297373a894 269 bool dma_busy(int channelid)
mbed_official 579:53297373a894 270 {
mbed_official 579:53297373a894 271 int res = 0;
mbed_official 579:53297373a894 272 /* Sanity check arguments */
mbed_official 579:53297373a894 273 MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
mbed_official 579:53297373a894 274
mbed_official 579:53297373a894 275 uint8_t channel_index;
mbed_official 579:53297373a894 276
mbed_official 579:53297373a894 277 channel_index = get_index_from_id(channelid);
mbed_official 579:53297373a894 278
mbed_official 579:53297373a894 279 if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
mbed_official 579:53297373a894 280 /* This channel is not active! return zero for now */
mbed_official 579:53297373a894 281 res = 0;
mbed_official 579:53297373a894 282 }
mbed_official 579:53297373a894 283
mbed_official 579:53297373a894 284 return dma_is_busy(&dma_channels[channel_index].resource);
mbed_official 579:53297373a894 285 }
mbed_official 579:53297373a894 286
mbed_official 579:53297373a894 287 /** DMA channel transfer completion check
mbed_official 579:53297373a894 288 *
mbed_official 579:53297373a894 289 * To check whether DMA channel job is completed or not
mbed_official 579:53297373a894 290 * @param[in] channelid Channel id of DMA channel
mbed_official 579:53297373a894 291 * @return non zero if busy otherwise zero
mbed_official 579:53297373a894 292 */
mbed_official 579:53297373a894 293 bool dma_is_transfer_complete(int channelid)
mbed_official 579:53297373a894 294 {
mbed_official 579:53297373a894 295 int res = 0;
mbed_official 579:53297373a894 296 /* Sanity check arguments */
mbed_official 579:53297373a894 297 MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
mbed_official 579:53297373a894 298
mbed_official 579:53297373a894 299 uint8_t channel_index;
mbed_official 579:53297373a894 300
mbed_official 579:53297373a894 301 channel_index = get_index_from_id(channelid);
mbed_official 579:53297373a894 302
mbed_official 579:53297373a894 303 if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
mbed_official 579:53297373a894 304 /* This channel is not active! return zero for now */
mbed_official 579:53297373a894 305 res = 0;
mbed_official 579:53297373a894 306 }
mbed_official 579:53297373a894 307
mbed_official 579:53297373a894 308 return (STATUS_OK == dma_get_job_status(&dma_channels[channel_index].resource));
mbed_official 579:53297373a894 309 }
mbed_official 579:53297373a894 310
mbed_official 579:53297373a894 311 /** Registers callback function for DMA
mbed_official 579:53297373a894 312 *
mbed_official 579:53297373a894 313 * Registers callback function for DMA for specified events
mbed_official 579:53297373a894 314 * @param[in] channelid Channel id of DMA channel
mbed_official 579:53297373a894 315 * @param[in] handler Callback function pointer
mbed_official 579:53297373a894 316 * @param[in] event Events mask
mbed_official 579:53297373a894 317 * @return void
mbed_official 579:53297373a894 318 */
mbed_official 579:53297373a894 319 void dma_set_handler(int channelid, uint32_t handler, uint32_t event)
mbed_official 579:53297373a894 320 {
mbed_official 579:53297373a894 321 /* Sanity check arguments */
mbed_official 579:53297373a894 322 MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
mbed_official 579:53297373a894 323
mbed_official 579:53297373a894 324 uint8_t channel_index;
mbed_official 579:53297373a894 325
mbed_official 579:53297373a894 326 channel_index = get_index_from_id(channelid);
mbed_official 579:53297373a894 327
mbed_official 579:53297373a894 328 if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
mbed_official 579:53297373a894 329 /* Return for now */
mbed_official 579:53297373a894 330 return;
mbed_official 579:53297373a894 331 }
mbed_official 579:53297373a894 332
mbed_official 579:53297373a894 333 dma_channels[channel_index].handler = handler;
mbed_official 579:53297373a894 334 if (event & DMA_TRANSFER_ERROR) {
mbed_official 579:53297373a894 335 dma_register_callback(&dma_channels[channel_index].resource, dma_handler, DMA_CALLBACK_TRANSFER_ERROR);
mbed_official 579:53297373a894 336 }
mbed_official 579:53297373a894 337 if (event & DMA_TRANSFER_COMPLETE) {
mbed_official 579:53297373a894 338 dma_register_callback(&dma_channels[channel_index].resource, dma_handler, DMA_CALLBACK_TRANSFER_DONE);
mbed_official 579:53297373a894 339 }
mbed_official 579:53297373a894 340
mbed_official 579:53297373a894 341 /* Set interrupt vector if someone have removed it */
mbed_official 579:53297373a894 342 NVIC_SetVector(DMAC_IRQn, (uint32_t)DMAC_Handler);
mbed_official 579:53297373a894 343 /* Enable interrupt */
mbed_official 579:53297373a894 344 NVIC_EnableIRQ(DMAC_IRQn);
mbed_official 579:53297373a894 345 }
mbed_official 579:53297373a894 346
mbed_official 579:53297373a894 347 /** Frees an allocated DMA channel
mbed_official 579:53297373a894 348 *
mbed_official 579:53297373a894 349 * Frees an already allocated DMA channel with specified channel id
mbed_official 579:53297373a894 350 * @param[in] channelid Channel id of DMA channel to be disabled
mbed_official 579:53297373a894 351 * @return zero if success
mbed_official 579:53297373a894 352 */
mbed_official 579:53297373a894 353 int dma_channel_free(int channelid)
mbed_official 579:53297373a894 354 {
mbed_official 579:53297373a894 355 /* Sanity check arguments */
mbed_official 579:53297373a894 356 MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
mbed_official 579:53297373a894 357
mbed_official 579:53297373a894 358 uint8_t channel_index;
mbed_official 579:53297373a894 359
mbed_official 579:53297373a894 360 channel_index = get_index_from_id(channelid);
mbed_official 579:53297373a894 361
mbed_official 579:53297373a894 362 if (STATUS_OK == dma_free(&dma_channels[channel_index].resource)) {
mbed_official 579:53297373a894 363 dma_channels[channel_index].status = DMA_NOT_USED;
mbed_official 579:53297373a894 364 dma_channels[channel_index].resource.descriptor = NULL;
mbed_official 579:53297373a894 365 return 0;
mbed_official 579:53297373a894 366 } else {
mbed_official 579:53297373a894 367 /* Return invalid value for now */
mbed_official 579:53297373a894 368 return -1;
mbed_official 579:53297373a894 369 }
mbed_official 579:53297373a894 370 }
mbed_official 579:53297373a894 371
mbed_official 579:53297373a894 372