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;
}
