ocs_elxu.c

/*
 *  BSD LICENSE
 *
 *  Copyright (c) 2011-2018 Broadcom.  All Rights Reserved.
 *  The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the
 *      distribution.
 *    * Neither the name of Intel Corporation nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * @file
 * Elxutility interface code
 */


#include "ocs.h"
#include "ocs_ioctl.h"
#include "ocs_elxu.h"

static int32_t __ocs_ioctl_mbox_cb(ocs_hal_t *hal, int32_t status, uint8_t *mqe, void *arg);

int32_t
ocs_process_sli_config(ocs_t *ocs, ocs_ioctl_elxu_mbox_t *mcmd, ocs_dma_t *dma)
{
	sli4_cmd_sli_config_t *sli_config = (sli4_cmd_sli_config_t *)mcmd->payload;

	if (sli_config->emb) {
		sli4_req_hdr_t *req = (sli4_req_hdr_t *)sli_config->payload.embed;

		switch (req->opcode) {
		case SLI4_OPC_COMMON_READ_OBJECT:
			if (mcmd->out_bytes) {
				sli4_req_common_read_object_t *rdobj =
				  	(sli4_req_common_read_object_t *)sli_config->payload.embed;

				if (ocs_dma_alloc(ocs, dma, mcmd->out_bytes, 4096)) {
					ocs_log_err(ocs, "%s: COMMON_READ_OBJECT - %" PRIX64 " allocation failed\n",
							__func__, mcmd->out_bytes);
					return ENXIO;
				}

				memset(dma->virt, 0, mcmd->out_bytes);

				rdobj->host_buffer_descriptor[0].bde_type = SLI4_BDE_TYPE_BDE_64;
				rdobj->host_buffer_descriptor[0].buffer_length = mcmd->out_bytes;
				rdobj->host_buffer_descriptor[0].u.data.buffer_address_low = ocs_addr32_lo(dma->phys);
				rdobj->host_buffer_descriptor[0].u.data.buffer_address_high = ocs_addr32_hi(dma->phys);

			}
			break;
		case SLI4_OPC_COMMON_WRITE_OBJECT:
		{
			sli4_req_common_write_object_t *wrobj =
			  	(sli4_req_common_write_object_t *)sli_config->payload.embed;

			if (ocs_dma_alloc(ocs, dma, wrobj->desired_write_length, 4096)) {
				ocs_log_err(ocs, "%s: COMMON_WRITE_OBJECT - %d allocation failed\n",
						__func__, wrobj->desired_write_length);
				return ENXIO;
			}
			// setup the descriptor
			wrobj->host_buffer_descriptor[0].bde_type = SLI4_BDE_TYPE_BDE_64;
			wrobj->host_buffer_descriptor[0].buffer_length = wrobj->desired_write_length;
			wrobj->host_buffer_descriptor[0].u.data.buffer_address_low = ocs_addr32_lo(dma->phys);
			wrobj->host_buffer_descriptor[0].u.data.buffer_address_high = ocs_addr32_hi(dma->phys);

			// copy the data into the DMA buffer
			if (ocs_copy_from_user(dma->virt, (void *)mcmd->in_addr, mcmd->in_bytes)) {
				ocs_log_warn(ocs, "%s: copy_from_user() failed\n", __func__);
				return EFAULT;
			}

		}
			break;
		case SLI4_OPC_COMMON_DELETE_OBJECT:
			break;
		case SLI4_OPC_COMMON_READ_OBJECT_LIST:
			if (mcmd->out_bytes) {
				sli4_req_common_read_object_list_t *rdobj =
					(sli4_req_common_read_object_list_t *)sli_config->payload.embed;
				if (ocs_dma_alloc(ocs, dma, mcmd->out_bytes, 4096)) {
					ocs_log_err(ocs, "%s: COMMON_READ_OBJECT_LIST - %" PRIX64 " allocation failed\n",
							__func__, mcmd->out_bytes);
					return ENXIO;
				}

				ocs_memset(dma->virt, 0, mcmd->out_bytes);

				rdobj->host_buffer_descriptor[0].bde_type = SLI4_BDE_TYPE_BDE_64;
				rdobj->host_buffer_descriptor[0].buffer_length = mcmd->out_bytes;
				rdobj->host_buffer_descriptor[0].u.data.buffer_address_low = ocs_addr32_lo(dma->phys);
				rdobj->host_buffer_descriptor[0].u.data.buffer_address_high = ocs_addr32_hi(dma->phys);

			}
			break;
		case SLI4_OPC_COMMON_READ_TRANSCEIVER_DATA:
			break;
		default:
			ocs_log_info(ocs, "%s: in=%p (%" PRIX64 ") out=%p (%" PRIX64 ")\n", __func__,
					(void *)mcmd->in_addr, mcmd->in_bytes,
					(void *)mcmd->out_addr, mcmd->out_bytes);
			ocs_log_info(ocs, "%s: unknown (opc=%#x)\n", __func__,
					req->opcode);
			break;
		}
	} else {
		uint32_t max_bytes = max(mcmd->in_bytes, mcmd->out_bytes);
		if (ocs_dma_alloc(ocs, dma, max_bytes, 4096)) {
			ocs_log_err(ocs, "%s: non-embedded - %u allocation failed\n",
					__func__, max_bytes);
			return ENXIO;
		}

		if (ocs_copy_from_user(dma->virt, (void *)mcmd->in_addr, mcmd->in_bytes)) {
			ocs_log_warn(ocs, "%s: copy_from_user failed\n", __func__);
			return ENXIO;
		}

		sli_config->payload.mem.address_low  = ocs_addr32_lo(dma->phys);
		sli_config->payload.mem.address_high = ocs_addr32_hi(dma->phys);
		sli_config->payload.mem.length = max_bytes;
	}

	return 0;
}

