cvmx-cmd-queue.c

Go to the documentation of this file.

/***********************license start***************
 * Author: Cavium Networks
 *
 * Contact: [email protected]
 * This file is part of the OCTEON SDK
 *
 * Copyright (c) 2003-2008 Cavium Networks
 *
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, Version 2, as
 * published by the Free Software Foundation.
 *
 * This file is distributed in the hope that it will be useful, but
 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
 * NONINFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this file; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 * or visit http://www.gnu.org/licenses/.
 *
 * This file may also be available under a different license from Cavium.
 * Contact Cavium Networks for more information
 ***********************license end**************************************/

/*
 * Support functions for managing command queues used for
 * various hardware blocks.
 */

#include <linux/kernel.h>

#include <asm/octeon/octeon.h>

#include <asm/octeon/cvmx-config.h>
#include <asm/octeon/cvmx-fpa.h>
#include <asm/octeon/cvmx-cmd-queue.h>

#include <asm/octeon/cvmx-npei-defs.h>
#include <asm/octeon/cvmx-pexp-defs.h>
#include <asm/octeon/cvmx-pko-defs.h>

__cvmx_cmd_queue_all_state_t *__cvmx_cmd_queue_state_ptr;

static cvmx_cmd_queue_result_t __cvmx_cmd_queue_init_state_ptr(void)
{
    char *alloc_name = "cvmx_cmd_queues";
#if defined(CONFIG_CAVIUM_RESERVE32) && CONFIG_CAVIUM_RESERVE32
    extern uint64_t octeon_reserve32_memory;
#endif

    if (likely(__cvmx_cmd_queue_state_ptr))
        return CVMX_CMD_QUEUE_SUCCESS;

#if defined(CONFIG_CAVIUM_RESERVE32) && CONFIG_CAVIUM_RESERVE32
    if (octeon_reserve32_memory)
        __cvmx_cmd_queue_state_ptr =
            cvmx_bootmem_alloc_named_range(sizeof(*__cvmx_cmd_queue_state_ptr),
                           octeon_reserve32_memory,
                           octeon_reserve32_memory +
                           (CONFIG_CAVIUM_RESERVE32 <<
                            20) - 1, 128, alloc_name);
    else
#endif
        __cvmx_cmd_queue_state_ptr =
            cvmx_bootmem_alloc_named(sizeof(*__cvmx_cmd_queue_state_ptr),
                        128,
                        alloc_name);
    if (__cvmx_cmd_queue_state_ptr)
        memset(__cvmx_cmd_queue_state_ptr, 0,
               sizeof(*__cvmx_cmd_queue_state_ptr));
    else {
        struct cvmx_bootmem_named_block_desc *block_desc =
            cvmx_bootmem_find_named_block(alloc_name);
        if (block_desc)
            __cvmx_cmd_queue_state_ptr =
                cvmx_phys_to_ptr(block_desc->base_addr);
        else {
            cvmx_dprintf
                ("ERROR: cvmx_cmd_queue_initialize: Unable to get named block %s.\n",
                 alloc_name);
            return CVMX_CMD_QUEUE_NO_MEMORY;
        }
    }
    return CVMX_CMD_QUEUE_SUCCESS;
}

cvmx_cmd_queue_result_t cvmx_cmd_queue_initialize(cvmx_cmd_queue_id_t queue_id,
                          int max_depth, int fpa_pool,
                          int pool_size)
{
    __cvmx_cmd_queue_state_t *qstate;
    cvmx_cmd_queue_result_t result = __cvmx_cmd_queue_init_state_ptr();
    if (result != CVMX_CMD_QUEUE_SUCCESS)
        return result;

    qstate = __cvmx_cmd_queue_get_state(queue_id);
    if (qstate == NULL)
        return CVMX_CMD_QUEUE_INVALID_PARAM;

    /*
     * We artificially limit max_depth to 1<<20 words. It is an
     * arbitrary limit.
     */
    if (CVMX_CMD_QUEUE_ENABLE_MAX_DEPTH) {
        if ((max_depth < 0) || (max_depth > 1 << 20))
            return CVMX_CMD_QUEUE_INVALID_PARAM;
    } else if (max_depth != 0)
        return CVMX_CMD_QUEUE_INVALID_PARAM;

    if ((fpa_pool < 0) || (fpa_pool > 7))
        return CVMX_CMD_QUEUE_INVALID_PARAM;
    if ((pool_size < 128) || (pool_size > 65536))
        return CVMX_CMD_QUEUE_INVALID_PARAM;

    /* See if someone else has already initialized the queue */
    if (qstate->base_ptr_div128) {
        if (max_depth != (int)qstate->max_depth) {
            cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
                "Queue already initialized with different "
                "max_depth (%d).\n",
                 (int)qstate->max_depth);
            return CVMX_CMD_QUEUE_INVALID_PARAM;
        }
        if (fpa_pool != qstate->fpa_pool) {
            cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
                "Queue already initialized with different "
                "FPA pool (%u).\n",
                 qstate->fpa_pool);
            return CVMX_CMD_QUEUE_INVALID_PARAM;
        }
        if ((pool_size >> 3) - 1 != qstate->pool_size_m1) {
            cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
                "Queue already initialized with different "
                "FPA pool size (%u).\n",
                 (qstate->pool_size_m1 + 1) << 3);
            return CVMX_CMD_QUEUE_INVALID_PARAM;
        }
        CVMX_SYNCWS;
        return CVMX_CMD_QUEUE_ALREADY_SETUP;
    } else {
        union cvmx_fpa_ctl_status status;
        void *buffer;

        status.u64 = cvmx_read_csr(CVMX_FPA_CTL_STATUS);
        if (!status.s.enb) {
            cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
                     "FPA is not enabled.\n");
            return CVMX_CMD_QUEUE_NO_MEMORY;
        }
        buffer = cvmx_fpa_alloc(fpa_pool);
        if (buffer == NULL) {
            cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
                     "Unable to allocate initial buffer.\n");
            return CVMX_CMD_QUEUE_NO_MEMORY;
        }

        memset(qstate, 0, sizeof(*qstate));
        qstate->max_depth = max_depth;
        qstate->fpa_pool = fpa_pool;
        qstate->pool_size_m1 = (pool_size >> 3) - 1;
        qstate->base_ptr_div128 = cvmx_ptr_to_phys(buffer) / 128;
        /*
         * We zeroed the now serving field so we need to also
         * zero the ticket.
         */
        __cvmx_cmd_queue_state_ptr->
            ticket[__cvmx_cmd_queue_get_index(queue_id)] = 0;
        CVMX_SYNCWS;
        return CVMX_CMD_QUEUE_SUCCESS;
    }
}

