| /****************************************************************************** |
| * |
| * 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 NXP |
| * |
| ****************************************************************************** |
| * |
| * util.h |
| * |
| ****************************************************************************** |
| */ |
| |
| #ifndef UTIL_H_ |
| #define UTIL_H_ |
| |
| #include <linux/delay.h> |
| #include <linux/mutex.h> |
| |
| /** |
| * \addtogroup GENERAL_API |
| * \{ |
| */ |
| /** status code returned by API calls */ |
| typedef enum { |
| /** operation succedded */ |
| CDN_OK = 0, |
| /** CEC operation succedded */ |
| CDN_CEC_ERR_NONE = 0, |
| /** mailbox is currently sending or receiving data */ |
| CDN_BSY, |
| /** message set up and ready to be sent, no data sent yet */ |
| CDN_STARTED, |
| /** error encountered while reading/writing APB */ |
| CDN_ERR, |
| /** reply returned with bad opcode */ |
| CDN_BAD_OPCODE, |
| /** reply returned with bad module */ |
| CDN_BAD_MODULE, |
| /** reply not supported mode */ |
| CDN_ERROR_NOT_SUPPORTED, |
| /** Invalid argument passed to CEC API function */ |
| CDN_CEC_ERR_INVALID_ARG, |
| /** |
| * TX Buffer for CEC Messages is full. This is applicable only |
| * when TX Buffers for CEC Messages are implemented in the HW. |
| */ |
| CDN_CEC_ERR_TX_BUFF_FULL, |
| /** No Messages in the RX Buffers are present. */ |
| CDN_CEC_ERR_RX_BUFF_EMPTY, |
| /** Timeout during TX operation */ |
| CDN_CEC_ERR_TX_TIMEOUT, |
| /** Timeout during RX operation */ |
| CDN_CEC_ERR_RX_TIMEOUT, |
| /** Data transmision fail. */ |
| CDN_CEC_ERR_TX_FAILED, |
| /** Data reception fail. */ |
| CDN_CEC_ERR_RX_FAILED, |
| /** Operation aborted. */ |
| CDN_CEC_ERR_ABORT, |
| } CDN_API_STATUS; |
| |
| typedef enum { |
| CDN_DPTX, |
| CDN_HDMITX_TYPHOON, |
| CDN_HDMITX_KIRAN, |
| } CDN_PROTOCOL_TYPE; |
| |
| typedef enum { |
| CDN_BUS_TYPE_APB = 0, |
| CDN_BUS_TYPE_SAPB = 1 |
| } CDN_BUS_TYPE; |
| |
| typedef struct { |
| /** apb write status */ |
| enum tx_status_enum { |
| /** one or more bytes written */ |
| CDN_TX_WRITE = 0, |
| /** nothing to write */ |
| CDN_TX_NOTHING = 1, |
| /** mailbox full, 0 bytes written */ |
| CDN_TX_FULL = 2, |
| /** APB error while writing */ |
| CDN_TX_APB_ERROR = 3 |
| } tx_status:3; |
| /** apb read status */ |
| enum rx_status_enum { |
| /** 1 or more bytes read */ |
| CDN_RX_READ = 0, |
| /** mailbox empty, 0 bytes read */ |
| CDN_RX_EMPTY = 1, |
| /** apb error while reading */ |
| CDN_RX_APB_ERROR = 2 |
| } rx_status:2; |
| /** indicates end of currenly recived message */ |
| u8 rxend:1; |
| /** end of tx message reached */ |
| u8 txend:1; |
| } INTERNAL_MBOX_STATUS; |
| |
| struct hdp_mem { |
| void __iomem *regs_base; |
| void __iomem *ss_base; |
| }; |
| |
| struct hdp_rw_func { |
| int (*read_reg) (struct hdp_mem *mem, u32 addr, u32 *value); |
| int (*write_reg) (struct hdp_mem *mem, u32 addr, u32 value); |
| int (*sread_reg) (struct hdp_mem *mem, u32 addr, u32 *value); |
| int (*swrite_reg) (struct hdp_mem *mem, u32 addr, u32 value); |
| }; |
| |
| typedef struct { |
| u8 txBuffer[1024]; |
| u8 rxBuffer[1024]; |
| u32 txi; //iterators |
| u32 rxi; |
| u8 txEnable; //data readt to send |
| u8 rxEnable; |
| u8 running; |
| CDN_BUS_TYPE bus_type; |
| u32 tmp; |
| |
| struct mutex mutex; //mutex may replace running |
| struct hdp_mem mem; |
| struct hdp_rw_func *rw; |
| } state_struct; |
| /** |
| * \addtogroup UTILS |
| * \{ |
| */ |
| #define INTERNAL_CMD_HEAD_SIZE 4 |
| |
| /** |
| * \brief expands to blocking function body |
| * \param x - function call |
| */ |
| #define MAILBOX_FILL_TIMEOUT 1500 |
| #define internal_block_function(y, x) \ |
| do { \ |
| unsigned long end_jiffies = jiffies + \ |
| msecs_to_jiffies(MAILBOX_FILL_TIMEOUT); \ |
| CDN_API_STATUS ret; \ |
| mutex_lock(y); \ |
| do { \ |
| ret = x; \ |
| cpu_relax(); \ |
| } while (time_after(end_jiffies, jiffies) && \ |
| (ret == CDN_BSY || ret == CDN_STARTED)); \ |
| mutex_unlock(y); \ |
| return ret; \ |
| } while (0) |
| |
| /** |
| * \brief write message and write response (if any), non-blocking way. Also sets state.running = 0 |
| */ |
| #define internal_process_messages(state) \ |
| do { \ |
| if (state->txEnable && !internal_mbox_tx_process(state).txend) \ |
| return CDN_BSY; \ |
| if (state->rxEnable && !internal_mbox_rx_process(state).rxend) \ |
| return CDN_BSY; \ |
| state->running = 0; \ |
| } while (0) |
| |
| #define internal_opcode_ok_or_return(state, module, opcode) do { \ |
| CDN_API_STATUS ret; \ |
| ret = internal_test_rx_head(state, module, opcode); \ |
| if (ret != CDN_OK) \ |
| return ret; \ |
| } while (0) |
| |
| #define internal_opcode_match_or_return(state) do { \ |
| CDN_API_STATUS ret; \ |
| ret = internal_test_rx_head_match(state); \ |
| if (ret != CDN_OK) \ |
| return ret; \ |
| } while (0) |
| |
| /* macro for simple tx only command, command format as in mkfullmsg (with count) */ |
| #define internal_macro_command_tx(state, module, opcode, bustype, command...) \ |
| do { \ |
| if (!state->running) { \ |
| internal_tx_mkfullmsg(state, module, opcode, command); \ |
| state->bus_type = bustype; \ |
| return CDN_STARTED; \ |
| } \ |
| internal_process_messages(state); \ |
| } while (0) |
| |
| /* macro for command with response with matching opcode, command format as in mkfullmsg (with count) */ |
| #define internal_macro_command_txrx(state, module, opcode, bustype, command...) \ |
| do { \ |
| if (!state->running) { \ |
| internal_tx_mkfullmsg(state, module, opcode, command); \ |
| state->bus_type = bustype; \ |
| state->rxEnable = 1; \ |
| return CDN_STARTED; \ |
| } \ |
| internal_process_messages(state); \ |
| internal_opcode_match_or_return(state); \ |
| } while (0) |
| |
| /** |
| * \brief put val into dest in big endian format |
| * \param val - value to put |
| * \param dest - place to put value |
| * \param bytes - true size of val in bytes. for example if bytes = 2 val is treated as short int |
| */ |
| void internal_itobe(int val, volatile u8 *dest, int bytes); |
| |
| /** |
| * \brief read big endian value from src and return it |
| * \param src - source to read from |
| * \param bytes - size of read value |
| * \return result |
| */ |
| u32 internal_betoi(volatile u8 const *src, u8 bytes); |
| |
| /** |
| * \brief create message from size and value pairs; also sets state.runnging and state.txEnable |
| * \param dest - pointer to write message to |
| * \param valNo - number of values to write |
| * \param ... - pairs of size and value, each value is written after another. if size is positive value, value is written with #internal_itobe, if size is negative, value is treated as src pointer for memcpy |
| * |
| * example: |
| * |
| * u16 x = 0xAABB; |
| * |
| * internal_mkmsg(dest, 3, 1, 1, 2, 3, -2, &x); |
| * |
| * will write 01 00 03 AA BB to dest |
| */ |
| u32 internal_mkmsg(volatile u8 *dest, int valNo, ...); |
| u32 internal_vmkmsg(volatile u8 *dest, int valNo, va_list vl); |
| |
| /** |
| * \brief setup message header in txBuffer, set txEnable = 1 |
| */ |
| void internal_mbox_tx_enable(state_struct *state, u8 module, u8 opcode, |
| u16 length); |
| |
| /** |
| * \brief write from txBuffer to mailbox untill full or end of message. |
| * |
| * when txEnable == 0 writes nothing |
| * when write reaches end of message set txEnable = 0 |
| */ |
| |
| /** |
| * \brief combination of #internal_mkmsg and #internal_mbox_tx_enable |
| * |
| * #internal_mkmsg dest and #internal_mbox_tx_enable length are determined automaticly |
| * this function also sets state.txEnable = 1 and state.running |
| */ |
| void internal_tx_mkfullmsg(state_struct *state, u8 module, u8 opcode, |
| int valNo, ...); |
| void internal_vtx_mkfullmsg(state_struct *state, u8 module, u8 opcode, |
| int valNo, va_list vl); |
| |
| /** |
| * \brief read from state.txBuffer and store results in specified pointers |
| * \param valNo - numbero of values to read |
| * \param ... - pairs of size and ptr |
| * |
| * this function is similar to #internal_mkmsg - |
| * |
| * when size is positive read value using #internal_betoi |
| * when size is negative mempcy from txBuffer to ptr -size bytes |
| * when size is 0 write to ptr addres of current position in rxbuffer |
| * when ptr is NULL ignore size bytes (if size is negative this will rewind buffer) |
| */ |
| void internal_readmsg(state_struct *state, int valNo, ...); |
| void internal_vreadmsg(state_struct *state, int valNo, va_list vl); |
| |
| INTERNAL_MBOX_STATUS internal_mbox_tx_process(state_struct *state); |
| /** |
| * \brief read to rxBuffer from mailbox untill empty or end of message |
| * |
| * when rxEnable == 0 reads nothing |
| * when end of message reached sets rxEnable = 0 |
| */ |
| INTERNAL_MBOX_STATUS internal_mbox_rx_process(state_struct *state); |
| |
| /** |
| * \brief check if apb is available |
| * \return !(rxEnable && txEable) |
| */ |
| u32 internal_apb_available(state_struct *state); |
| |
| /** |
| * \brief test if parameters match module and opcode in rxBuffer |
| * \return CDN_OK or CDN_BAD_OPCODE or CDN_BAD_MODULE |
| */ |
| CDN_API_STATUS internal_test_rx_head(state_struct *state, u8 module, |
| u8 opcode); |
| |
| CDN_API_STATUS internal_test_rx_head_match(state_struct *state); |
| |
| /** |
| * \brief print current fw and lib version |
| */ |
| void print_fw_ver(state_struct *state); |
| |
| int cdn_apb_read(state_struct *state, u32 addr, u32 *value); |
| int cdn_sapb_read(state_struct *state, u32 addr, u32 *value); |
| int cdn_apb_write(state_struct *state, u32 addr, u32 value); |
| int cdn_sapb_write(state_struct *state, u32 addr, u32 value); |
| void cdn_sleep(u32 ms); |
| void cdn_usleep(u32 us); |
| u16 internal_get_msg_len(state_struct *state); |
| |
| #endif |
