rt_single.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 The University of Manchester
 *
 * 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
 *
 *     https://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 <stdbool.h>
#include <spin1_api.h>
#include <spin1_api_params.h>
#include <debug.h>
#include <malloc_extras.h>
#include "../common/routing_table.h"
 
#ifndef __RT_SINGLE_H__
#define __RT_SINGLE_H__
 
/* entry_t is defined as:
 *
 *     typedef struct
 *     {
 *       uint32_t keymask;
 *       uint32_t mask;
 *       uint32_t route;   // Routing direction
 *       uint32_t source;  // Source of packets arriving at this entry
 *     } entry_t;
 *
 * The `source` field is used to determine if the entry could be replaced by
 * default routing, it can be left blank if removing default entries is not to
 * be used. Otherwise indicate which links will be used by packets expected to
 * match the specified entry.
 *
 * NOTE: The routing table provided to this application MUST include all of the
 * entries which are expected to arrive at this router (i.e., entries which
 * could be replaced by default routing MUST be included in the table provided
 * to this application).
 *
 * NOTE: The block of memory containing the header and initial routing table
 * will be freed on exit by this application.
 */
 
#define RTR_MC_SET_FAILED 0
 
table_t *table;
 
static const uint32_t DMA_READ_FLAGS =
        DMA_WIDTH << 24 | DMA_BURST_SIZE << 21 | DMA_READ << 19;
 
#define DMA_COMPLETE 0x400
 
#define DMA_CHECK_MASK 0x401
 
typedef struct {
    uint32_t app_id;
 
    uint32_t compress_as_much_as_possible;
 
    uint32_t table_size;
 
    entry_t entries[];
} header_t;
 
int routing_table_get_n_entries(void) {
    return table->size;
}
 
void routing_table_remove_from_size(int size_to_remove) {
    table->size -= size_to_remove;
}
 
entry_t* routing_table_get_entry(uint32_t entry_id_to_find) {
    return &table->entries[entry_id_to_find];
}
 
void print_header(header_t *header) {
    log_debug("app_id = %d", header->app_id);
    log_debug("compress_as_much_as_possible = %d",
            header->compress_as_much_as_possible);
    log_debug("table_size = %d", header->table_size);
}
 
static void read_table(header_t *header) {
    table = MALLOC(
        sizeof(uint32_t) + (sizeof(entry_t) * header->table_size));
    if (table == NULL) {
        log_error("failed to allocate memory for routing tables");
        malloc_extras_terminate(EXIT_FAIL);
    }
    // Copy the size of the table
    table->size = header->table_size;
 
    // Copy in the routing table entries
    spin1_memcpy(table->entries, header->entries,
            sizeof(entry_t) * table->size);
}
 
bool load_routing_table(uint32_t app_id) {
    // Try to allocate sufficient room for the routing table.
    uint32_t entry_id = rtr_alloc_id(table->size, app_id);
    if (entry_id == 0) {
        log_error("Unable to allocate routing table of size %u\n", table->size);
        return FALSE;
    }
 
    // Load entries into the table (provided the allocation succeeded).
    // Note that although the allocation included the specified
    // application ID we also need to include it as the most significant
    // byte in the route (see `sark_hw.c`).
    for (uint32_t i = 0; i < table->size; i++) {
        entry_t entry = table->entries[i];
        uint32_t route = entry.route | (app_id << 24);
        uint success = rtr_mc_set(
            entry_id + i, entry.key_mask.key, entry.key_mask.mask, route);
        if (success == RTR_MC_SET_FAILED) {
            log_warning("failed to set a router table entry at index %d",
                    entry_id + i);
        }
    }
 
    // Indicate we were able to allocate routing table entries.
    return TRUE;
}
 
bool routing_table_get_entries(uint32_t start_entry, uint32_t n_entries,
        entry_t *output) {
    uint32_t length = n_entries * sizeof(entry_t);
    uint32_t desc = DMA_READ_FLAGS | length;
    dma[DMA_ADRS] = (uint32_t) &table->entries[start_entry];
    dma[DMA_ADRT] = (uint32_t) output;
    dma[DMA_DESC] = desc;
    return false;
}
 
 
static inline bool dma_done(void) {
    return (dma[DMA_STAT] & DMA_CHECK_MASK) == DMA_COMPLETE;
}
 
void routing_table_wait_for_last_transfer(void) {
    while (!dma_done()) {
        continue;
    }
    dma[DMA_CTRL] = 0x8;
}
 
#endif //__RT_SINGLE_H__