drivers/aes/aes.c

Go to the documentation of this file.

#include <assert.h>
#include <debug.h>
#include <malloc.h>
#include <status-codes.h>
#include <string.h>
#include <interrupt.h>
#include <chip/memory-map.h>
#include <aes.h>

#include "aes_regs.h"

void aes_init(struct aes_module *module, uint32_t mode)
{
        assert(module);

        module->port = (void *)AES_BASE;
        module->mode = mode | AES_MR_START_MODE_DMA;

        aes_write_reg(module->port, CR, AES_CR_SWRST);
        aes_write_reg(module->port, MR, module->mode);

        module->dma_rx_channel = dmac_aes_alloc_rx_channel();
        module->dma_tx_channel = dmac_aes_alloc_tx_channel();

        module->counter = 0;
}

void aes_free(struct aes_module *module)
{
        assert(module);

        module->port = NULL;
        dmac_aes_free_channel(module->dma_rx_channel);
        dmac_aes_free_channel(module->dma_tx_channel);
}

void aes_set_cipher(struct aes_module *module, uint32_t mode)
{
        assert(module);

        module->mode = (module->mode & ~AES_MR_CIPHER_MASK) |
                        (mode & AES_MR_CIPHER_MASK);

        aes_write_reg(module->port, CR, AES_CR_SWRST);
        aes_write_reg(module->port, MR, module->mode);
}

uint32_t aes_get_cipher(struct aes_module *module)
{
        assert(module);

        return (module->mode & AES_MR_CIPHER_MASK);
}

void aes_load_init_vector(struct aes_module *module, const uint32_t *vector)
{
        int i;

        assert(module);
        assert(vector);

        for (i = 0; i < 4; i++)
                aes_write_init_reg(module->port, i, *vector++);
}

void aes_load_key(struct aes_module *module, const uint32_t *key)
{
        int i;
        int key_length = 0;

        assert(module);
        assert(key);

        switch (module->mode & AES_KEYSIZE_MASK) {
        case AES_KEYSIZE_128:
                key_length = 4;
                break;
        case AES_KEYSIZE_192:
                key_length = 6;
                break;
        case AES_KEYSIZE_256:
                key_length = 8;
                break;
        default:
                unhandled_case(module->mode);
        }

        for (i = 0; i < key_length; i++)
                aes_write_key_reg(module->port, i, *key++);
}

void aes_free_duplicate_buffers(struct slist *buf_list)
{
        struct buffer *buf;

        assert(buf_list);

        while (!slist_is_empty(buf_list)) {
                buf = slist_pop_head(buf_list, struct buffer, node);
                buffer_free(buf);
        }
}

int aes_duplicate_buffer_refs(struct slist *copy, struct slist *original)
{
        struct buffer *buf;
        struct buffer *temp;

        assert(copy);
        assert(original);

        slist_for_each(original, buf, node) {
                temp = buffer_alloc();
                if (unlikely(!temp))
                        goto ret_error;
                temp->addr.ptr = buf->addr.ptr;
                temp->addr.phys = buf->addr.phys;
                temp->len = buf->len;
                slist_insert_tail(copy, &temp->node);
        }
        return 0;

ret_error:
        aes_free_duplicate_buffers(copy);
        return -1;
}

static void aes_dma_tx_done(struct dmac_channel *chan,
                struct dmac_request *req)
{
        struct aes_request *areq = req->context;

        aes_free_duplicate_buffers(&req->buf_list);
        free(req);

        if (++areq->done_counter >= 2 && areq->req_done)
                areq->req_done(areq, &areq->rx_buf_list, areq->context);
}

static void aes_dma_rx_done(struct dmac_channel *chan,
                struct dmac_request *req)
{
        struct aes_request *areq = req->context;
        unsigned int iflags;

        assert(req);
        assert(areq);

        iflags = cpu_irq_save();
        if (!slist_is_empty(&req->buf_list))
                slist_move_to_tail(&areq->rx_buf_list, &req->buf_list);
        cpu_irq_restore(iflags);

        free(req);

        if (++areq->done_counter >= 2 && areq->req_done)
                areq->req_done(areq, &areq->rx_buf_list, areq->context);
}

static void aes_dma_req_init(struct dmac_request *req,
                struct aes_request *areq, enum dma_direction dir)
{
        memset(req, 0, sizeof(struct dmac_request));
        dmac_req_init(req);
        req->direction = dir;

        switch (dir) {
        case DMA_TO_DEVICE:
                req->req_done = aes_dma_tx_done;
                break;

        case DMA_FROM_DEVICE:
                req->req_done = aes_dma_rx_done;
                break;

        default:
                unhandled_case(dir);
        }

        req->reg_width = DMAC_REG_WIDTH_32BIT;
        req->burst_length = DMAC_BURST_LENGTH_4;
        req->context = areq;
}

void aes_submit_request(struct aes_request *req)
{
        struct dmac_request *tx_req = &req->tx_req;
        struct dmac_request *rx_req = &req->rx_req;

        assert(req);

        aes_dma_req_init(tx_req, req, DMA_TO_DEVICE);
        aes_dma_req_init(rx_req, req, DMA_FROM_DEVICE);
        req->done_counter = 0;

        if (!slist_is_empty(&req->tx_buf_list)) {
                /* Move buffers to DMA requests. */
                slist_move_to_tail(&tx_req->buf_list, &req->tx_buf_list);
                slist_move_to_tail(&rx_req->buf_list, &req->rx_buf_list);

                /* Submit DMA requests to the DMA controller. */
                dmac_chan_submit_request(req->module->dma_rx_channel, rx_req);
                dmac_chan_submit_request(req->module->dma_tx_channel, tx_req);
        } else {
                /* Empty request; skip actual encryption, clean up and
                 * run callback. */
                aes_dma_tx_done(req->module->dma_tx_channel, tx_req);
                aes_dma_rx_done(req->module->dma_rx_channel, rx_req);
        }
}

struct aes_request *aes_alloc_request(struct aes_module *module)
{
        struct aes_request *req;

        assert(module);
        /* Try to catch AES usage without running init first. */
        assert(module->port);

        req = malloc(sizeof(struct aes_request));
        assert(req);
        req->module = module;

        return req;
}

void aes_free_request(struct aes_request *req)
{
        assert(slist_is_empty(&req->tx_buf_list));
        assert(slist_is_empty(&req->rx_buf_list));

        free(req);
}

void aes_prepare_request(struct aes_request *req, struct slist *buf_list)
{
        slist_init(&req->tx_buf_list);
        slist_init(&req->rx_buf_list);

        if (!slist_is_empty(buf_list)) {
                assert(!aes_duplicate_buffer_refs(
                                &req->rx_buf_list, buf_list));
                slist_move_to_tail(&req->tx_buf_list, buf_list);
        }
}

---