int32_t
ocs_elxu(ocs_t *ocs, ocs_ioctl_elxu_mbox_t *mcmd)
{
	int32_t rc = 0;
	ocs_dma_t dma = { 0 };
	ocs_sem_t waitsem;

	// sanity checks
	if ((ELXU_BSD_MAGIC != mcmd->magic) ||
			(sizeof(*mcmd) != mcmd->size)) {
		ocs_log_debug(ocs, "%s: malformed command m=%08x s=%08x\n",
				__func__, mcmd->magic, mcmd->size);
		return EINVAL;
	}

	switch(((sli4_mbox_command_header_t *)mcmd->payload)->command)
	{
	case SLI4_MBOX_COMMAND_SLI_CONFIG:
		if (ENXIO == ocs_process_sli_config(ocs, mcmd, &dma))
			return ENXIO;
		break;

	case SLI4_MBOX_COMMAND_READ_REV:
	case SLI4_MBOX_COMMAND_READ_STATUS:
	case SLI4_MBOX_COMMAND_READ_LNK_STAT:
	case SLI4_MBOX_COMMAND_DUMP:
		break;

	default:
		ocs_log_debug(NULL, "command %d\n",((sli4_mbox_command_header_t *)mcmd->payload)->command);
		ocs_log_debug(NULL, "%s, command not support\n", __func__);
		goto no_support;
		break;

	} // end for switch( ... -> command )

	ocs_sem_init(&waitsem, 0, "elxu_mbox");

	rc = ocs_hal_command(&ocs->hal, mcmd->payload, OCS_CMD_NOWAIT, __ocs_ioctl_mbox_cb, &waitsem);
	if (rc)
		goto dma_free;

	if (ocs_sem_p(&waitsem, OCS_SEM_FOREVER) == 0) {
		if(SLI4_MBOX_COMMAND_SLI_CONFIG == ((sli4_mbox_command_header_t *)mcmd->payload)->command &&
			mcmd->out_bytes && dma.virt) {
			if (ocs_copy_to_user((void *)mcmd->out_addr, dma.virt, mcmd->out_bytes)) {
				ocs_log_warn(ocs, "%s: copy_to_user failed\n", __func__);
				rc = -ENXIO;
			}
		}
	} else {
		ocs_log_warn(ocs, "%s: hal command was interrupted\n", __func__);
		rc = -ENXIO;
	}

dma_free:
	ocs_dma_free(ocs, &dma);

no_support:
	return rc;
}

static int32_t
__ocs_ioctl_mbox_cb(ocs_hal_t *hal, int32_t status, uint8_t *mqe, void *arg)
{
	ocs_sem_t *sem = arg;

	ocs_sem_v(sem);

	return 0;

}