ssize_t GPS_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) { int retval = 0; int written = 0; down(&wr_mtx); /* GPS_TRC_FUNC(); */ /*printk("%s: count %d pos %lld\n", __func__, count, *f_pos); */ if (count > 0) { int copy_size = (count < MTKSTP_BUFFER_SIZE) ? count : MTKSTP_BUFFER_SIZE; if (copy_from_user(&o_buf[0], &buf[0], copy_size)) { retval = -EFAULT; goto out; } /* printk("%02x ", val); */ #if GPS_DEBUG_TRACE_GPIO mtk_wcn_stp_debug_gpio_assert(IDX_GPS_TX, DBG_TIE_LOW); #endif written = mtk_wcn_stp_send_data(&o_buf[0], copy_size, GPS_TASK_INDX); #if GPS_DEBUG_TRACE_GPIO mtk_wcn_stp_debug_gpio_assert(IDX_GPS_TX, DBG_TIE_HIGH); #endif #if GPS_DEBUG_DUMP { unsigned char *buf_ptr = &o_buf[0]; int k = 0; pr_debug("--[GPS-WRITE]--"); for (k = 0; k < 10; k++) { if (k % 16 == 0) pr_debug("\n"); pr_debug("0x%02x ", o_buf[k]); } pr_debug("\n"); } #endif /* If cannot send successfully, enqueue again if (written != copy_size) { // George: FIXME! Move GPS retry handling from app to driver } */ if (0 == written) { retval = -ENOSPC; /*no windowspace in STP is available, native process should not call GPS_write with no delay at all */ GPS_ERR_FUNC("target packet length:%zd, write success length:%d, retval = %d.\n", count, written, retval); } else { retval = written; } } else { retval = -EFAULT; GPS_ERR_FUNC("target packet length:%zd is not allowed, retval = %d.\n", count, retval); } out: up(&wr_mtx); return retval; }
ssize_t BT_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) { int retval = 0; int written = 0; down(&wr_mtx); BT_DBG_FUNC("%s: count %d pos %lld\n", __func__, count, *f_pos); if(retflag) { if (retflag == 1) //reset start { retval = -88; BT_INFO_FUNC("MT662x reset Write: start\n"); } else if (retflag == 2) // reset end { retval = -99; BT_INFO_FUNC("MT662x reset Write: end\n"); } goto OUT; } if (count > 0) { int copy_size = (count < MTKSTP_BUFFER_SIZE) ? count : MTKSTP_BUFFER_SIZE; if (copy_from_user(&o_buf[0], &buf[0], copy_size)) { retval = -EFAULT; goto OUT; } //printk("%02x ", val); written = mtk_wcn_stp_send_data(&o_buf[0], copy_size, BT_TASK_INDX); if(0 == written) { retval = -ENOSPC; /*no windowspace in STP is available, native process should not call BT_write with no delay at all*/ BT_ERR_FUNC("target packet length:%d, write success length:%d, retval = %d.\n", count, written, retval); } else { retval = written; } }else { retval = -EFAULT; BT_ERR_FUNC("target packet length:%d is not allowed, retval = %d.\n", count, retval); } OUT: up(&wr_mtx); return (retval); }
ssize_t BT_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) { INT32 retval = 0; INT32 written = 0; down(&wr_mtx); BT_DBG_FUNC("%s: count %zd pos %lld\n", __func__, count, *f_pos); if (retflag) { if (retflag == 1) { /* reset start */ retval = -88; BT_INFO_FUNC("MT662x reset Write: start\n"); } else if (retflag == 2) { /* reset end */ retval = -99; BT_INFO_FUNC("MT662x reset Write: end\n"); } goto OUT; } if (count > 0) { INT32 copy_size; if (count < BT_BUFFER_SIZE) { copy_size = count; } else { copy_size = BT_BUFFER_SIZE; BT_ERR_FUNC(" count > BT_BUFFER_SIZE\n"); } if (copy_from_user(&o_buf[0], &buf[0], copy_size)) { retval = -EFAULT; goto OUT; } /* pr_warn("%02x ", val); */ written = mtk_wcn_stp_send_data(&o_buf[0], copy_size, BT_TASK_INDX); if (0 == written) { retval = -ENOSPC; /*no windowspace is available, native process should not call BT_write with no delay at all */ BT_ERR_FUNC ("target packet length:%zd, write success length:%d, retval = %d.\n", count, written, retval); } else { retval = written; } } else { retval = -EFAULT; BT_ERR_FUNC("target packet length:%zd is not allowed, retval = %d.\n", count, retval); } OUT: up(&wr_mtx); return retval; }
INT32 wmt_ctrl_tx_ex ( const UINT8 *pData, const UINT32 size, UINT32 *writtenSize, const MTK_WCN_BOOL bRawFlag ) { P_DEV_WMT pDev = &gDevWmt; /* single instance */ INT32 iRet; if (NULL != writtenSize) { *writtenSize = 0; } /* sanity check */ if (0 == size) { WMT_WARN_FUNC("size to tx is 0\n"); osal_assert(size); return -1; } /* if STP is not enabled yet, can't use this function. Use tx_raw instead */ if ( !osal_test_bit(WMT_STAT_STP_OPEN, &pDev->state) || !osal_test_bit(WMT_STAT_STP_EN, &pDev->state) ) { WMT_ERR_FUNC("wmt state(0x%lx) \n", pDev->state); osal_assert(osal_test_bit(WMT_STAT_STP_EN, &pDev->state)); osal_assert(osal_test_bit(WMT_STAT_STP_OPEN, &pDev->state)); return -2; } /* sanity ok, proceeding tx operation */ /*retval = mtk_wcn_stp_send_data(data, size, WMTDRV_TYPE_WMT);*/ mtk_wcn_stp_flush_rx_queue(WMT_TASK_INDX); if (bRawFlag) { iRet = mtk_wcn_stp_send_data_raw(pData, size, WMT_TASK_INDX); } else { iRet = mtk_wcn_stp_send_data(pData, size, WMT_TASK_INDX); } if (iRet != size){ WMT_WARN_FUNC("write(%d) written(%d)\n", size, iRet); osal_assert(iRet == size); } if (writtenSize) { *writtenSize = iRet; } return 0; }
ssize_t BT_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) { INT32 retval = 0; INT32 write_size; INT32 written = 0; down(&wr_mtx); BT_DBG_FUNC("%s: count %zd pos %lld\n", __func__, count, *f_pos); if (rstflag) { if (rstflag == 1) { /* Reset start */ retval = -88; BT_INFO_FUNC("%s: detect whole chip reset start\n", __func__); } else if (rstflag == 2) { /* Reset end */ retval = -99; BT_INFO_FUNC("%s: detect whole chip reset end\n", __func__); } goto OUT; } if (count > 0) { if (count < BT_BUFFER_SIZE) { write_size = count; } else { write_size = BT_BUFFER_SIZE; BT_ERR_FUNC("%s: count > BT_BUFFER_SIZE\n", __func__); } if (copy_from_user(&o_buf[0], &buf[0], write_size)) { retval = -EFAULT; goto OUT; } written = mtk_wcn_stp_send_data(&o_buf[0], write_size, BT_TASK_INDX); if (0 == written) { retval = -ENOSPC; /* No space is available, native program should not call BT_write with no delay */ BT_ERR_FUNC ("Packet length %zd, sent length %d, retval = %d\n", count, written, retval); } else { retval = written; } } else { retval = -EFAULT; BT_ERR_FUNC("Packet length %zd is not allowed, retval = %d\n", count, retval); } OUT: up(&wr_mtx); return retval; }
/* * fm_cmd_tx() - send cmd to FM firmware and wait event * @buf - send buffer * @len - the length of cmd * @mask - the event flag mask * @ cnt - the retry conter * @timeout - timeout per cmd * Return 0, if success; error code, if failed */ fm_s32 fm_cmd_tx(fm_u8 *buf, fm_u16 len, fm_s32 mask, fm_s32 cnt, fm_s32 timeout, fm_s32(*callback) (struct fm_res_ctx *result)) { fm_s32 ret_time = 0; struct task_struct *task = current; struct fm_trace_t trace; if ((NULL == buf) || (len < 0) || (0 == mask) || (cnt > SW_RETRY_CNT_MAX) || (timeout > SW_WAIT_TIMEOUT_MAX)) { WCN_DBG(FM_ERR | LINK, "cmd tx, invalid para\n"); return -FM_EPARA; } FM_EVENT_CLR(link_event->ln_event, mask); #ifdef FM_TRACE_ENABLE trace.type = buf[0]; trace.opcode = buf[1]; trace.len = len - 4; trace.tid = (fm_s32) task->pid; fm_memset(trace.pkt, 0, FM_TRACE_PKT_SIZE); fm_memcpy(trace.pkt, &buf[4], (trace.len > FM_TRACE_PKT_SIZE) ? FM_TRACE_PKT_SIZE : trace.len); #endif sw_retry: #ifdef FM_TRACE_ENABLE if (fm_true == FM_TRACE_FULL(cmd_fifo)) { FM_TRACE_OUT(cmd_fifo, NULL); } FM_TRACE_IN(cmd_fifo, &trace); #endif /* send cmd to FM firmware */ if ((ret_time = mtk_wcn_stp_send_data(buf, len, FM_TASK_INDX)) <= 0) { WCN_DBG(FM_EMG | LINK, "send data over stp failed[%d]\n", ret_time); return -FM_ELINK; } /* wait the response form FM firmware */ ret_time = FM_EVENT_WAIT_TIMEOUT(link_event->ln_event, mask, timeout); if (!ret_time) { if (0 < cnt--) { WCN_DBG(FM_WAR | LINK, "wait even timeout, [retry_cnt=%d], pid=%d\n", cnt, task->pid); fm_print_cmd_fifo(); fm_print_evt_fifo(); return -FM_EFW; goto sw_retry; /* retry if timeout and retry cnt > 0 */ } else { WCN_DBG(FM_ALT | LINK, "fatal error, SW retry failed, reset HW\n"); return -FM_EFW; } } FM_EVENT_CLR(link_event->ln_event, mask); if (callback) { callback(&link_event->result); } return 0; }