static int rk3190_mbox_startup(struct ipc_mbox *imb)
{
struct rk3190_mbox *pmb = (struct rk3190_mbox *)imb;
int i;
rk3190_mbox_writel(pmb, MBOX_INTEN, 0); // disable interrupts
rk3190_mbox_writel(pmb, MBOX_INTSTAT, ~0x0); // clear interrupts
pmb->mboxd = create_workqueue("mboxd");
if (!pmb->mboxd) {
return -ENOMEM;
}
INIT_WORK(&pmb->work, rk3190_mbox_rx_work);
for (i=0; i<ARRAY_SIZE(pmb->irq); i++) {
if (pmb->irq[i] >= 0) {
request_irq(pmb->irq[i], rk3190_mbox_interrupt, 0, "mbox", pmb);
}
}
IPC_DBG(DEBUG_INFO,"=============%s=================",__func__);
// enable mbox interrupt
rk3190_mbox_writel(pmb, MBOX_INTEN, MBOX_CHAN_MASKBITS);
return 0;
}
static int sdio_read_modem_data(u8 *buf, int len, int addr)
{
int ret = 0;
IPC_DBG(" sdio_read_modem_data entery:buf:0x%X, len:%x\r\n", (u32)buf, len);
ret = sprd_sdio_channel_rx(buf, len, addr);
return ret;
}
static int hwreq_ipcmsg_handler(struct ipc_msg *pmsg, void *data)
{
struct rk_baseband *bb;
int cmd;
int ret;
bb = (struct rk_baseband *)data;
cmd = pmsg->subcmd;
IPC_DBG(DEBUG_INFO,"%s:cmd=%d",__func__,cmd);
switch (cmd) {
case IPC_HW_SIM_VCC_SELECT:
ret = handle_sim_vccsel_req(bb, pmsg);
break;
case IPC_HW_GPIO_SET_OUTPUT ... IPC_HW_GPIO_SET_DEBOUNCE:
ret = handle_gpio_req(bb, cmd, pmsg);
break;
case IPC_HW_BB_SYSTEM_HALT:
ret = handle_bb_system_halt(bb, pmsg);
break;
default:
break;
}
return 0;
}
int mux_ipc_sdio_write(const char *buf, size_t count)
{
static int first = 1;
IPC_DBG("[mipc]mux_ipc_sdio_write write len:%d\r\n", count);
if(first) {
int cnt = 0;
first = 0;
wait_cp_bootup();
while(1) {
set_tx_buf_dbg_data(s_dbg_buf, MAX_MIPC_TX_FRAME_SIZE - sizeof(struct packet_header));
mux_ipc_xmit_buf(s_dbg_buf, MAX_MIPC_TX_FRAME_SIZE - sizeof(struct packet_header));
//set_tx_buf_dbg_data(s_dbg_buf, 50);
//mux_ipc_xmit_buf(s_dbg_buf, 50);
cnt++;
if(cnt == MAX_MIPC_TX_FRAME_SIZE)
//if(cnt == 4)
{
msleep(100);
cnt = 0;
}
}
}
return count;
//return mux_ipc_xmit_buf(buf, count);
}
int mux_ipc_sdio_read(char *buf, size_t count)
{
int ret = 0;
wait_event_interruptible(s_mux_read_rts, !kfifo_is_empty(&s_mipc_rx_cache_kfifo) || s_mux_ipc_event_flags);
if(s_mux_ipc_event_flags & MUX_IPC_READ_DISABLE) {
printk("[mipc] mux ipc read disable!\r\n");
return -1;
}
IPC_DBG("[mipc]mux_ipc_sdio_read read len:%d\r\n", count);
ret = kfifo_out(&s_mipc_rx_cache_kfifo,buf,count);
ipc_info_mux_read(ret);
ipc_info_sdio_read_saved_count(kfifo_len(&s_mipc_rx_cache_kfifo));
return ret;
}
int mux_ipc_sdio_write(const char *buf, size_t count)
{
wait_cp_bootup();
IPC_DBG("[mipc]mux_ipc_sdio_write write len:%d\r\n", count);
return mux_ipc_xmit_buf(buf, count);
}
static int do_sdio_rx(u32 *tx_flow_info, u32 *acked_tx_frame)
{
u32 receve_len = 0;
int ret = 0;
int result = SDHCI_TRANSFER_OK;
int resend_count = 0;
struct packet_header *packet = NULL;
wake_lock(&s_ipc_sdio_wake_lock);
do {
IPC_DBG(" sdio_read_modem_data xxxx................\r\n");
ipc_info_change_status(IPC_RX_CHANNEL, IPC_STATUS_CONNECTED);
memset(s_mipc_rx_buf, 0xaa, MAX_MIPC_RX_FRAME_SIZE);
if(!have_buffer_to_read()) {
panic("do_sdio_rx have no buffer to read!\r\n");
}
ret = sdio_read_modem_data(s_mipc_rx_buf, MAX_MIPC_RX_FRAME_SIZE, (resend_count != 0));
set_cp_awake(true);
if (!ret) {
//calc phy read speed
ipc_info_sdio_read(MAX_MIPC_RX_FRAME_SIZE);
packet=(struct packet_header *)s_mipc_rx_buf;
if(VerifyPacketHeader(packet, tx_flow_info, acked_tx_frame)) {
result = SDHCI_TRANSFER_OK;
} else {
ipc_info_error_status(IPC_RX_CHANNEL, IPC_STATUS_PACKET_ERROR);
result = SDHCI_TRANSFER_ERROR;
printk("[mipc] Sdio Rx Packet check error tag:0x%X, len:%d, ul_frame_num:0x%x\n", packet->tag, packet->length, packet->u.ul_frame_num);
}
} else {
ipc_info_error_status(IPC_RX_CHANNEL, IPC_STATUS_CRC_ERROR);
result = SDHCI_TRANSFER_ERROR;
printk("[mipc]SDIO READ FAIL, ret:%d\r \n", ret);
}
ipc_info_change_status(IPC_RX_CHANNEL, IPC_STATUS_DISCONNECTED);
if(result) {
resend_count++;
msleep(2);
}
} while(result && (resend_count < MAX_SDIO_RX_RETRY));
ipc_info_change_status(IPC_RX_CHANNEL, IPC_STATUS_IDLE);
wake_unlock(&s_ipc_sdio_wake_lock);
if(!result) {
u32 send_cnt = 0;
ipc_info_rate(IPC_RX_CHANNEL, packet->length*1000/MAX_MIPC_RX_FRAME_SIZE);
ipc_info_sdio_read_payload(packet->length);
receve_len = packet->length;
printk("[mipc] read data len:%d\r\n", receve_len);
if(sdio_transfer_frame_check_enable && sdio_frame_check(&s_mipc_rx_buf[sizeof(struct packet_header )], packet->length)) {
printk("[mipc]:sdio receved data frame error!\r\n");
}
if(packet->length) {
kfifo_in(&s_mipc_rx_cache_kfifo,&s_mipc_rx_buf[sizeof(struct packet_header )], packet->length);
wake_up_interruptible(&s_mux_read_rts);
} else {
ipc_info_error_status(IPC_RX_CHANNEL, IPC_STATUS_INVALID_PACKET);
}
} else {
receve_len = 0;
printk("[mipc] receive data fail! result:%d\r\n", result);
}
return result;
}
static inline void switch_pipe_state(struct ipc_pipe *pipe, u8 state)
{
pipe->state = state;
IPC_DBG(DEBUG_INFO,"state=%d\n",state);
}
