blob: e59b5f059239e411233951d345ffcb3cb5b1ad6b [file] [log] [blame] [edit]
/******************************************************************************
*
* Copyright (C) 2016-2017 Cadence Design Systems, Inc.
* All rights reserved worldwide.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. 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.
*
* 3. Neither the name of the copyright holder 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 HOLDER 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.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Copyright 2017-2018 NXP
*
******************************************************************************
*
* util.c
*
******************************************************************************
*/
#include "util.h"
#include "API_General.h"
#include "apb_cfg.h"
#include "opcodes.h"
int cdn_apb_read(state_struct *state, u32 addr, u32 *value)
{
struct hdp_mem *mem = state->mem;
state->rw->read_reg(mem, addr, value);
return 0;
}
int cdn_apb_write(state_struct *state, u32 addr, u32 value)
{
struct hdp_mem *mem = state->mem;
state->rw->write_reg(mem, addr, value);
return 0;
}
int cdn_sapb_read(state_struct *state, u32 addr, u32 *value)
{
struct hdp_mem *mem = state->mem;
state->rw->sread_reg(mem, addr, value);
return 0;
}
int cdn_sapb_write(state_struct *state, u32 addr, u32 value)
{
struct hdp_mem *mem = state->mem;
state->rw->swrite_reg(mem, addr, value);
return 0;
}
void cdn_sleep(u32 ms)
{
mdelay(ms);
}
void cdn_usleep(u32 us)
{
udelay(us);
}
int cdn_bus_read(state_struct *state, u32 addr, u32 *value)
{
return state->bus_type ?
cdn_sapb_read(state, addr, value) : cdn_apb_read(state, addr,
value);
}
int cdn_bus_write(state_struct *state, u32 addr, u32 value)
{
return state->bus_type ?
cdn_sapb_write(state, addr, value) : cdn_apb_write(state, addr,
value);
}
void internal_itobe(int val, volatile u8 *dest, int bytes)
{
int i;
for (i = bytes - 1; i >= 0; --i) {
dest[i] = (u8) val;
val >>= 8;
}
}
u32 internal_betoi(volatile u8 const *src, u8 bytes)
{
u32 ret = 0;
int i;
if (bytes > sizeof(ret)) {
printk
("Warning. Read request for payload larger then supported.\n");
bytes = sizeof(ret);
}
for (i = 0; i < bytes; ++i) {
ret <<= 8;
ret |= (u32) src[i];
}
return ret;
}
u32 internal_mkmsg(volatile u8 *dest, int valNo, ...)
{
va_list vl;
u32 len = 0;
va_start(vl, valNo);
len = internal_vmkmsg(dest, valNo, vl);
va_end(vl);
return len;
}
u32 internal_vmkmsg(volatile u8 *dest, int valNo, va_list vl)
{
u32 len = 0;
int i;
for (i = 0; i < valNo; ++i) {
int size = va_arg(vl, int);
if (size > 0) {
internal_itobe(va_arg(vl, int), dest, size);
dest += size;
len += size;;
} else {
memcpy((void *)dest, va_arg(vl, void *), -size);
dest -= size;
len -= size;
}
}
return len;
}
void internal_tx_mkfullmsg(state_struct *state, u8 module, u8 opcode,
int valNo, ...)
{
va_list vl;
va_start(vl, valNo);
internal_vtx_mkfullmsg(state, module, opcode, valNo, vl);
va_end(vl);
}
void internal_vtx_mkfullmsg(state_struct *state, u8 module, u8 opcode,
int valNo, va_list vl)
{
u32 len =
internal_vmkmsg(state->txBuffer + INTERNAL_CMD_HEAD_SIZE, valNo,
vl);
internal_mbox_tx_enable(state, module, opcode, len);
state->txEnable = 1;
state->running = 1;
}
void internal_readmsg(state_struct *state, int valNo, ...)
{
va_list vl;
va_start(vl, valNo);
internal_vreadmsg(state, valNo, vl);
va_end(vl);
}
void internal_vreadmsg(state_struct *state, int valNo, va_list vl)
{
u8 *src = state->rxBuffer + INTERNAL_CMD_HEAD_SIZE;
size_t i;
for (i = 0; i < (size_t) valNo; ++i) {
int size = va_arg(vl, int);
void *ptr = va_arg(vl, void *);
if (!ptr) {
src += size;
} else if (!size) {
*((u8 **) ptr) = src;
} else if (size > 0) {
switch ((size_t) size) {
case sizeof(u8):
*((u8 *) ptr) = internal_betoi(src, size);
break;
case sizeof(u16):
*((u16 *) ptr) = internal_betoi(src, size);
break;
case 3: // 3-byte value (e.g. DPCD address) can be safely converted from BE
case sizeof(u32):
*((u32 *) ptr) = internal_betoi(src, size);
break;
default:
pr_warn("Warning. Unsupported variable size.\n");
memcpy(ptr, src, size);
};
src += size;
} else {
memcpy(ptr, src, -size);
src -= size;
}
}
}
INTERNAL_MBOX_STATUS mailbox_write(state_struct *state, u8 val)
{
INTERNAL_MBOX_STATUS ret = { 0, 0, 0, 0 };
u32 full;
if (cdn_bus_read(state, MAILBOX_FULL_ADDR << 2, &full)) {
ret.tx_status = CDN_TX_APB_ERROR;
return ret;
}
if (full) {
ret.tx_status = CDN_TX_FULL;
return ret;
}
if (cdn_bus_write(state, MAILBOX0_WR_DATA << 2, val)) {
ret.tx_status = CDN_TX_APB_ERROR;
return ret;
}
ret.tx_status = CDN_TX_WRITE;
return ret;
}
INTERNAL_MBOX_STATUS mailbox_read(state_struct *state, volatile u8 *val)
{
INTERNAL_MBOX_STATUS ret = { 0, 0, 0, 0 };
u32 empty;
u32 rd;
if (cdn_bus_read(state, MAILBOX_EMPTY_ADDR << 2, &empty)) {
ret.rx_status = CDN_RX_APB_ERROR;
return ret;
}
if (empty) {
ret.rx_status = CDN_RX_EMPTY;
return ret;
}
if (cdn_bus_read(state, MAILBOX0_RD_DATA << 2, &rd)) {
ret.rx_status = CDN_RX_APB_ERROR;
return ret;
}
*val = (u8) rd;
ret.rx_status = CDN_RX_READ;
return ret;
}
INTERNAL_MBOX_STATUS internal_mbox_tx_process(state_struct *state)
{
u32 txCount = 0;
u32 length = (u32) state->txBuffer[2] << 8 | (u32) state->txBuffer[3];
INTERNAL_MBOX_STATUS ret = {.txend = 0 };
INTERNAL_MBOX_STATUS tx_ret;
ret.tx_status = CDN_TX_NOTHING;
if (!state->txEnable)
return ret;
while ((tx_ret.tx_status =
mailbox_write(state, state->txBuffer[state->txi]).tx_status) ==
CDN_TX_WRITE) {
txCount++;
if (++state->txi >= length + 4) {
state->txEnable = 0;
state->txi = 0;
ret.txend = 1;
break;
}
}
if (txCount && tx_ret.tx_status == CDN_TX_FULL)
ret.tx_status = CDN_TX_WRITE;
else
ret.tx_status = tx_ret.tx_status;
return ret;
}
INTERNAL_MBOX_STATUS internal_mbox_rx_process(state_struct *state)
{
u32 rxCount = 0;
INTERNAL_MBOX_STATUS ret = { 0, 0, 0, 0 };
INTERNAL_MBOX_STATUS rx_ret;
while ((rx_ret.rx_status =
mailbox_read(state, state->rxBuffer + state->rxi).rx_status) ==
CDN_RX_READ) {
rxCount++;
if (++state->rxi >=
4 +
((u32) state->rxBuffer[2] << 8 | (u32) state->
rxBuffer[3])) {
state->rxi = 0;
ret.rxend = 1;
state->rxEnable = 0;
break;
}
}
ret.rx_status = rxCount ? CDN_RX_READ : CDN_RX_EMPTY;
return ret;
}
u32 internal_apb_available(state_struct *state)
{
return !(state->rxEnable || state->txEnable);
}
void internal_mbox_tx_enable(state_struct *state, u8 module, u8 opcode,
u16 length)
{
state->txBuffer[0] = opcode;
state->txBuffer[1] = module;
state->txBuffer[2] = (u8) (length >> 8);
state->txBuffer[3] = (u8) length;
state->txEnable = 1;
}
CDN_API_STATUS internal_test_rx_head(state_struct *state, u8 module, u8 opcode)
{
if (opcode != state->rxBuffer[0])
return CDN_BAD_OPCODE;
if (module != state->rxBuffer[1])
return CDN_BAD_MODULE;
return CDN_OK;
}
CDN_API_STATUS internal_test_rx_head_match(state_struct *state)
{
return internal_test_rx_head(state, state->txBuffer[1],
state->txBuffer[0]);
}
void print_fw_ver(state_struct *state)
{
u16 ver, verlib;
CDN_API_General_getCurVersion(state, &ver, &verlib);
printk("FIRMWARE VERSION: %d, LIB VERSION: %d\n", ver, verlib);
}
u16 internal_get_msg_len(state_struct *state)
{
return ((u16) state->rxBuffer[2] << 8) | (u16) state->rxBuffer[3];
}