cvmx_cmd_queue_result_t cvmx_cmd_queue_shutdown(cvmx_cmd_queue_id_t queue_id)
{
    __cvmx_cmd_queue_state_t *qptr = __cvmx_cmd_queue_get_state(queue_id);
    if (qptr == NULL) {
        cvmx_dprintf("ERROR: cvmx_cmd_queue_shutdown: Unable to "
                 "get queue information.\n");
        return CVMX_CMD_QUEUE_INVALID_PARAM;
    }

    if (cvmx_cmd_queue_length(queue_id) > 0) {
        cvmx_dprintf("ERROR: cvmx_cmd_queue_shutdown: Queue still "
                 "has data in it.\n");
        return CVMX_CMD_QUEUE_FULL;
    }

    __cvmx_cmd_queue_lock(queue_id, qptr);
    if (qptr->base_ptr_div128) {
        cvmx_fpa_free(cvmx_phys_to_ptr
                  ((uint64_t) qptr->base_ptr_div128 << 7),
                  qptr->fpa_pool, 0);
        qptr->base_ptr_div128 = 0;
    }
    __cvmx_cmd_queue_unlock(qptr);

    return CVMX_CMD_QUEUE_SUCCESS;
}

int cvmx_cmd_queue_length(cvmx_cmd_queue_id_t queue_id)
{
    if (CVMX_ENABLE_PARAMETER_CHECKING) {
        if (__cvmx_cmd_queue_get_state(queue_id) == NULL)
            return CVMX_CMD_QUEUE_INVALID_PARAM;
    }

    /*
     * The cast is here so gcc with check that all values in the
     * cvmx_cmd_queue_id_t enumeration are here.
     */
    switch ((cvmx_cmd_queue_id_t) (queue_id & 0xff0000)) {
    case CVMX_CMD_QUEUE_PKO_BASE:
        /*
         * FIXME: Need atomic lock on
         * CVMX_PKO_REG_READ_IDX. Right now we are normally
         * called with the queue lock, so that is a SLIGHT
         * amount of protection.
         */
        cvmx_write_csr(CVMX_PKO_REG_READ_IDX, queue_id & 0xffff);
        if (OCTEON_IS_MODEL(OCTEON_CN3XXX)) {
            union cvmx_pko_mem_debug9 debug9;
            debug9.u64 = cvmx_read_csr(CVMX_PKO_MEM_DEBUG9);
            return debug9.cn38xx.doorbell;
        } else {
            union cvmx_pko_mem_debug8 debug8;
            debug8.u64 = cvmx_read_csr(CVMX_PKO_MEM_DEBUG8);
            return debug8.cn58xx.doorbell;
        }
    case CVMX_CMD_QUEUE_ZIP:
    case CVMX_CMD_QUEUE_DFA:
    case CVMX_CMD_QUEUE_RAID:
        /* FIXME: Implement other lengths */
        return 0;
    case CVMX_CMD_QUEUE_DMA_BASE:
        {
            union cvmx_npei_dmax_counts dmax_counts;
            dmax_counts.u64 =
                cvmx_read_csr(CVMX_PEXP_NPEI_DMAX_COUNTS
                      (queue_id & 0x7));
            return dmax_counts.s.dbell;
        }
    case CVMX_CMD_QUEUE_END:
        return CVMX_CMD_QUEUE_INVALID_PARAM;
    }
    return CVMX_CMD_QUEUE_INVALID_PARAM;
}

void *cvmx_cmd_queue_buffer(cvmx_cmd_queue_id_t queue_id)
{
    __cvmx_cmd_queue_state_t *qptr = __cvmx_cmd_queue_get_state(queue_id);
    if (qptr && qptr->base_ptr_div128)
        return cvmx_phys_to_ptr((uint64_t) qptr->base_ptr_div128 << 7);
    else
        return NULL;
}