Diff: targets/TARGET_Atmel/TARGET_SAM_CortexM0P/dma_api.c

Revision:

149:156823d33999

Parent:

64:41a834223ea3

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/targets/TARGET_Atmel/TARGET_SAM_CortexM0P/dma_api.c	Fri Oct 28 11:17:30 2016 +0100
@@ -0,0 +1,372 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2015 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "mbed_assert.h"
+#include "system.h"
+#include "dma_api.h"
+#include "dma_api_HAL.h"
+
+#include <math.h>
+
+#include "cmsis.h"
+#include "pinmap.h"
+
+/**
+ * \internal
+ * Structure redefinition, already defined in dma.c.
+ * Redefining as that definition is not available here
+ */
+struct _dma_module {
+    volatile bool _dma_init;
+    volatile uint32_t allocated_channels;
+    uint8_t free_channels;
+};
+
+extern struct _dma_module _dma_inst;
+extern uint8_t g_sys_init;
+
+static struct dma_instance_s dma_channels[CONF_MAX_USED_CHANNEL_NUM];
+
+/**
+ * \internal
+ * Get resource index from channel id
+ *
+ * @param[in] channelid Valid DMA channel id
+ * @return index to DMA instance
+ */
+static uint8_t get_index_from_id(int channelid)
+{
+    /* Sanity check arguments */
+    MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
+
+    uint8_t i;
+
+    for (i=0; i<CONF_MAX_USED_CHANNEL_NUM; i++) {
+        if ((dma_channels[i].status & DMA_ALLOCATED)
+                && (dma_channels[i].resource.channel_id == channelid)) {
+            break;
+        }
+    }
+
+    return i;
+}
+
+/**
+ * \internal
+ * Handler function for DMA callback
+ *
+ * @param[in] resource pointer to the resource
+ * @return void
+ */
+static void dma_handler(const struct dma_resource* const resource)
+{
+    MBED_ASSERT(resource);
+    void (*callback_func)(void);
+
+    uint8_t channelid = resource->channel_id;
+    uint8_t channel_index;
+
+    channel_index = get_index_from_id(channelid);
+    if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
+        return;
+    }
+
+    callback_func = (void(*)(void))(dma_channels[channel_index].handler);
+    if (callback_func) {
+        callback_func();
+    }
+}
+
+/**
+ * \internal
+ * Configure a DMA channel for specified resource
+ *
+ * @param[in] channel_index index to the resource
+ * @return void
+ */
+static void configure_dma_resource(uint8_t channel_index)
+{
+    /* Sanity check arguments */
+    MBED_ASSERT(channel_index < CONF_MAX_USED_CHANNEL_NUM);
+
+    enum status_code ret;
+    struct dma_resource_config config;
+
+    if (dma_channels[channel_index].status & DMA_ALLOCATED) {
+        return;
+    }
+
+    /* Get default configuration for DMA */
+    dma_get_config_defaults(&config);
+
+    /* Allocate a free channel */
+    ret = dma_allocate(&dma_channels[channel_index].resource, &config);
+
+    if (ret == STATUS_OK) {
+        dma_channels[channel_index].status = DMA_ALLOCATED;
+    }
+}
+
+/** Setup a DMA descriptor for specified resource
+ *
+ * @param[in] channel_index		DMA channel id
+ * @param[in] src				source address
+ * @param[in] src_inc_enable	source address auto increment enable flag
+ * @param[in] desc				destination address
+ * @param[in] desc_inc_enable	destination address auto increment enable flag
+ * @param[in] length			length of data to be transferred
+ * @param[in] beat_size			beat size to be set
+ * @return void
+ */
+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)
+{
+    enum status_code result;
+    uint8_t channel_index;
+    struct dma_descriptor_config descriptor_config;
+
+    /* Sanity check arguments */
+    MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
+    MBED_ASSERT(src);
+    MBED_ASSERT(desc);
+
+    channel_index = get_index_from_id(channelid);
+
+    dma_descriptor_get_config_defaults(&descriptor_config);
+
+    if (beat_size <= 8) {
+        descriptor_config.beat_size = DMA_BEAT_SIZE_BYTE;
+    } else if ((beat_size > 8) && (beat_size <= 16)) {
+        descriptor_config.beat_size = DMA_BEAT_SIZE_HWORD;
+    } else {
+        descriptor_config.beat_size = DMA_BEAT_SIZE_WORD;
+    }
+    descriptor_config.block_transfer_count = length;
+    descriptor_config.source_address = src;
+    descriptor_config.destination_address = desc;
+
+    /* Source address auto-increment is enabled by default */
+    if (!src_inc_enable) {
+        descriptor_config.src_increment_enable = false;
+    }
+
+    /* Destination address auto-increment is enabled by default */
+    if (!desc_inc_enable) {
+        descriptor_config.dst_increment_enable = false;
+    }
+
+    dma_descriptor_create(&dma_channels[channel_index].descriptor, &descriptor_config);
+
+    /* Add descriptor to resource */
+    if (dma_channels[channel_index].resource.descriptor == NULL) {
+        /* Multiple calls to this function without releasing already allocated channel is not handled now */
+        result = dma_add_descriptor(&dma_channels[channel_index].resource, &dma_channels[channel_index].descriptor);
+        if (result != STATUS_OK) {
+            dma_channels[channel_index].status |= DMA_ERROR;
+        }
+    }
+}
+
+
+/** Initialize the DMA
+ *
+ * Configures clock for DMAC
+ */
+void dma_init()
+{
+    int i;
+
+    if (g_sys_init == 0) {
+        system_init();
+        g_sys_init = 1;
+    }
+
+    if (!_dma_inst._dma_init) {
+        for (i=0; i<CONF_MAX_USED_CHANNEL_NUM; i++) {
+            dma_channels[i].status = DMA_NOT_USED;
+        }
+    }
+    /* Do nothing for now. ASF does the clock init when allocating channel */
+}
+
+/** Allocates channel for DMA
+ *
+ * Allocates channel for DMA with specified capability
+ * @param[in] capabilities     Capability of DMA channel
+ */
+int dma_channel_allocate(uint32_t capabilities)
+{
+    uint8_t channel_index = 0;
+
+    for (channel_index=0; channel_index<CONF_MAX_USED_CHANNEL_NUM; channel_index++) {
+        if (dma_channels[channel_index].status == DMA_NOT_USED) {
+            break;
+        }
+    }
+
+    if (channel_index != CONF_MAX_USED_CHANNEL_NUM) {
+        configure_dma_resource(channel_index);
+        if (dma_channels[channel_index].status & DMA_ALLOCATED) {
+            return dma_channels[channel_index].resource.channel_id;
+        }
+    }
+
+    /* Couldn't find a channel. */
+    return DMA_ERROR_OUT_OF_CHANNELS;
+}
+
+/** Start DMA transfer
+ *
+ * Kick starts transfer in DMA channel with specified channel id
+ * @param[in] channelid    Channel id of DMA channel
+ * @return zero if success otherwise non zero
+ */
+bool dma_start_transfer(int channelid)
+{
+    /* Sanity check arguments */
+    MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
+
+    uint8_t channel_index;
+
+    channel_index = get_index_from_id(channelid);
+
+    if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
+        /* Return invalid value for now */
+        return false;
+    }
+
+    if (!(dma_channels[channel_index].status & DMA_ALLOCATED)) {
+        /* DMA not allocated, return invalid value for now */
+        return false;
+    }
+
+    /* Start DMA transfer */
+    if (STATUS_OK != dma_start_transfer_job(&dma_channels[channel_index].resource)) {
+        /* Error in starting DMA transfer */
+        return false;
+    }
+
+    return true;
+}
+
+/** DMA channel busy check
+ *
+ * To check whether DMA channel is busy with a job or not
+ * @param[in] channelid    Channel id of DMA channel
+ * @return non zero if busy otherwise zero
+ */
+bool dma_busy(int channelid)
+{
+    /* Sanity check arguments */
+    MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
+
+    uint8_t channel_index;
+
+    channel_index = get_index_from_id(channelid);
+
+    if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
+        /* This channel is not active! return zero for now */
+        //res = 0;
+        return 0;
+    }
+
+    return dma_is_busy(&dma_channels[channel_index].resource);
+}
+
+/** DMA channel transfer completion check
+ *
+ * To check whether DMA channel job is completed or not
+ * @param[in] channelid    Channel id of DMA channel
+ * @return non zero if busy otherwise zero
+ */
+bool dma_is_transfer_complete(int channelid)
+{
+    /* Sanity check arguments */
+    MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
+
+    uint8_t channel_index;
+
+    channel_index = get_index_from_id(channelid);
+
+    if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
+        /* This channel is not active! return zero for now */
+        // res = 0;
+        return 0;
+    }
+
+    return (STATUS_OK == dma_get_job_status(&dma_channels[channel_index].resource));
+}
+
+/** Registers callback function for DMA
+ *
+ * Registers callback function for DMA for specified events
+ * @param[in] channelid    Channel id of DMA channel
+ * @param[in] handler      Callback function pointer
+ * @param[in] event        Events mask
+ * @return void
+ */
+void dma_set_handler(int channelid, uint32_t handler, uint32_t event)
+{
+    /* Sanity check arguments */
+    MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
+
+    uint8_t channel_index;
+
+    channel_index = get_index_from_id(channelid);
+
+    if (channel_index >= CONF_MAX_USED_CHANNEL_NUM) {
+        /* Return for now */
+        return;
+    }
+
+    dma_channels[channel_index].handler = handler;
+    if (event & DMA_TRANSFER_ERROR) {
+        dma_register_callback(&dma_channels[channel_index].resource, (dma_callback_t)dma_handler, DMA_CALLBACK_TRANSFER_ERROR);
+    }
+    if (event & DMA_TRANSFER_COMPLETE) {
+        dma_register_callback(&dma_channels[channel_index].resource, (dma_callback_t)dma_handler, DMA_CALLBACK_TRANSFER_DONE);
+    }
+
+    /* Set interrupt vector if someone have removed it */
+    NVIC_SetVector(DMAC_IRQn, (uint32_t)DMAC_Handler);
+    /* Enable interrupt */
+    NVIC_EnableIRQ(DMAC_IRQn);
+}
+
+/** Frees an allocated DMA channel
+ *
+ * Frees an already allocated DMA channel with specified channel id
+ * @param[in] channelid    Channel id of DMA channel to be disabled
+ * @return zero if success
+ */
+int dma_channel_free(int channelid)
+{
+    /* Sanity check arguments */
+    MBED_ASSERT(channelid < CONF_MAX_USED_CHANNEL_NUM);
+
+    uint8_t channel_index;
+
+    channel_index = get_index_from_id(channelid);
+
+    if (STATUS_OK == dma_free(&dma_channels[channel_index].resource)) {
+        dma_channels[channel_index].status = DMA_NOT_USED;
+        dma_channels[channel_index].resource.descriptor = NULL;
+        return 0;
+    } else {
+        /* Return invalid value for now */
+        return -1;
+    }
+}
+
+