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