marcus chiou / mbed-src

mbed library sources

Fork of mbed-src 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