/* ------------------------------------------------------------------------------ */
static int SYSRAM_Release(struct inode *pInode, struct file *pFile)
{
MUINT32 Index = 0;
MUINT32 Sec = 0, USec = 0;
MUINT64 Time64 = 0;
SYSRAM_PROC_STRUCT *pProc;
/* */
SYSRAM_GetTime(&Time64, &Sec, &USec);
/* */
LOG_MSG("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm, current->pid, current->tgid, Sec, USec);
/* */
if (pFile->private_data != NULL) {
pProc = (SYSRAM_PROC_STRUCT *) (pFile->private_data);
/* */
if (pProc->Pid != 0 || pProc->Tgid != 0 || pProc->Table != 0) {
/* */
LOG_WRN("Proc:Name(%s),pid(%d),tgid(%d),Table(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid, pProc->Tgid, pProc->Table, pProc->TimeS, pProc->TimeUS);
/* */
if (pProc->Table) {
LOG_WRN("Force to release");
/*
LOG_WRN("Proc:Name(%s),pid(%d),tgid(%d),Table(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->Table,
pProc->TimeS,
pProc->TimeUS);
*/
SYSRAM_DumpLayout();
/* */
for (Index = 0; Index < SYSRAM_USER_AMOUNT; Index++) {
if (pProc->Table & (1 << Index)) {
SYSRAM_IOC_Free((SYSRAM_USER_ENUM) Index);
}
}
}
}
/* */
kfree(pFile->private_data);
pFile->private_data = NULL;
} else {
LOG_WRN("private_data is NULL");
/*
LOG_WRN("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
*/
}
/* */
return 0;
}
//-----------------------------------------------------------------------------
static void CamPipeMgr_RemovePipeInfo(MUINT32 PipeMask)
{
MUINT32 i;
//
//LOG_MSG("PipeMask(0x%08X)",PipeMask);
//
CamPipeMgr.PipeMask &= (~PipeMask);
//
for(i=0;i<CAM_PIPE_MGR_PIPE_AMOUNT;i++)
{
if((1<<i) & PipeMask)
{
if( CamPipeMgr.PipeInfo[i].Pid != 0 &&
CamPipeMgr.PipeInfo[i].Tgid != 0)
{
CamPipeMgr.PipeInfo[i].Pid = 0;
CamPipeMgr.PipeInfo[i].Tgid = 0;
strcpy(CamPipeMgr.PipeInfo[i].ProcName,CAM_PIPE_MGR_PROC_NAME);
}
else
{
LOG_WRN("PipeMask(0x%08lX),Pipe(%ld,%s),Pid(%d),Tgid(%d),Time(%ld.%06ld)",
PipeMask,
i,
CamPipeMgr.PipeInfo[i].ProcName,
CamPipeMgr.PipeInfo[i].Pid,
CamPipeMgr.PipeInfo[i].Tgid,
CamPipeMgr.PipeInfo[i].TimeS,
CamPipeMgr.PipeInfo[i].TimeUS);
}
}
}
}
int lis2ds12_trigger_set(struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct lis2ds12_data *data = dev->driver_data;
u8_t buf[6];
__ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY);
gpio_pin_disable_callback(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN);
data->data_ready_handler = handler;
if (handler == NULL) {
LOG_WRN("lis2ds12: no handler");
return 0;
}
/* re-trigger lost interrupt */
if (data->hw_tf->read_data(data, LIS2DS12_REG_OUTX_L,
buf, sizeof(buf)) < 0) {
LOG_ERR("status reading error");
return -EIO;
}
data->data_ready_trigger = *trig;
lis2ds12_init_interrupt(dev);
gpio_pin_enable_callback(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN);
return 0;
}
static void telnet_accept(struct net_context *client,
struct sockaddr *addr,
socklen_t addrlen,
int error,
void *user_data)
{
if (error) {
LOG_ERR("Error %d", error);
goto error;
}
if (client_cnx) {
LOG_WRN("A telnet client is already in.");
goto error;
}
if (net_context_recv(client, telnet_recv, 0, NULL)) {
LOG_ERR("Unable to setup reception (family %u)",
net_context_get_family(client));
goto error;
}
LOG_DBG("Telnet client connected (family AF_INET%s)",
net_context_get_family(client) == AF_INET ? "" : "6");
orig_printk_hook = __printk_get_hook();
__printk_hook_install(telnet_console_out);
client_cnx = client;
k_timer_start(&send_timer, TELNET_TIMEOUT, TELNET_TIMEOUT);
return;
error:
net_context_put(client);
}
//----------------------------------------------------------------------------
MBOOL PipeMgrDrvImp::Uninit(void)
{
MBOOL Result = MTRUE;
//
Mutex::Autolock lock(mLock);
//
if(mUser <= 0)
{
LOG_WRN("No user(%d)",mUser);
goto EXIT;
}
//
android_atomic_dec(&mUser);
//
if(mUser == 0)
{
LOG_MSG("Last user(%d)",mUser);
}
else
{
LOG_MSG("More user(%d)",mUser);
goto EXIT;
}
//
if(mFd >= 0)
{
close(mFd);
mFd = -1;
}
//
EXIT:
return Result;
}
//----------------------------------------------------------------------------
static int ResMgr_release(
struct inode* pInode,
struct file* pFile)
{
RES_MGR_OPEN_INFO_STRUCT* pOpenInfo;
//
LOG_MSG("Current:process(%s), pid(%d), tgid(%d)\r\n", current->comm, current->pid, current->tgid);
//
if(pFile->private_data != NULL)
{
pOpenInfo = (RES_MGR_OPEN_INFO_STRUCT*)pFile->private_data;
LOG_MSG("OpenInfo:pid(%d), tgid(%d), Resource(0x%08lX)\r\n",pOpenInfo->Pid,pOpenInfo->Tgid,pOpenInfo->Resource);
if(pOpenInfo->Resource)
{
LOG_WRN("free resource and memory,OpenInfo:pid(%d), tgid(%d), Resource(0x%08lX)\r\n",pOpenInfo->Pid,pOpenInfo->Tgid,pOpenInfo->Resource);
}
//
ResMgr_SpinLock();
if(pOpenInfo->Resource)
{
ResMgr_ResUnlock(pOpenInfo->Resource);
pOpenInfo->Resource = 0;
}
kfree(pFile->private_data);
pFile->private_data = NULL;
ResMgr_SpinUnlock();
}
//
//LOG_MSG("OK\r\n");
return 0;
}
/* ------------------------------------------------------------------------------ */
static int SYSRAM_mmap(struct file *pFile, struct vm_area_struct *pVma)
{
/* LOG_MSG(""); */
long length = 0;
MUINT32 pfn = 0x0;
pVma->vm_page_prot = pgprot_noncached(pVma->vm_page_prot);
length = (long)(pVma->vm_end - pVma->vm_start);
pfn = pVma->vm_pgoff << PAGE_SHIFT;
LOG_WRN
("pVma->vm_pgoff(0x%lx),phy(0x%lx),pVmapVma->vm_start(0x%lx),pVma->vm_end(0x%lx),length(0x%lx)",
pVma->vm_pgoff, pVma->vm_pgoff << PAGE_SHIFT, pVma->vm_start, pVma->vm_end, length);
if ((length > ISP_VALID_REG_RANGE) || (pfn < IMGSYS_BASE_ADDR)
|| (pfn > (IMGSYS_BASE_ADDR + ISP_VALID_REG_RANGE))) {
LOG_ERR
("mmap range error : vm_start(0x%lx),vm_end(0x%lx),length(0x%lx),pfn(0x%lx)!",
pVma->vm_start, pVma->vm_end, length, pfn);
return -EAGAIN;
}
if (remap_pfn_range(pVma,
pVma->vm_start,
pVma->vm_pgoff, pVma->vm_end - pVma->vm_start, pVma->vm_page_prot)) {
LOG_ERR("fail");
return -EAGAIN;
}
return 0;
}
//------------------------------------------------------------------------------
static int SYSRAM_mmap(
struct file* pFile,
struct vm_area_struct* pVma)
{
//LOG_MSG("");
pVma->vm_page_prot = pgprot_noncached(pVma->vm_page_prot);
long length = pVma->vm_end - pVma->vm_start;
MUINT32 pfn=pVma->vm_pgoff<<PAGE_SHIFT;//page from number, physical address of kernel memory
LOG_WRN("pVma->vm_pgoff(0x%x),phy(0x%x),pVmapVma->vm_start(0x%x),pVma->vm_end(0x%x),length(0x%x)",\
pVma->vm_pgoff,pVma->vm_pgoff<<PAGE_SHIFT,pVma->vm_start,pVma->vm_end,length);
if((length>ISP_VALID_REG_RANGE) || (pfn<IMGSYS_BASE_ADDR) || (pfn>(IMGSYS_BASE_ADDR+ISP_VALID_REG_RANGE)))
{
LOG_ERR("mmap range error : vm_start(0x%x),vm_end(0x%x),length(0x%x),pfn(0x%x)!",pVma->vm_start,pVma->vm_end,length,pfn);
return -EAGAIN;
}
if(remap_pfn_range(
pVma,
pVma->vm_start,
pVma->vm_pgoff,
pVma->vm_end - pVma->vm_start,
pVma->vm_page_prot))
{
LOG_ERR("fail");
return -EAGAIN;
}
return 0;
}
TResult CKKMApi::readEOT()
{
LOG_DBG("readEOT ==>");
//todo append repeats
TResult nRet = kResult_Success;
QByteArray readData;
nRet = readChunk(readData, defs::nReadEOTTimeout);
if (nRet == kResult_Success)
{
bool bCorrect = (readData == QByteArray(&defs::cEOT,1));
LOG_DBG("readEOT : "<<bCorrect <<" '"<<ba2hex(readData)<<"'");
while (!bCorrect)
{
LOG_WRN("repeat readEOT");
nRet = readChunk(readData, defs::nReadEOTTimeout);
if (nRet != kResult_Success)
break;
bCorrect = (readData == QByteArray(&defs::cEOT,1));
LOG_DBG("readEOT : "<<bCorrect <<" '"<<ba2hex(readData)<<"'");
}
}
LOG_DBG("readEOT <==");
return nRet;
}
int usb_dc_ep_enable(const u8_t ep)
{
u8_t ep_abs_idx = EP_ABS_IDX(ep);
/* endpoint0 OUT is primed by controller driver when configure this
* endpoint.
*/
if (!ep_abs_idx) {
return 0;
}
if (s_Device.eps[ep_abs_idx].ep_occupied) {
LOG_WRN("endpoint 0x%x already enabled", ep);
return -EBUSY;
}
if ((EP_ADDR2IDX(ep) != USB_CONTROL_ENDPOINT) && (EP_ADDR2DIR(ep) == USB_EP_DIR_OUT)) {
s_Device.interface->deviceRecv(s_Device.controllerHandle,
ep,
(u8_t *)s_Device.eps[ep_abs_idx].block.data,
(uint32_t)s_Device.eps[ep_abs_idx].ep_mps);
s_Device.eps[ep_abs_idx].ep_occupied = true;
} else {
/* control enpoint just be enabled before enumeration,
* when running here, setup has been primed.
*/
s_Device.eps[ep_abs_idx].ep_occupied = true;
}
return 0;
}
//-----------------------------------------------------------------------------
MBOOL
TdriMgrImp::
flushSetting(
ISP_DRV_CQ_ENUM ispCq
)
{
LOCAL_PROFILING_LOG_AUTO_START(Event_TdriMgr);
LOCAL_PROFILING_LOG_PRINT("flushSetting");
LOG_INF("E:Cq(%d)",ispCq);
//
if(tdriMgrCqMap[ispCq].tdriMgrCQ == TPIPE_DRV_CQ01) {
pIspDrv->lockSemaphoreCq1();
// flush setting
::memset((char*)&tdriMgrInfo[TPIPE_DRV_CQ01].tdriTurningSetting, 0x00, sizeof(TDRI_MGR_TPIPE_TABLE_TURNING));
::memset((char*)&tdriMgrInfo[TPIPE_DRV_CQ01].tdriMgrCfg, 0x00, sizeof(TdriDrvCfg));
tdriMgrInfo[TPIPE_DRV_CQ01].tdriMgrCfg.updateTdri.updateType = TPIPE_DRV_UPDATE_TYPE_CQ1_TURNING_SAVE;
refreshTableSetting(TPIPE_DRV_CQ01, 0xffffffff); // refresh all setting
tdriMgrInfo[TPIPE_DRV_CQ01].tdriMgrCfg.updateTdri.partUpdateFlag = 0xffffffff; // clean Tpipe update flag
handleTpipeTable(TPIPE_DRV_CQ01);
pIspDrv->setTurnTopEn1(ISP_DRV_CQ01, ISP_DRV_TURNING_TOP_RESET);
pIspDrv->setTurnTopEn2(ISP_DRV_CQ01, ISP_DRV_TURNING_TOP_RESET);
pIspDrv->setTurnTopDma(ISP_DRV_CQ01, ISP_DRV_TURNING_TOP_RESET);
pIspDrv->flushTurnCqTable(ISP_DRV_CQ01);
//
pIspDrv->unlockSemaphoreCq1();
}
else if(tdriMgrCqMap[ispCq].tdriMgrCQ == TPIPE_DRV_CQ02) {
pIspDrv->lockSemaphoreCq2();
// flush setting
::memset((char*)&tdriMgrInfo[TPIPE_DRV_CQ02].tdriTurningSetting, 0x00, sizeof(TDRI_MGR_TPIPE_TABLE_TURNING));
::memset((char*)&tdriMgrInfo[TPIPE_DRV_CQ02].tdriMgrCfg, 0x00, sizeof(TdriDrvCfg));
tdriMgrInfo[TPIPE_DRV_CQ02].tdriMgrCfg.updateTdri.updateType = TPIPE_DRV_UPDATE_TYPE_CQ2_TURNING_SAVE;
refreshTableSetting(TPIPE_DRV_CQ02, 0xffffffff); // refresh all setting
tdriMgrInfo[TPIPE_DRV_CQ02].tdriMgrCfg.updateTdri.partUpdateFlag = 0xffffffff; // clean Tpipe update flag
handleTpipeTable(TPIPE_DRV_CQ02);
pIspDrv->setTurnTopEn1(ISP_DRV_CQ02, ISP_DRV_TURNING_TOP_RESET);
pIspDrv->setTurnTopEn2(ISP_DRV_CQ02, ISP_DRV_TURNING_TOP_RESET);
pIspDrv->setTurnTopDma(ISP_DRV_CQ02, ISP_DRV_TURNING_TOP_RESET);
pIspDrv->flushTurnCqTable(ISP_DRV_CQ02);
//
pIspDrv->unlockSemaphoreCq2();
}
else {
LOG_WRN("not support this tMgrCq(%d) for flush",tdriMgrCqMap[ispCq].tdriMgrCQ);
return MFALSE;
}
LOG_INF("X\n",ispCq);
LOCAL_PROFILING_LOG_PRINT("End flushSetting");
return MTRUE;
}
void ControlFlow::process_signal(int signum) {
switch(signum) {
case SIGTERM:
case SIGPIPE:
case SIGUSR1:
running_ = false;
LOG_DBG("Signal received: %d", signum);
break;
default:
LOG_WRN("Unknown signal received: %d", signum);
}
}
static int lsm6dsl_attr_set(struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lsm6dsl_accel_config(dev, chan, attr, val);
case SENSOR_CHAN_GYRO_XYZ:
return lsm6dsl_gyro_config(dev, chan, attr, val);
default:
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
//-----------------------------------------------------------------------------
MBOOL ResMgrDrvImp::CloseHdmi(MBOOL En)
{
MBOOL Result = MTRUE;
//
LOG_MSG("En(%d)",En);
//
if(mUser <= 0)
{
LOG_ERR("No user");
Result = MFALSE;
goto EXIT;
}
//
if(mFdHdmiTx < 0)
{
mFdHdmiTx = open(RES_MGR_DRV_DEVNAME_HDMITX, O_RDONLY, 0);
if(mFdHdmiTx < 0)
{
LOG_WRN("HDMITX kernel open fail, errno(%d):%s",errno,strerror(errno));
}
}
//
if(mFdHdmiTx >= 0)
{
if(En)
{
if(ioctl(mFdHdmiTx, MTK_HDMI_FORCE_CLOSE, 0) < 0)
{
LOG_ERR("HDMI_FORCE_CLOSE fail, errno(%d):%s",errno,strerror(errno));
Result = MFALSE;
}
}
else
{
if(ioctl(mFdHdmiTx, MTK_HDMI_FORCE_OPEN, 0) < 0)
{
LOG_ERR("HDMI_FORCE_OPEN fail, errno(%d):%s",errno,strerror(errno));
Result = MFALSE;
}
}
}
//
EXIT:
//LOG_MSG("Result(%d)",Result);
return Result;
}
int usb_dc_attach(void)
{
s_Device.eps = &s_ep_ctrl[0];
if (s_Device.attached) {
LOG_WRN("already attached");
return 0;
}
s_Device.interface = (const usb_device_controller_interface_struct_t *)(&s_UsbDeviceEhciInterface);
if (kStatus_USB_Success != s_Device.interface->deviceInit(CONTROLLER_ID, &s_Device, &s_Device.controllerHandle)) {
return -EINVAL;
}
/* Connect and enable USB interrupt */
IRQ_CONNECT(DT_USBD_MCUX_EHCI_IRQ, DT_USBD_MCUX_EHCI_IRQ_PRI,
usb_isr_handler, 0, 0);
irq_enable(DT_USBD_MCUX_EHCI_IRQ);
s_Device.attached = 1;
LOG_DBG("attached");
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlRun, NULL);
return 0;
}
//----------------------------------------------------------------------------
static int ResMgr_flush(
struct file* pFile,
fl_owner_t Id)
{
RES_MGR_OPEN_INFO_STRUCT* pOpenInfo;
//
LOG_MSG("Current:process(%s), pid(%d), tgid(%d)\r\n", current->comm, current->pid, current->tgid);
//
if(pFile->private_data != NULL)
{
pOpenInfo = (RES_MGR_OPEN_INFO_STRUCT*)pFile->private_data;
LOG_MSG("OpenInfo:pid(%d), tgid(%d), Resource(0x%08lX)\r\n",pOpenInfo->Pid,pOpenInfo->Tgid,pOpenInfo->Resource);
if(pOpenInfo->Tgid == 0)
{
if(pOpenInfo->Resource != 0)
{
LOG_ERR("No Tgid info about resource\r\n");
LOG_ERR("OpenInfo:pid(%d), tgid(%d), Resource(0x%08lX)\r\n",pOpenInfo->Pid,pOpenInfo->Tgid,pOpenInfo->Resource);
LOG_ERR("Current:process(%s), pid(%d), tgid(%d)\r\n",current->comm , current->pid, current->tgid);
}
}
else
if( (pOpenInfo->Tgid == current->tgid) ||
((pOpenInfo->Tgid != current->tgid) && (strcmp(current->comm, "binder") == 0)))
{
if(pOpenInfo->Resource)
{
LOG_WRN("free resource and memory,OpenInfo:pid(%d), tgid(%d), Resource(0x%08lX)\r\n",pOpenInfo->Pid,pOpenInfo->Tgid,pOpenInfo->Resource);
ResMgr_SpinLock();
ResMgr_ResUnlock(pOpenInfo->Resource);
pOpenInfo->Resource = 0;
ResMgr_SpinUnlock();
}
}
}
//
//LOG_MSG("OK\r\n");
return 0;
}
//PrimalAlgorithm* ClimateAlgorithmFactory::make(const std::unique_ptr<NumericsCoreParams>& aNumCoreParams, N_Configuration::Component* aClimateAlgo)
PrimalAlgorithm* ClimateAlgorithmFactory::make(const NumericsCoreParams& aNumCoreParams, const N_Configuration::Component& aClimateAlgo)
{
//if (aClimateAlgo)
//{
if (aClimateAlgo.type().present())
{
if (!std::strcmp(aClimateAlgo.type()->c_str(), "FullyImplicit"))
{
LOG_INF("Setting FullyImplicit climate algorithm.");
return new FullyImplicitClimateAlgorithm(aNumCoreParams, aClimateAlgo);
}
}
else // no ClimateAlgo type provided => default algo
{
LOG_WRN("Climate algorithm type not provided. Setting algorithm that does not nothing.");
return new DumbAlgorithm();
}
//}
//// ClimateAlgo component not provided => default algo
//LOG_WRN("Climate algorithm not provided. Setting algorithm that does not nothing.");
//return new DumbAlgorithm();
}
TResult CKKMApi::readENQ(int nTimeOut)
{
LOG_DBG("readENQ ==>");
TResult nRet = kResult_Success;
QByteArray readData;
nRet = readChunk(readData, nTimeOut);
if (nRet == kResult_Success)
{
bool bCorrect = (readData == QByteArray(&defs::cENQ,1));
LOG_DBG("readENQ : "<<bCorrect <<" '"<<ba2hex(readData)<<"'");
while (!bCorrect)
{
LOG_WRN("repeat readENQ");
nRet = readChunk(readData, nTimeOut);
if (nRet != kResult_Success)
break;
bCorrect = (readData == QByteArray(&defs::cENQ,1));
LOG_DBG("readENQ : "<<bCorrect <<" '"<<ba2hex(readData)<<"'");
}
}
LOG_DBG("readENQ <==");
return nRet;
}
int usb_dc_ep_read_wait(u8_t ep, u8_t *data, u32_t max_data_len,
u32_t *read_bytes)
{
u8_t ep_idx = EP_ADDR2IDX(ep);
u8_t ep_abs_idx = EP_ABS_IDX(ep);
u32_t data_len;
u8_t *bufp = NULL;
while (s_Device.eps[ep_abs_idx].ep_occupied) {
LOG_ERR("Endpoint is occupied by the controller");
return -EBUSY;
}
if ((ep_idx >= NUM_OF_EP_MAX) || (EP_ADDR2DIR(ep) != USB_EP_DIR_OUT)) {
LOG_ERR("Wrong endpoint index/address/direction");
return -EINVAL;
}
/* Allow to read 0 bytes */
if (!data && max_data_len) {
LOG_ERR("Wrong arguments");
return -EINVAL;
}
/* it is control setup, we should use message.buffer,
* this buffer is from internal setup array.
*/
bufp = s_Device.eps[ep_abs_idx].transfer_message.buffer;
data_len = s_Device.eps[ep_abs_idx].transfer_message.length;
if (data_len == USB_UNINITIALIZED_VAL_32) {
if (read_bytes) {
*read_bytes = 0;
}
return -EINVAL;
}
if (!data && !max_data_len) {
/* When both buffer and max data to read are zero return the
* available data in buffer.
*/
if (read_bytes) {
*read_bytes = data_len;
}
return 0;
}
if (data_len > max_data_len) {
LOG_WRN("Not enough room to copy all the data!");
data_len = max_data_len;
}
if (data != NULL) {
for (u32_t i = 0; i < data_len; i++) {
data[i] = bufp[i];
}
}
if (read_bytes) {
*read_bytes = data_len;
}
if (EP_ADDR2IDX(ep) == USB_ENDPOINT_CONTROL) {
u8_t isSetup = s_Device.eps[0].transfer_message.isSetup;
u8_t *buffer = s_Device.eps[0].transfer_message.buffer;
if (isSetup) {
if (((usb_setup_struct_t *)buffer)->wLength == 0) {
s_Device.setupDataStage = SETUP_DATA_STAGE_DONE;
} else if (((usb_setup_struct_t *)buffer)->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) {
s_Device.setupDataStage = SETUP_DATA_STAGE_IN;
} else {
s_Device.setupDataStage = SETUP_DATA_STAGE_OUT;
}
} else {
if (s_Device.setupDataStage != SETUP_DATA_STAGE_DONE) {
if ((data_len >= max_data_len) || (data_len < s_Device.eps[0].ep_mps)) {
s_Device.setupDataStage = SETUP_DATA_STAGE_DONE;
}
}
}
}
return 0;
}
//------------------------------------------------------------------------------
static long SYSRAM_Ioctl(
struct file* pFile,
unsigned int Cmd,
unsigned long Param)
{
MINT32 Ret = 0;
MUINT32 Sec = 0,USec = 0;
MUINT64 Time64 = 0;
SYSRAM_PROC_STRUCT* pProc = (SYSRAM_PROC_STRUCT*)pFile->private_data;
SYSRAM_ALLOC_STRUCT Alloc;
SYSRAM_USER_ENUM User;
//
SYSRAM_GetTime(&Time64, &Sec, &USec);
/*
LOG_MSG("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
*/
if(pFile->private_data == NULL)
{
LOG_WRN("private_data is NULL.");
Ret = -EFAULT;
goto EXIT;
}
//
switch(Cmd)
{
case SYSRAM_ALLOC:
{
if(copy_from_user(&Alloc, (void*)Param, sizeof(SYSRAM_ALLOC_STRUCT)) == 0)
{
if(SYSRAM_IsBadOwner(Alloc.User))
{
LOG_ERR("User(%d) out of range(%d)",Alloc.User,SYSRAM_USER_AMOUNT);
Ret = -EFAULT;
goto EXIT;
}
//
Alloc.Addr = SYSRAM_IOC_Alloc(
Alloc.User,
Alloc.Size,
Alloc.Alignment,
Alloc.TimeoutMS);
if(Alloc.Addr != 0)
{
SYSRAM_SpinLock();
pProc->Table |= (1 << Alloc.User);
if(pProc->Tgid == 0)
{
pProc->Pid = current->pid;
pProc->Tgid = current->tgid;
strcpy(pProc->ProcName,current->comm);
SYSRAM_SpinUnlock();
}
else
{
SYSRAM_SpinUnlock();
if(pProc->Tgid != current->tgid)
{
LOG_ERR("Tgid is inconsistent");
Ret = -EFAULT;
}
}
}
else
{
Ret = -EFAULT;
}
//
if(copy_to_user((void*)Param, &Alloc, sizeof(SYSRAM_ALLOC_STRUCT)) )
{
LOG_ERR("copy to user failed");
Ret = -EFAULT;
}
}
else
{
LOG_ERR("copy_from_user fail");
Ret = -EFAULT;
}
break;
}
//
case SYSRAM_FREE:
{
if(copy_from_user(&User, (void*)Param, sizeof(SYSRAM_USER_ENUM)) == 0)
{
if(SYSRAM_IsBadOwner(User))
{
LOG_ERR("User(%d) out of range(%d)",User,SYSRAM_USER_AMOUNT);
Ret = -EFAULT;
goto EXIT;
}
//
SYSRAM_SpinLock();
if((pProc->Table) & (1 << User))
{
SYSRAM_SpinUnlock();
SYSRAM_IOC_Free(User);
SYSRAM_SpinLock();
//
pProc->Table &= (~(1 << User));
if(pProc->Table == 0)
{
pProc->Pid = 0;
pProc->Tgid = 0;
strcpy(pProc->ProcName,SYSRAM_PROC_NAME);
}
SYSRAM_SpinUnlock();
}
else
{
SYSRAM_SpinUnlock();
LOG_WRN("Freeing unallocated buffer user(%d)",User);
Ret = -EFAULT;
}
}
else
{
LOG_ERR("copy_from_user fail");
Ret = -EFAULT;
}
break;
}
case SYSRAM_DUMP:
{
SYSRAM_DumpLayout();
break;
}
default:
{
LOG_WRN("No such command");
Ret = -EINVAL;
break;
}
}
//
EXIT:
if(Ret != 0)
{
LOG_ERR("Fail");
LOG_ERR("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
if(pFile->private_data != NULL)
{
LOG_ERR("Proc:Name(%s),pid(%d),tgid(%d),Table(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->Table,
Sec,
USec);
}
}
//
return Ret;
}
//------------------------------------------------------------------------------
static int SYSRAM_Flush(
struct file* pFile,
fl_owner_t Id)
{
MUINT32 Index = 0;
MUINT32 Sec = 0,USec = 0;
MUINT64 Time64 = 0;
SYSRAM_PROC_STRUCT* pProc;
//
SYSRAM_GetTime(&Time64, &Sec, &USec);
//
LOG_MSG("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
//
if(pFile->private_data != NULL)
{
pProc = (SYSRAM_PROC_STRUCT *)pFile->private_data;
//
if( pProc->Pid != 0 ||
pProc->Tgid != 0 ||
pProc->Table != 0)
{
//
LOG_WRN("Proc:Name(%s),pid(%d),tgid(%d),Table(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->Table,
pProc->TimeS,
pProc->TimeUS);
//
if( pProc->Tgid == 0 &&
pProc->Table != 0)
{
LOG_ERR("No Tgid info");
/*
LOG_ERR("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
LOG_ERR("Proc:Name(%s),pid(%d),tgid(%d),Table(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->Table,
pProc->TimeS,
pProc->TimeUS);
*/
}
else if( (pProc->Tgid == current->tgid) ||
((pProc->Tgid != current->tgid) && (strcmp(current->comm, "binder") == 0)))
{
if(pProc->Table)
{
LOG_WRN("Force to release");
/*
LOG_WRN("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
*/
SYSRAM_DumpLayout();
//
for(Index = 0 ; Index < SYSRAM_USER_AMOUNT; Index++)
{
if(pProc->Table & (1 << Index))
{
SYSRAM_IOC_Free((SYSRAM_USER_ENUM)Index);
}
}
//
pProc->Table= 0;
}
}
}
}
else
{
LOG_WRN("private_data is NULL");
/*
LOG_WRN("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
*/
}
//
return 0;
}
static int handle_device_list(const u8_t *desc, int connfd)
{
struct op_common header = {
.version = htons(USBIP_VERSION),
.code = htons(OP_REP_DEVLIST),
.status = 0,
};
LOG_DBG("desc %p", desc);
if (send(connfd, &header, sizeof(header), 0) != sizeof(header)) {
LOG_ERR("send() header failed: %s", strerror(errno));
return errno;
}
/* Send number of devices */
u32_t ndev = htonl(1);
if (send(connfd, &ndev, sizeof(ndev), 0) != sizeof(ndev)) {
LOG_ERR("send() ndev failed: %s", strerror(errno));
return errno;
}
send_device(desc, connfd);
send_interfaces(desc, connfd);
return 0;
}
static void handle_usbip_submit(int connfd, struct usbip_header *hdr)
{
struct usbip_submit *req = &hdr->u.submit;
int read;
LOG_DBG("");
read = recv(connfd, req, sizeof(*req), 0);
if (read != sizeof(*req)) {
LOG_ERR("recv() failed: %s", strerror(errno));
return;
}
usbip_header_dump((void *)hdr);
if (ntohl(hdr->common.ep) == 0) {
handle_usb_control(hdr);
} else {
handle_usb_data(hdr);
}
}
static void handle_usbip_unlink(int connfd, struct usbip_header *hdr)
{
struct usbip_unlink *req = &hdr->u.unlink;
u64_t setup_padding;
int read;
LOG_DBG("");
read = recv(connfd, req, sizeof(hdr->u), 0);
if (read != sizeof(hdr->u)) {
LOG_ERR("recv() failed: %s", strerror(errno));
return;
}
/* Read also padding */
read = recv(connfd, &setup_padding, sizeof(setup_padding), 0);
if (read != sizeof(setup_padding)) {
LOG_ERR("recv() failed: %s", strerror(errno));
return;
}
usbip_header_dump((void *)hdr);
/* TODO: unlink */
}
static int handle_import(const u8_t *desc, int connfd)
{
struct op_common header = {
.version = htons(USBIP_VERSION),
.code = htons(OP_REP_IMPORT),
.status = 0,
};
char busid[32];
LOG_DBG("attach device");
if (recv(connfd, busid, 32, 0) != sizeof(busid)) {
LOG_ERR("recv() failed: %s", strerror(errno));
return errno;
}
if (send(connfd, &header, sizeof(header), 0) != sizeof(header)) {
LOG_ERR("send() header failed: %s", strerror(errno));
return errno;
}
send_device(desc, connfd);
return 0;
}
extern struct usb_desc_header __usb_descriptor_start[];
void usbip_start(void)
{
struct sockaddr_in srv;
unsigned char attached;
int listenfd, connfd;
const u8_t *desc;
int reuse = 1;
LOG_DBG("Starting");
/*
* Do not use usb_get_device_descriptor();
* to prevent double string fixing
*/
desc = (const u8_t *)__usb_descriptor_start;
if (!desc) {
LOG_ERR("Descriptors are not set");
posix_exit(EXIT_FAILURE);
}
listenfd = socket(PF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
if (listenfd < 0) {
LOG_ERR("socket() failed: %s", strerror(errno));
posix_exit(EXIT_FAILURE);
}
if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR,
(const char *)&reuse, sizeof(reuse)) < 0) {
LOG_WRN("setsockopt() failed: %s", strerror(errno));
}
memset(&srv, 0, sizeof(srv));
srv.sin_family = AF_INET;
srv.sin_addr.s_addr = htonl(INADDR_ANY);
srv.sin_port = htons(USBIP_PORT);
if (bind(listenfd, (struct sockaddr *)&srv, sizeof(srv)) < 0) {
LOG_ERR("bind() failed: %s", strerror(errno));
posix_exit(EXIT_FAILURE);
}
if (listen(listenfd, SOMAXCONN) < 0) {
LOG_ERR("listen() failed: %s", strerror(errno));
posix_exit(EXIT_FAILURE);
}
while (true) {
struct sockaddr_in client_addr;
socklen_t client_addr_len = sizeof(client_addr);
connfd = accept4(listenfd, (struct sockaddr *)&client_addr,
&client_addr_len, SOCK_NONBLOCK);
if (connfd < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
/* Non-blocking accept */
k_sleep(100);
continue;
}
LOG_ERR("accept() failed: %s", strerror(errno));
posix_exit(EXIT_FAILURE);
}
connfd_global = connfd;
LOG_DBG("Connection: %s", inet_ntoa(client_addr.sin_addr));
/* Set attached 0 */
attached = 0U;
while (true) {
struct usbip_header cmd;
struct usbip_header_common *hdr = &cmd.common;
int read;
if (!attached) {
struct op_common req;
read = recv(connfd, &req, sizeof(req), 0);
if (read < 0) {
if (errno == EAGAIN ||
errno == EWOULDBLOCK) {
/* Non-blocking accept */
k_sleep(100);
continue;
}
}
if (read != sizeof(req)) {
LOG_WRN("wrong length, %d", read);
/* Closing connection */
break;
}
LOG_HEXDUMP_DBG((u8_t *)&req, sizeof(req),
"Got request");
LOG_DBG("Code: 0x%x", ntohs(req.code));
switch (ntohs(req.code)) {
case OP_REQ_DEVLIST:
handle_device_list(desc, connfd);
break;
case OP_REQ_IMPORT:
if (!handle_import(desc, connfd)) {
attached = 1U;
}
break;
default:
LOG_ERR("Unhandled code: 0x%x",
ntohs(req.code));
break;
}
continue;
}
/* Handle attached case */
read = recv(connfd, hdr, sizeof(*hdr), 0);
if (read < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
/* Non-blocking accept */
k_sleep(100);
continue;
}
}
LOG_HEXDUMP_DBG((u8_t *)hdr, read, "Got cmd");
if (read != sizeof(*hdr)) {
LOG_ERR("recv wrong length: %d", read);
/* Closing connection */
break;
}
devid_global = ntohl(hdr->devid);
seqnum_global = ntohl(hdr->seqnum);
switch (ntohl(hdr->command)) {
case USBIP_CMD_SUBMIT:
handle_usbip_submit(connfd, &cmd);
break;
case USBIP_CMD_UNLINK:
handle_usbip_unlink(connfd, &cmd);
break;
default:
LOG_ERR("Unknown command: 0x%x",
ntohl(hdr->command));
close(connfd);
return;
}
}
LOG_DBG("Closing connection");
close(connfd);
}
}
int usbip_recv(u8_t *buf, size_t len)
{
return recv(connfd_global, buf, len, 0);
}
int usbip_send(u8_t ep, const u8_t *data, size_t len)
{
return send(connfd_global, data, len, 0);
}
int usbip_send_common(u8_t ep, u32_t data_len)
{
struct usbip_submit_rsp rsp;
rsp.common.command = htonl(USBIP_RET_SUBMIT);
rsp.common.seqnum = htonl(seqnum_global);
rsp.common.devid = htonl(0);
rsp.common.direction = htonl(0); /* TODO get from ep */
rsp.common.ep = htonl(ep);
rsp.status = htonl(0);
rsp.actual_length = htonl(data_len);
rsp.start_frame = htonl(0);
rsp.number_of_packets = htonl(0);
rsp.error_count = htonl(0);
rsp.setup = htonl(0);
return usbip_send(ep, (u8_t *)&rsp, sizeof(rsp));
}
static int mcux_elcdif_set_brightness(const struct device *dev,
const u8_t brightness)
{
LOG_WRN("Set brightness not implemented");
return -ENOTSUP;
}
//-----------------------------------------------------------------------------
static long CamPipeMgr_Ioctl(
struct file* pFile,
unsigned int Cmd,
unsigned long Param)
{
MINT32 Ret = 0;
MUINT32 Sec = 0,USec = 0;
pid_t Pid;
pid_t Tgid;
char ProcName[TASK_COMM_LEN];
CAM_PIPE_MGR_LOCK_STRUCT Lock;
CAM_PIPE_MGR_UNLOCK_STRUCT Unlock;
CAM_PIPE_MGR_MODE_STRUCT Mode;
CAM_PIPE_MGR_ENABLE_STRUCT Enable;
CAM_PIPE_MGR_DISABLE_STRUCT Disable;
CAM_PIPE_MGR_PROC_STRUCT* pProc = (CAM_PIPE_MGR_PROC_STRUCT*)pFile->private_data;
CAM_PIPE_MGR_STATUS_ENUM Status;
//
CamPipeMgr_GetTime(&Sec, &USec);
/*
LOG_MSG("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
*/
if(pFile->private_data == NULL)
{
LOG_ERR("private_data is NULL");
Ret = -EFAULT;
goto EXIT;
}
//
switch(Cmd)
{
case CAM_PIPE_MGR_LOCK:
{
if(copy_from_user(&Lock, (void*)Param, sizeof(CAM_PIPE_MGR_LOCK_STRUCT)) == 0)
{
if((Lock.PipeMask & CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw]) != Lock.PipeMask)
{
if( (Lock.PipeMask & CAM_PIPE_MGR_PIPE_MASK_CDP_CONCUR) ||
(Lock.PipeMask & CAM_PIPE_MGR_PIPE_MASK_CDP_LINK))
{
LOG_WRN("LOCK:Sw(%d),Hw(%d),LPM(0x%08lX),PLT(0x%08lX) fail",
CamPipeMgr.Mode.ScenSw,
CamPipeMgr.Mode.ScenHw,
Lock.PipeMask,
CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw]);
}
else
{
LOG_ERR("LOCK:Sw(%d),Hw(%d),LPM(0x%08lX),PLT(0x%08lX) fail",
CamPipeMgr.Mode.ScenSw,
CamPipeMgr.Mode.ScenHw,
Lock.PipeMask,
CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw]);
}
Ret = -EFAULT;
}
else
{
CamPipeMgr_SpinLock();
Status = CamPipeMgr_LockPipe(&Lock);
if(Status == CAM_PIPE_MGR_STATUS_OK)
{
pProc->PipeMask |= Lock.PipeMask;
if(pProc->Tgid == 0)
{
pProc->Pid = current->pid;
pProc->Tgid = current->tgid;
strcpy(pProc->ProcName,current->comm);
CamPipeMgr_SpinUnlock();
if(CamPipeMgr.LogMask & Lock.PipeMask)
{
LOG_MSG("LOCK:Sw(%d),Hw(%d),LPM(0x%08lX),PLT(0x%08lX) OK",
CamPipeMgr.Mode.ScenSw,
CamPipeMgr.Mode.ScenHw,
Lock.PipeMask,
CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw]);
LOG_MSG("LOCK:Proc:Name(%s),Pid(%d),Tgid(%d),PipeMask(0x%08lX)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->PipeMask);
}
}
else
{
CamPipeMgr_SpinUnlock();
if(pProc->Tgid != current->tgid)
{
LOG_ERR("LOCK:Tgid is inconsistent");
Ret = -EFAULT;
}
}
}
else
{
CamPipeMgr_SpinUnlock();
if( (CamPipeMgr.LogMask & Lock.PipeMask) ||
(CamPipeMgr.Mode.ScenSw == CAM_PIPE_MGR_SCEN_SW_NONE))
{
if( (Lock.PipeMask & CAM_PIPE_MGR_PIPE_MASK_CDP_CONCUR) ||
(Lock.PipeMask & CAM_PIPE_MGR_PIPE_MASK_CDP_LINK))
{
LOG_WRN("LOCK:Sw(%d),Hw(%d),LPM(0x%08lX),PLT(0x%08lX) fail,Status(%d)",
CamPipeMgr.Mode.ScenSw,
CamPipeMgr.Mode.ScenHw,
Lock.PipeMask,
CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw],
Status);
}
else
{
LOG_ERR("LOCK:Sw(%d),Hw(%d),LPM(0x%08lX),PLT(0x%08lX) fail,Status(%d)",
CamPipeMgr.Mode.ScenSw,
CamPipeMgr.Mode.ScenHw,
Lock.PipeMask,
CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw],
Status);
}
}
Ret = -EFAULT;
}
}
}
else
{
LOG_ERR("LOCK:copy_from_user fail");
Ret = -EFAULT;
}
break;
}
//
case CAM_PIPE_MGR_UNLOCK:
{
if(copy_from_user(&Unlock, (void*)Param, sizeof(CAM_PIPE_MGR_UNLOCK_STRUCT)) == 0)
{
CamPipeMgr_SpinLock();
if(pProc->PipeMask & Unlock.PipeMask)
{
CamPipeMgr_UnlockPipe(&Unlock);
//Store info before clear.
Pid = pProc->Pid;
Tgid = pProc->Tgid;
strcpy(ProcName,pProc->ProcName);
//
pProc->PipeMask &= (~Unlock.PipeMask);
if(pProc->PipeMask == 0)
{
pProc->Pid = 0;
pProc->Tgid = 0;
strcpy(pProc->ProcName,CAM_PIPE_MGR_PROC_NAME);
}
CamPipeMgr_SpinUnlock();
if(CamPipeMgr.LogMask & Unlock.PipeMask)
{
LOG_MSG("UNLOCK:Sw(%d),Hw(%d),UPM(0x%08lX),PLT(0x%08lX) OK",
CamPipeMgr.Mode.ScenSw,
CamPipeMgr.Mode.ScenHw,
Unlock.PipeMask,
CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw]);
LOG_MSG("UNLOCK:Proc:Name(%s),Pid(%d),Tgid(%d),PipeMask(0x%08lX)",
ProcName,
Pid,
Tgid,
pProc->PipeMask);
}
}
else
{
CamPipeMgr_SpinUnlock();
if( (CamPipeMgr.LogMask & Unlock.PipeMask) ||
(CamPipeMgr.Mode.ScenSw == CAM_PIPE_MGR_SCEN_SW_NONE))
{
LOG_ERR("UNLOCK:Sw(%d),Hw(%d),UPM(0x%08lX),PLT(0x%08lX) fail, it was not locked before",
CamPipeMgr.Mode.ScenSw,
CamPipeMgr.Mode.ScenHw,
Unlock.PipeMask,
CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw]);
}
Ret = -EFAULT;
}
}
else
{
LOG_ERR("UNLOCK:copy_from_user fail");
Ret = -EFAULT;
}
break;
}
//
case CAM_PIPE_MGR_DUMP:
{
CamPipeMgr_DumpPipeInfo();
break;
}
//
case CAM_PIPE_MGR_SET_MODE:
{
if(copy_from_user(&Mode, (void*)Param, sizeof(CAM_PIPE_MGR_MODE_STRUCT)) == 0)
{
LOG_MSG("SET_MODE:Sw(%d),Hw(%d)",Mode.ScenSw,Mode.ScenHw);
if((CamPipeMgr.PipeMask | CamPipeMgr.PipeLockTable[Mode.ScenHw]) ^ CamPipeMgr.PipeLockTable[Mode.ScenHw])
{
LOG_ERR("SET_MODE:PM(0x%08lX),PLT(0x%08lX), some pipe should be unlock",
CamPipeMgr.PipeMask,
CamPipeMgr.PipeLockTable[Mode.ScenHw]);
Ret = -EFAULT;
}
//
CamPipeMgr_SpinLock();
memcpy(
&(CamPipeMgr.Mode),
&Mode,
sizeof(CAM_PIPE_MGR_MODE_STRUCT));
CamPipeMgr_UpdatePipeLockTable(CamPipeMgr.Mode.ScenSw);
CamPipeMgr_SpinUnlock();
LOG_MSG("SET_MODE:done");
}
else
{
LOG_ERR("SET_MODE:copy_from_user fail");
Ret = -EFAULT;
}
break;
}
//
case CAM_PIPE_MGR_GET_MODE:
{
if(copy_to_user((void*)Param, &(CamPipeMgr.Mode), sizeof(CAM_PIPE_MGR_MODE_STRUCT)) == 0)
{
//do nothing.
}
else
{
LOG_ERR("GET_MODE:copy_to_user fail");
Ret = -EFAULT;
}
break;
}
//
case CAM_PIPE_MGR_ENABLE_PIPE:
{
if(copy_from_user(&Enable, (void*)Param, sizeof(CAM_PIPE_MGR_ENABLE_STRUCT)) == 0)
{
LOG_MSG("ENABLE_PIPE:Sw(%d),Hw(%d):EPM(0x%08lX),PLT(0x%08lX)",
CamPipeMgr.Mode.ScenSw,
CamPipeMgr.Mode.ScenHw,
Enable.PipeMask,
CamPipeMgr_GtePipeLockTable(CamPipeMgr.Mode.ScenSw,CamPipeMgr.Mode.ScenHw));
if((Enable.PipeMask & CamPipeMgr_GtePipeLockTable(CamPipeMgr.Mode.ScenSw,CamPipeMgr.Mode.ScenHw)) != Enable.PipeMask)
{
LOG_ERR("ENABLE_PIPE:Some pipe are not available");
Ret = -EFAULT;
}
else
{
CamPipeMgr_SpinLock();
CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw] |= Enable.PipeMask;
CamPipeMgr_SpinUnlock();
}
}
else
{
LOG_ERR("ENABLE_PIPE:copy_from_user fail");
Ret = -EFAULT;
}
break;
}
//
case CAM_PIPE_MGR_DISABLE_PIPE:
{
if(copy_from_user(&Disable, (void*)Param, sizeof(CAM_PIPE_MGR_DISABLE_STRUCT)) == 0)
{
LOG_MSG("DISABLE_PIPE:Sw(%d),Hw(%d):DPM(0x%08lX),PLT(0x%08lX)",
CamPipeMgr.Mode.ScenSw,
CamPipeMgr.Mode.ScenHw,
Disable.PipeMask,
CamPipeMgr_GtePipeLockTable(CamPipeMgr.Mode.ScenSw,CamPipeMgr.Mode.ScenHw));
if((Disable.PipeMask & CamPipeMgr_GtePipeLockTable(CamPipeMgr.Mode.ScenSw,CamPipeMgr.Mode.ScenHw)) != Disable.PipeMask)
{
LOG_ERR("DISABLE_PIPE:Some pipe are not available");
Ret = -EFAULT;
}
else
{
CamPipeMgr_SpinLock();
CamPipeMgr.PipeLockTable[CamPipeMgr.Mode.ScenHw] &= (~Disable.PipeMask);
CamPipeMgr_SpinUnlock();
}
}
else
{
LOG_ERR("DISABLE_PIPE:copy_from_user fail");
Ret = -EFAULT;
}
break;
}
//
default:
{
LOG_ERR("Unknown cmd");
Ret = -EFAULT;
break;
}
}
//
EXIT:
if(Ret != 0)
{
if( (CamPipeMgr.LogMask & Lock.PipeMask) ||
(CamPipeMgr.Mode.ScenSw == CAM_PIPE_MGR_SCEN_SW_NONE))
{
LOG_ERR("Fail");
LOG_ERR("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
if(pFile->private_data != NULL)
{
LOG_ERR("Proc:Name(%s),Pid(%d),Tgid(%d),PipeMask(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->PipeMask,
Sec,
USec);
}
CamPipeMgr_DumpPipeInfo();
}
}
return Ret;
}
//-----------------------------------------------------------------------------
static int CamPipeMgr_Flush(
struct file* pFile,
fl_owner_t Id)
{
MUINT32 Sec = 0,USec = 0;
CAM_PIPE_MGR_PROC_STRUCT* pProc;
CAM_PIPE_MGR_UNLOCK_STRUCT Unlock;
//
CamPipeMgr_GetTime(&Sec, &USec);
//
LOG_MSG("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
//
if(pFile->private_data != NULL)
{
pProc = (CAM_PIPE_MGR_PROC_STRUCT*)pFile->private_data;
//
if( pProc->Pid != 0 ||
pProc->Tgid != 0 ||
pProc->PipeMask != 0)
{
//
LOG_WRN("Proc:Name(%s),Pid(%d),Tgid(%d),PipeMask(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->PipeMask,
pProc->TimeS,
pProc->TimeUS);
//
if( pProc->Tgid == 0 &&
pProc->PipeMask != 0)
{
LOG_ERR("No Tgid info");
/*
LOG_ERR("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
LOG_ERR("Proc:Name(%s),Pid(%d),Tgid(%d),PipeMask(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->PipeMask,
pProc->TimeS,
pProc->TimeUS);
*/
}
else
if( (pProc->Tgid == current->tgid) ||
((pProc->Tgid != current->tgid) && (strcmp(current->comm, "binder") == 0)))
{
if(pProc->PipeMask)
{
LOG_WRN("Force to unlock pipe");
/*
LOG_WRN("Proc:Name(%s),Pid(%d),Tgid(%d),PipeMask(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->PipeMask,
pProc->TimeS,
pProc->TimeUS);
*/
CamPipeMgr_SpinLock();
Unlock.PipeMask = pProc->PipeMask;
CamPipeMgr_UnlockPipe(&Unlock);
pProc->PipeMask = 0;
CamPipeMgr_SpinUnlock();
}
}
}
}
else
{
LOG_WRN("private_data is NULL");
/*
LOG_WRN("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
*/
}
//
//LOG_MSG("OK");
return 0;
}
//-----------------------------------------------------------------------------
static int CamPipeMgr_Release(
struct inode* pInode,
struct file* pFile)
{
MUINT32 Sec = 0,USec = 0;
CAM_PIPE_MGR_PROC_STRUCT* pProc;
CAM_PIPE_MGR_UNLOCK_STRUCT Unlock;
//
CamPipeMgr_GetTime(&Sec, &USec);
//
LOG_MSG("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
//
if(pFile->private_data != NULL)
{
pProc = (CAM_PIPE_MGR_PROC_STRUCT*)pFile->private_data;
//
if( pProc->Pid != 0 ||
pProc->Tgid != 0 ||
pProc->PipeMask != 0)
{
//
LOG_WRN("Proc:Name(%s),Pid(%d),Tgid(%d),PipeMask(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->PipeMask,
pProc->TimeS,
pProc->TimeUS);
//
if(pProc->PipeMask)
{
LOG_WRN("Force to unlock pipe");
/*
LOG_WRN("Proc:Name(%s),Pid(%d),Tgid(%d),PipeMask(0x%08lX),Time(%ld.%06ld)",
pProc->ProcName,
pProc->Pid,
pProc->Tgid,
pProc->PipeMask,
pProc->TimeS,
pProc->TimeUS);
*/
CamPipeMgr_SpinLock();
Unlock.PipeMask = pProc->PipeMask;
CamPipeMgr_UnlockPipe(&Unlock);
CamPipeMgr_SpinUnlock();
}
}
//
kfree(pFile->private_data);
pFile->private_data = NULL;
}
else
{
LOG_WRN("private_data is NULL");
/*
LOG_WRN("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)",
current->comm,
current->pid,
current->tgid,
Sec,
USec);
*/
}
//
//LOG_MSG("OK");
return 0;
}
