M4U_STATUS_ENUM MTKM4UDrv::m4u_insert_wrapped_range(M4U_MODULE_ID_ENUM eModuleID,
M4U_PORT_ID_ENUM portID,
const unsigned int MVAStart,
const unsigned int MVAEnd)
{
M4U_WRAP_DES_T m4u_wrap;
m4u_wrap.eModuleID = eModuleID;
m4u_wrap.ePortID = portID;
m4u_wrap.MVAStart = MVAStart;
m4u_wrap.MVAEnd = MVAEnd;
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_insert_wrapped_range failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_INSERT_TLB_RANGE, &m4u_wrap))
{
M4UMSG(" ioctl MTK_M4U_T_INSERT_TLB_RANGE fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_invalid_tlb_range(M4U_MODULE_ID_ENUM eModuleID,
unsigned int MVAStart,
unsigned int MVAEnd)
{
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.MVAStart = MVAStart;
m4u_module.MVAEnd = MVAEnd;
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_invalid_tlb_range failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_INVALID_TLB_RANGE, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_INVALID_TLB_RANGE fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_query_mva(M4U_MODULE_ID_ENUM eModuleID,
const unsigned int BufAddr,
const unsigned int BufSize,
unsigned int *pRetMVAAddr)
{
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.BufAddr = BufAddr;
m4u_module.BufSize = BufSize;
*pRetMVAAddr = 0;
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_query_mva failed \n");
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_QUERY_MVA, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_QUERY_MVA fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
return M4U_STATUS_KERNEL_FAULT;
}
else
{
*pRetMVAAddr = m4u_module.MVAStart;
return M4U_STATUS_OK;
}
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_monitor_stop(M4U_PORT_ID_ENUM PortID)
{
M4U_MODULE_ID_ENUM eModuleID = m4u_get_module_by_port(PortID);
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_monitor_stop failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_MONITOR_STOP, &PortID))
{
M4UMSG(" ioctl MTK_M4U_T_MONITOR_STOP fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
int m4u_dbg_dump_nolock(M4U_MODULE_ID_ENUM eModuleId)
{
struct m4u_dbg_fifo *pfifo = NULL;
struct m4u_dbg_info *pbuffer;
int index;
int i;
M4UMSG("==== dump event for module: %s(%d) =====\n", m4u_get_module_name(eModuleId), eModuleId);
if(eModuleId >= M4U_CLNTMOD_MAX)
{
M4UMSG("[m4u_dbg] moduleId > M4U_CLNTMOD_MAX : %d\n", (unsigned int)eModuleId);
return -1;
}
pfifo = mfifo+eModuleId;
index = pfifo->top;
for(i=0; i<pfifo->max_num; i++)
{
index--;
if(index < 0) index = pfifo->max_num-1;
pbuffer = pfifo->buffer + index;
if(pbuffer->event != 0)
{
M4UMSG("[m4u_dbg](%d) evt=%s,va=0x%x,size=0x%x,mva=0x%x,tgid=%d\n", index,
__m4u_evt_name(pbuffer->event),pbuffer->va,pbuffer->size,pbuffer->mva,pbuffer->tgid);
}
}
return 0;
}
int MTKM4UDrv::m4u_cache_sync(M4U_PORT_ID port,
M4U_CACHE_SYNC_ENUM eCacheSync,
unsigned long va,
unsigned int size,
unsigned int mva)
{
M4U_CACHE_STRUCT m4u_cache;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_cache_sync failed \n");
m4u_dump_backtrace();
return -1;
}
m4u_cache.port = port;
m4u_cache.eCacheSync = eCacheSync;
m4u_cache.va = va;
m4u_cache.size = size;
m4u_cache.mva = mva;
if(ioctl(mFileDescriptor, MTK_M4U_T_CACHE_SYNC, &m4u_cache) < 0)
{
M4UMSG(" ioctl MTK_M4U_T_CACHE_SYNC fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return -1;
}
else
{
return 0;
}
}
///> native
int MTKM4UDrv::m4u_config_port(M4U_PORT_STRUCT* pM4uPort)
{
if(NULL==pM4uPort)
{
M4UMSG("m4u_config_port failed, input M4U_PORT_STRUCT* is null! \n");
m4u_dump_backtrace();
return -1;
}
if(mFileDescriptor<0)
{
M4UMSG("m4u_config_port failed \n");
m4u_dump_backtrace();
return -1;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_CONFIG_PORT, pM4uPort) < 0)
{
M4UMSG(" ioctl MTK_M4U_T_CONFIG_PORT fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return -1;
}
else
{
return 0;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_cache_flush_all(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_cache_sync failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_CACHE_FLUSH_ALL, NULL))
{
M4UMSG(" ioctl MTK_M4U_T_CACHE_FLUSH_ALL fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
int MTKM4UDrv::m4u_dump_pagetable(M4U_PORT_ID port,
const unsigned long BufAddr,
const unsigned int BufSize,
unsigned int MVAStart)
{
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.port = port;
m4u_module.BufAddr = BufAddr;
m4u_module.BufSize = BufSize;
m4u_module.MVAStart = MVAStart;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_dump_pagetable failed \n");
m4u_dump_backtrace();
return -1;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_DUMP_PAGETABLE, &m4u_module) < 0)
{
M4UMSG(" ioctl MTK_M4U_T_DUMP_PAGETABLE fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return -1;
}
else
{
return 0;
}
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_dump_info(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_dump_info failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_DUMP_INFO, &eModuleID))
{
M4UMSG(" ioctl MTK_M4U_T_DUMP_INFO fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_dump_pagetable(M4U_MODULE_ID_ENUM eModuleID,
const unsigned int BufAddr,
const unsigned int BufSize,
unsigned int MVAStart)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.BufAddr = BufAddr;
m4u_module.BufSize = BufSize;
m4u_module.MVAStart = MVAStart;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_dump_pagetable failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_DUMP_PAGETABLE, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_DUMP_PAGETABLE fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_dump_reg(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_dump_reg failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
//M4UMSG("before m4u_dump_reg, module=%d", eModuleID);
if(ioctl(mFileDescriptor, MTK_M4U_T_DUMP_REG, &eModuleID))
{
M4UMSG(" ioctl MTK_M4U_T_DUMP_REG fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
//M4UMSG("after m4u_dump_reg, module=%d", eModuleID);
return M4U_STATUS_OK;
}
}
int MTKM4UDrv::m4u_dealloc_mva(M4U_PORT_ID port,
unsigned long va, unsigned int size,
unsigned int mva)
{
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.port = port;
m4u_module.MVAStart = mva;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_dealloc_mva failed \n");
m4u_dump_backtrace();
return -1;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_DEALLOC_MVA, &m4u_module) < 0)
{
M4UMSG(" ioctl MTK_M4U_T_DEALLOC_MVA fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
//munlock((void*)va, size);
return -1;
}
else
{
//munlock((void*)va,size);
return 0;
}
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_reset_mva_release_tlb(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_reset_mva_release_tlb failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_RESET_MVA_RELEASE_TLB, &eModuleID))
{
M4UMSG(" ioctl MTK_M4U_T_RESET_MVA_RELEASE_TLB fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_config_port_rotator(M4U_PORT_STRUCT_ROTATOR* pM4uPort)
{
M4U_MODULE_ID_ENUM eModuleID = m4u_get_module_by_port(pM4uPort->ePortID);
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(NULL==pM4uPort)
{
M4UMSG("m4u_config_port_rotator failed, input M4U_PORT_STRUCT_ROTATOR* is null! \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(mFileDescriptor<0)
{
M4UMSG("m4u_config_port_rotator failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_CONFIG_PORT_ROTATOR, pM4uPort))
{
M4UMSG(" ioctl MTK_M4U_T_CONFIG_PORT_ROTATOR fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
void init_mlock_cnt(void)
{
/* allocate pMlock_cnt */
mlock_cnt_size = max_pfn + PHYS_PFN_OFFSET;
pMlock_cnt = (unsigned char *)vmalloc(mlock_cnt_size);
if (!pMlock_cnt) {
M4UMSG("allocate for pMlock_cnt error! size=%d.\n", mlock_cnt_size);
return;
}
memset(pMlock_cnt, 0, mlock_cnt_size);
M4UMSG("allocate for pMlock_cnt done: size=%d\n", mlock_cnt_size);
}
int m4u_dbg_fifo_init(void)
{
int i;
int total_num = 0;
struct m4u_dbg_info* pInfo = NULL;
mfifo = (struct m4u_dbg_fifo*)kmalloc(sizeof(struct m4u_dbg_fifo)*M4U_CLNTMOD_MAX, GFP_KERNEL);
if(mfifo == NULL)
{
M4UMSG("[m4u_dbg] kmalloc failed for mfifo\n");
goto error_out;
}
for(i=0; i<M4U_CLNTMOD_MAX; i++)
{
total_num += m4u_dbg_nums[i];
}
M4UMSG("size(m4u_dbg_fifo)=%d, size(m4u_dbg_info)=%d, size(buffer)=%d\n",
sizeof(struct m4u_dbg_fifo), sizeof(struct m4u_dbg_info), sizeof(struct m4u_dbg_info)*total_num);
pInfo = (struct m4u_dbg_info*) kzalloc(sizeof(struct m4u_dbg_info)*total_num, GFP_KERNEL);
if(pInfo == NULL)
{
M4UMSG("[m4u_dbg] kmalloc failed for pInfo\n");
goto error_out;
}
for(i=0; i<M4U_CLNTMOD_MAX; i++)
{
pInfo += m4u_dbg_nums[i];
mfifo[i].buffer = pInfo;
mfifo[i].top = 0;
mfifo[i].max_num = m4u_dbg_nums[i];
spin_lock_init(&(mfifo[i].lock));
}
return 0;
error_out:
if(mfifo != NULL)
kfree(mfifo);
if(pInfo != NULL)
kfree(pInfo);
return -1;
}
void init_mlock_cnt(void)
{
//allocate pMlock_cnt
mlock_cnt_size = max_pfn + PHYS_PFN_OFFSET;
pMlock_cnt= (unsigned char*) vmalloc(mlock_cnt_size);
if(!pMlock_cnt)
{
M4UMSG("allocate for pMlock_cnt error! size=%d.\n", mlock_cnt_size);
return;
}
//printk("max_pfn=%d, offset=%d\n", max_pfn, PHYS_PFN_OFFSET );
memset(pMlock_cnt, 0, mlock_cnt_size);
M4UMSG("allocate for pMlock_cnt done: size=%d\n", mlock_cnt_size);
}
void* mva_get_priv_ext(unsigned int mva)
{
void *priv = NULL;
int index;
unsigned long irq_flags;
index = MVAGRAPH_INDEX(mva);
if(index==0 || index>MVA_MAX_BLOCK_NR)
{
M4UMSG("mvaGraph index is 0. mva=0x%x\n", mva);
return NULL;
}
spin_lock_irqsave(&gMvaGraph_lock, irq_flags);
//find prev head/tail of this region
while(mvaGraph[index]==0)
index--;
if(MVA_IS_BUSY(index))
{
priv = mvaInfoGraph[index];
}
spin_unlock_irqrestore(&gMvaGraph_lock, irq_flags);
return priv;
}
bool MTKM4UDrv::m4u_print_m4u_enable_status()
{
for(int i=0; i<M4U_CLNTMOD_MAX; i++)
{
M4UMSG("module(%d)\t:\t%d\n", i, mUseM4U[i]);
}
return true;
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_cache_sync(M4U_MODULE_ID_ENUM eModuleID,
M4U_CACHE_SYNC_ENUM eCacheSync,
unsigned int BufAddr,
unsigned int BufSize)
{
M4UMSG("error!! use old m4u_cache_sync interface!!\n");
return -1;
}
bool MTKM4UDrv::m4u_check_m4u_en(M4U_MODULE_ID_ENUM eModuleID)
{
if(!mUseM4U[eModuleID])
{
M4UMSG("warning: call m4u function but didnot enable m4u function. ID: %d\n", eModuleID);
}
return mUseM4U[eModuleID];
}
MTKM4UDrv::~MTKM4UDrv(void)
{
if(-1!=mFileDescriptor)
{
if(ioctl(mFileDescriptor, MTK_M4U_T_M4UDrv_DECONSTRUCT, NULL))
{
M4UMSG(" ioctl MTK_M4U_T_M4UDrv_DECONSTRUCT fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
}
M4UINFO("~MTKM4UDrv close m4u fd=%d, obj=0x%x\n", mFileDescriptor, (unsigned int)&mFileDescriptor);
close(mFileDescriptor);
}
else
{
M4UMSG("warning: ~MTKM4UDrv fd=%d, obj=0x%x\n", mFileDescriptor, (unsigned int)&mFileDescriptor);
}
mFileDescriptor = -1;
}
int MTKM4UDrv::m4u_config_port_array(struct m4u_port_array * port_array)
{
if(mFileDescriptor<0)
{
M4UMSG("m4u_config_port failed \n");
m4u_dump_backtrace();
return -1;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_CONFIG_PORT_ARRAY, port_array) < 0)
{
M4UMSG(" ioctl MTK_M4U_T_CONFIG_PORT fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return -1;
}
else
{
return 0;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_manual_insert_entry(M4U_MODULE_ID_ENUM eModuleID,
unsigned int EntryMVA,
bool Lock)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
M4U_MOUDLE_STRUCT m4u_module;
if(0)
{
m4u_module.eModuleID = eModuleID;
m4u_module.EntryMVA = EntryMVA;
m4u_module.Lock = Lock;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_insert_entry failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_MANUAL_INSERT_ENTRY, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_MANUAL_INSERT_ENTRY fail! fd=%d, %d, %s \n", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
else
{
return M4U_STATUS_OK;
}
}
static void m4u_dump_backtrace(void)
{
char name[35] = "/data/m4u_dump";
//sprintf(name, "/data/m4u_dump_%d_%d.txt", getpid(), gettid());
M4UMSG("m4u dump back trace when error============> \n");
rtt_dump_backtrace(getpid(), gettid(), name);
FILE *fp = fopen(name, "r");
if(fp)
{
char tmp[101] = "";
int cnt=0;
while( (fgets(tmp, 100, fp) != NULL) && (cnt<500) )
{
cnt++;
M4UMSG("[%d]: %s", cnt, tmp);
}
fclose(fp);
}
//unlink(name);
}
int MTKM4UDrv::m4u_cache_flush_all(M4U_PORT_ID port)
{
if(mFileDescriptor<0 )
{
M4UMSG("m4u_cache_sync failed \n");
m4u_dump_backtrace();
return -1;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_CACHE_FLUSH_ALL, NULL) < 0)
{
M4UMSG(" ioctl MTK_M4U_T_CACHE_FLUSH_ALL fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return -1;
}
else
{
return 0;
}
}
/**
* @brief :
* @param
* @return
*/
int MTKM4UDrv::m4u_monitor_stop(M4U_PORT_ID PortID)
{
if(mFileDescriptor<0 )
{
M4UMSG("m4u_monitor_stop failed \n");
m4u_dump_backtrace();
return -1;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_MONITOR_STOP, &PortID) < 0)
{
M4UMSG(" ioctl MTK_M4U_T_MONITOR_STOP fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return -1;
}
else
{
return 0;
}
}
/**
* @brief :
* @param
* @return
*/
int MTKM4UDrv::m4u_power_off(M4U_PORT_ID port)
{
if(mFileDescriptor<0 )
{
M4UMSG("m4u_power_off failed \n");
m4u_dump_backtrace();
return -1;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_POWER_OFF, &port) < 0)
{
M4UMSG(" ioctl MTK_M4U_T_POWER_OFF fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return -1;
}
else
{
return 0;
}
}
int MTKM4UDrv::m4u_config_mau(M4U_PORT_ID port, unsigned int mva, unsigned int size,
bool write, bool enable, bool force)
{
M4U_MAU_STRUCT mau;
mau.port = port;
mau.mva = mva;
mau.size = size;
mau.write = write;
mau.enable = enable;
mau.force = force;
char value[PROPERTY_VALUE_MAX];
int u4Enable = 0;
property_get("mtk.m4u.mau.enable", value, "0");
u4Enable = atoi(value);
if(u4Enable == 0)
{
M4UMSG("mtk.m4u.mau.enable: %d\n", u4Enable);
return -1;
}
if(mFileDescriptor<0)
{
M4UMSG("m4u_config_mau failed \n");
m4u_dump_backtrace();
return -1;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_CONFIG_MAU, &mau) < 0)
{
M4UMSG(" ioctl MTK_M4U_T_CONFIG_MAU fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return -1;
}
else
{
return 0;
}
}
