static int gx1001_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *p) { struct gx1001_state *state = fe->demodulator_priv; demod_connect(state, p->frequency,p->u.qam.modulation,p->u.qam.symbol_rate); state->freq=p->frequency; state->mode=p->u.qam.modulation ; state->symbol_rate=p->u.qam.symbol_rate; //these data will be writed to eeprom pr_dbg("gx1001=>frequency=%d,symbol_rate=%d\r\n",p->frequency,p->u.qam.symbol_rate); return 0; }
static int AVL6211_Blindscan_Cancel(struct dvb_frontend* fe) { blindstart=0; AVL_DVBSx_ErrorCode r = AVL_DVBSx_EC_OK; r = AVL_DVBSx_IBase_SetFunctionalMode(pAVLChip_all, AVL_DVBSx_FunctMode_Demod);//set demod mode if(r!= AVL_DVBSx_EC_OK) { pr_dbg("avl6211_blindscan_cancel,fail\n"); } return r; }
static void dib7090_fe_release(struct aml_dvb *advb, struct aml_fe *fe) { if(fe && fe->fe) { pr_dbg("release fe Dib7090 %d\n", fe->id); dvb_unregister_frontend(fe->fe); dvb_frontend_detach(fe->fe); dib7090_fe_cfg_put(fe->cfg); fe->fe = NULL; fe->cfg = NULL; fe->id = -1; } }
int demod_check_locked(unsigned char* lock) { if(CXD2837_GetTPLock(cxd2837)==SONY_RESULT_OK) { pr_dbg("demod_check_locked !!\n"); *lock =1; return 1; } *lock =0; return 0; }
int rdma_rm_modify_qp(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev, uint32_t qp_handle, uint32_t attr_mask, union ibv_gid *dgid, uint32_t dqpn, enum ibv_qp_state qp_state, uint32_t qkey, uint32_t rq_psn, uint32_t sq_psn) { RdmaRmQP *qp; int ret; pr_dbg("qpn=%d\n", qp_handle); qp = rdma_rm_get_qp(dev_res, qp_handle); if (!qp) { return -EINVAL; } pr_dbg("qp_type=%d\n", qp->qp_type); pr_dbg("attr_mask=0x%x\n", attr_mask); if (qp->qp_type == IBV_QPT_SMI) { pr_dbg("QP0 unsupported\n"); return -EPERM; } else if (qp->qp_type == IBV_QPT_GSI) { pr_dbg("QP1\n"); return 0; } if (attr_mask & IBV_QP_STATE) { qp->qp_state = qp_state; pr_dbg("qp_state=%d\n", qp->qp_state); if (qp->qp_state == IBV_QPS_INIT) { ret = rdma_backend_qp_state_init(backend_dev, &qp->backend_qp, qp->qp_type, qkey); if (ret) { return -EIO; } } if (qp->qp_state == IBV_QPS_RTR) { ret = rdma_backend_qp_state_rtr(backend_dev, &qp->backend_qp, qp->qp_type, dgid, dqpn, rq_psn, qkey, attr_mask & IBV_QP_QKEY); if (ret) { return -EIO; } } if (qp->qp_state == IBV_QPS_RTS) { ret = rdma_backend_qp_state_rts(&qp->backend_qp, qp->qp_type, sq_psn, qkey, attr_mask & IBV_QP_QKEY); if (ret) { return -EIO; } } } return 0; }
/* * killer() * this continually stops and continues the runner process */ static void killer( const char *name, const pid_t pid, uint64_t *counter, const uint64_t max_ops) { double start = time_now(); uint64_t last_counter = *counter; pr_dbg(stderr, "%s: wait: killer started [%d]\n", name, getpid()); do { (void)kill(pid, SIGSTOP); (void)kill(pid, SIGCONT); /* * The waits may be blocked and * so the counter is not being updated. * If it is blocked for too long bail out * so we don't get stuck in the parent * waiter indefintely. */ if (last_counter == *counter) { if (time_now() - start > ABORT_TIMEOUT) { pr_dbg(stderr, "%s: waits were blocked, " "aborting\n", name); break; } } else { start = time_now(); last_counter = *counter; } } while (opt_do_run && (!max_ops || *counter < max_ops)); /* forcefully kill runner, wait is in parent */ (void)kill(pid, SIGKILL); /* tell parent to wake up! */ (void)kill(getppid(), SIGALRM); exit(EXIT_SUCCESS); }
static void cdx2834_fe_release(struct aml_dvb *advb, struct aml_fe *fe) { if(fe && fe->fe) { pr_dbg("release GX1001 frontend %d\n", fe->id); dvb_unregister_frontend(fe->fe); dvb_frontend_detach(fe->fe); if(fe->cfg){ kfree(fe->cfg); fe->cfg = NULL; } fe->id = -1; } }
/** * file_exists() * @path: file to check. * Determine if specified file exists. * * Returns: file type if @path exists, else 0. **/ static int file_exists(const char *path) { struct stat st; if (!path) { pr_dbg("%s: empty path specified\n", __func__); return 0; } if (stat(path, &st) < 0) return 0; return (st.st_mode & S_IFMT); }
static int mxl101_fe_enter_mode(struct aml_fe *fe, int mode) { struct aml_fe_dev *dev = fe->dtv_demod; pr_dbg("=========================demod init\r\n"); gpio_direction_output(dev->reset_gpio, dev->reset_value); msleep(300); gpio_direction_output(dev->reset_gpio, !dev->reset_value); //enable tuner power msleep(200); MxL101SF_Init(dev); return 0; }
void *rdma_rm_get_cqe_ctx(RdmaDeviceResources *dev_res, uint32_t cqe_ctx_id) { void **cqe_ctx; cqe_ctx = res_tbl_get(&dev_res->cqe_ctx_tbl, cqe_ctx_id); if (!cqe_ctx) { return NULL; } pr_dbg("ctx=%p\n", *cqe_ctx); return *cqe_ctx; }
static int modify_qp(PVRDMADev *dev, union pvrdma_cmd_req *req, union pvrdma_cmd_resp *rsp) { struct pvrdma_cmd_modify_qp *cmd = &req->modify_qp; pr_dbg("qp_handle=%d\n", cmd->qp_handle); memset(rsp, 0, sizeof(*rsp)); rsp->hdr.response = cmd->hdr.response; rsp->hdr.ack = PVRDMA_CMD_MODIFY_QP_RESP; rsp->hdr.err = rdma_rm_modify_qp(&dev->rdma_dev_res, &dev->backend_dev, cmd->qp_handle, cmd->attr_mask, (union ibv_gid *)&cmd->attrs.ah_attr.grh.dgid, cmd->attrs.dest_qp_num, (enum ibv_qp_state)cmd->attrs.qp_state, cmd->attrs.qkey, cmd->attrs.rq_psn, cmd->attrs.sq_psn); pr_dbg("ret=%d\n", rsp->hdr.err); return rsp->hdr.err; }
static int AVL6211_Blindscan_Cancel(struct dvb_frontend* fe) { blindstart=0; printk(KERN_INFO "AVL6211_Blindscan_Cancel\n"); while(2!=blindstart){ pr_dbg("wait for scan exit\n"); msleep(100); } /*call do_exit() directly*/ dvbs2_task = NULL; fe_use = NULL; return 0; }
static int cdx2834_fe_init(struct aml_dvb *advb, struct platform_device *pdev, struct aml_fe *fe, int id) { struct dvb_frontend_ops *ops; int ret; struct resource *res; struct cdx2834_fe_config *cfg; char buf[32]; pr_dbg("init CDX2834 frontend %d\n", id); cfg = kzalloc(sizeof(struct cdx2834_fe_config), GFP_KERNEL); if (!cfg) return -ENOMEM; cfg->reset_pin = frontend_reset; if(cfg->reset_pin==-1) { snprintf(buf, sizeof(buf), "frontend%d_reset", id); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf); if (!res) { pr_error("cannot get resource \"%s\"\n", buf); ret = -EINVAL; goto err_resource; } cfg->reset_pin = res->start; } cfg->i2c_id = frontend_i2c; if(cfg->i2c_id==-1) { snprintf(buf, sizeof(buf), "frontend%d_i2c", id); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf); if (!res) { pr_error("cannot get resource \"%s\"\n", buf); ret = -EINVAL; goto err_resource; } cfg->i2c_id = res->start; } cfg->tuner_addr = frontend_tuner_addr; if(cfg->tuner_addr==-1) { snprintf(buf, sizeof(buf), "frontend%d_tuner_addr", id); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf); if (!res) { pr_error("cannot get resource \"%s\"\n", buf); ret = -EINVAL; goto err_resource; } cfg->tuner_addr = res->start>>1; }
int32_t cr_access_vmexit_handler(struct acrn_vcpu *vcpu) { uint64_t reg; uint32_t idx; uint64_t exit_qual; int32_t ret = 0; exit_qual = vcpu->arch.exit_qualification; idx = (uint32_t)vm_exit_cr_access_reg_idx(exit_qual); ASSERT((idx <= 15U), "index out of range"); reg = vcpu_get_gpreg(vcpu, idx); switch ((vm_exit_cr_access_type(exit_qual) << 4U) | vm_exit_cr_access_cr_num(exit_qual)) { case 0x00UL: /* mov to cr0 */ vcpu_set_cr0(vcpu, reg); break; case 0x04UL: /* mov to cr4 */ vcpu_set_cr4(vcpu, reg); break; case 0x08UL: /* mov to cr8 */ /* According to SDM 6.15 "Exception and interrupt Reference": * * set reserved bit in CR8 causes GP to guest */ if ((reg & ~0xFUL) != 0UL) { pr_dbg("Invalid cr8 write operation from guest"); vcpu_inject_gp(vcpu, 0U); break; } vlapic_set_cr8(vcpu_vlapic(vcpu), reg); break; case 0x18UL: /* mov from cr8 */ reg = vlapic_get_cr8(vcpu_vlapic(vcpu)); vcpu_set_gpreg(vcpu, idx, reg); break; default: ASSERT(false, "Unhandled CR access"); ret = -EINVAL; break; } TRACE_2L(TRACE_VMEXIT_CR_ACCESS, vm_exit_cr_access_type(exit_qual), vm_exit_cr_access_cr_num(exit_qual)); return ret; }
static void adkeys_poll(struct adgpio_key_data *adkey) { int advol, i; static struct adgpio_key *prev_keys = NULL; static T_ad_check state = PLUGIN_INVALID; static int is_change_flag = 0; advol = adc1_read_ad5(); pr_dbg("poll: volatge: %d\n", advol); for (i = 0; i < adkey->naddet; i++) { if ((advol > adkey->addet[i].unpress_min) &&(advol < adkey->addet[i].unpress_max)) { adkey->keys = adkey->addet[i].fixkeys; if ((prev_keys != adkey->keys) || (state != adkey->addet[i].plugdev)) { prev_keys = adkey->keys; state = adkey->addet[i].plugdev; is_change_flag = 1; } else { is_change_flag = 0; } break; } } if (is_change_flag) { addetect_plugin_notify(state); } i = 0; do { if ((adkey->keys != NULL) && (advol > adkey->keys[i].min) && (advol < adkey->keys[i].max)) { adkey->press = 1; adkey->sync_me = 1; adkey->keycode = adkey->keys[i].code; adkey->loop = i; break; } else adkey->press = 0; i++; } while(i < adkey->nkey); if (adkey->sync_me) { mod_timer(&adkey->timer, jiffies + msecs_to_jiffies(adkey->debounce_interval)); } }
static int smc_hw_read_atr(smc_dev_t *smc) { char *ptr = smc->atr.atr; int his_len, t, tnext = 0, only_t0 = 1, loop_cnt=0; pr_dbg("read atr\n"); smc->atr.atr_len = 0; if(smc_hw_get(smc, 2, 2000)<0) goto end; ptr++; his_len = ptr[0]&0x0F; do { tnext = 0; loop_cnt++; if(ptr[0]&0x10) { if(smc_hw_get(smc, 1, 1000)<0) goto end; } if(ptr[0]&0x20) { if(smc_hw_get(smc, 1, 1000)<0) goto end; } if(ptr[0]&0x40) { if(smc_hw_get(smc, 1, 1000)<0) goto end; } if(ptr[0]&0x80) { if(smc_hw_get(smc, 1, 1000)<0) goto end; ptr = &smc->atr.atr[smc->atr.atr_len-1]; t = ptr[0]&0x0F; if(t) { only_t0 = 0; } if(ptr[0]&0xF0) { tnext = 1; } } } while(tnext && loop_cnt<4); if(!only_t0) his_len++; smc_hw_get(smc, his_len, 1000); return 0; end: return -EIO; }
static int create_mr(PVRDMADev *dev, union pvrdma_cmd_req *req, union pvrdma_cmd_resp *rsp) { struct pvrdma_cmd_create_mr *cmd = &req->create_mr; struct pvrdma_cmd_create_mr_resp *resp = &rsp->create_mr_resp; PCIDevice *pci_dev = PCI_DEVICE(dev); void *host_virt = NULL; memset(resp, 0, sizeof(*resp)); resp->hdr.response = cmd->hdr.response; resp->hdr.ack = PVRDMA_CMD_CREATE_MR_RESP; pr_dbg("pd_handle=%d\n", cmd->pd_handle); pr_dbg("access_flags=0x%x\n", cmd->access_flags); pr_dbg("flags=0x%x\n", cmd->flags); if (!(cmd->flags & PVRDMA_MR_FLAG_DMA)) { host_virt = pvrdma_map_to_pdir(pci_dev, cmd->pdir_dma, cmd->nchunks, cmd->length); if (!host_virt) { pr_dbg("Failed to map to pdir\n"); resp->hdr.err = -EINVAL; goto out; } } resp->hdr.err = rdma_rm_alloc_mr(&dev->rdma_dev_res, cmd->pd_handle, cmd->start, cmd->length, host_virt, cmd->access_flags, &resp->mr_handle, &resp->lkey, &resp->rkey); if (host_virt && !resp->hdr.err) { munmap(host_virt, cmd->length); } out: pr_dbg("ret=%d\n", resp->hdr.err); return resp->hdr.err; }
static int ite9133_read_status(struct dvb_frontend *fe, fe_status_t * status) { struct ite9133_state *state = fe->demodulator_priv; Dword ret; Bool locked = 0; pr_dbg("ite9133_read_status\n"); mutex_lock(&ite_lock); ret = Demodulator_isLocked(pdemod,&locked); printk("DVB: lock status is %d\n",locked); mutex_unlock(&ite_lock); if(locked==1) { *status = FE_HAS_LOCK|FE_HAS_SIGNAL|FE_HAS_CARRIER|FE_HAS_VITERBI|FE_HAS_SYNC; } else { *status = FE_TIMEDOUT; } pr_dbg("ite9133_read_status--\n"); return 0; }
static int __init his_boot_init(void) { ssize_t ret = 0; pr_dbg(KERN_DEBUG "his_boot_init.\r\n"); ret = platform_device_register(&his_boot_dev); if(ret) { pr_dbg("register his_boot device failed. \r\n"); return ret; } ret = platform_driver_register(&his_boot_drv); if(ret) { pr_dbg("register his_boot driver failed. \r\n"); platform_device_unregister(&his_boot_dev); } return ret; }
/***************************************************************************** 函 数 名 : bsp_power_icc_send_state 功能描述 : C核核间通信函数 输入参数 : 输出参数 : 无 返 回 值 : 调用函数 : 被调函数 : *****************************************************************************/ static void bsp_power_icc_send_state(void) { int ret = 0; int mode = 0; u32 icc_channel_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_ONOFF; mode = bsp_start_mode_get(); ret = bsp_icc_send(ICC_CPU_MODEM, icc_channel_id, (u8*)&mode, sizeof(mode)); if (ret != (int)sizeof(mode)) { pr_dbg("send len(%x) != expected len(%x)\n", ret, sizeof(mode)); } }
/***************************************************************************** 函 数 名 : power_on_time_get 功能描述 : 记录开机时间. 输入参数 : 输出参数 : 无 返 回 值 : 调用函数 : 被调函数 : *****************************************************************************/ static void power_on_time_get( void ) { struct rtc_time tm; struct timespec ts; getnstimeofday(&ts); rtc_time_to_tm((unsigned long)ts.tv_sec, &tm); power_item_info.time = tm; pr_dbg("system power on time:%4d-%02d-%02d %02d:%02d:%02d\n",tm.tm_year, tm.tm_mon, \ tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); }
static int si2168_fe_resume(struct aml_fe_dev *dev) { printk("mxl101_fe_resume\n"); amlogic_gpio_request(dev->reset_gpio,"si2168_reset"); amlogic_gpio_direction_output(dev->reset_gpio, dev->reset_value, "si2168_reset"); msleep(300); amlogic_gpio_direction_output(dev->reset_gpio, !dev->reset_value, "si2168_reset"); //enable tuner power msleep(200); int standard; standard=SILABS_DVB_T2; //Initialize LSI printf("Initializing LSI .. "); SiLabs_API_SW_Init(&front_end, DEMOD_ADDRESS+(fe1*2), TUNER_ADDRESS_TER+(fe1*2), TUNER_ADDRESS_SAT+(fe1*2)); front_end.Si2168_FE->demod->i2c=DEMOD_ADDRESS; SiLabs_API_switch_to_standard (&front_end, standard, 1); printk("chip id is %d, i2c is %x\n",front_end.chip,front_end.Si2168_FE->demod->i2c); if(MDrv_Tuner_Init()==1) pr_dbg("TUNER OK\n"); else pr_dbg("TUNER NG\n"); return 0; }
/***************************************************************************** 函 数 名 : power_off_operation 功能描述 : 执行关机操作 输入参数 : 输出参数 : 无 返 回 值 : 调用函数 : 被调函数 : *****************************************************************************/ LOCAL_1 void power_off_operation( void ) { /* 按键不松开情况下,不允许关机 */ while( is_power_key_pressed() ) { /* avoid the watchdog reset while polling the power key */ /* TO DO*/ } pr_dbg("\r\n power_off_operation : the power key is release\r\n" ); /* shutdown the system. */ power_off_down_operation(); }
static void ite9173_fe_release(struct aml_dvb *advb, struct aml_fe *fe) { if(fe && fe->fe) { pr_dbg("release ite9173 frontend %d\n", fe->id); mutex_destroy(&ite_lock); dvb_unregister_frontend(fe->fe); dvb_frontend_detach(fe->fe); if(fe->cfg){ kfree(fe->cfg); fe->cfg = NULL; } fe->id = -1; } }
/* * stress_cwd_readwriteable() * check if cwd is read/writeable */ void stress_cwd_readwriteable(void) { char path[PATH_MAX]; if (getcwd(path, sizeof(path)) == NULL) { pr_dbg(stderr, "Cannot determine current working directory\n"); return; } if (access(path, R_OK | W_OK)) { pr_inf(stderr, "Working directory %s is not read/writeable, " "some I/O tests may fail\n", path); return; } }
int get_mount_info(const char *name) { FILE *fp; int mounts = 0; if ((fp = fopen("/proc/self/mountinfo", "r")) == NULL) { pr_dbg(stderr, "%s: cannot open /proc/self/mountinfo\n", name); return -1; } for (;;) { char mount_path[PATH_MAX]; char *line = NULL; size_t line_len = 0; ssize_t nread = getline(&line, &line_len, fp); if (nread == -1) break; nread = sscanf(line, "%d %*d %*s %*s %s", &mount_info[mounts].mount_id, mount_path); if (nread != 2) continue; mount_info[mounts].mount_path = strdup(mount_path); if (mount_info[mounts].mount_path == NULL) { pr_dbg(stderr, "%s: cannot allocate mountinfo mount path\n", name); free_mount_info(mounts); mounts = -1; break; } mounts++; } fclose(fp); return mounts; }
static int AVL6211_Diseqc_Send_Master_Cmd(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd* cmd) { AVL_DVBSx_ErrorCode r = AVL_DVBSx_EC_OK; AVL_uchar ucData[8]; int j=100; struct AVL_DVBSx_Diseqc_TxStatus TxStatus; int i; pr_dbg("msg_len is %d,\n data is",cmd->msg_len); for(i=0;i<cmd->msg_len;i++){ ucData[i]=cmd->msg[i]; printk("%x ",cmd->msg[i]); } r=AVL_DVBSx_IDiseqc_SendModulationData(ucData, cmd->msg_len, pAVLChip_all); if(r != AVL_DVBSx_EC_OK) { pr_dbg("AVL_DVBSx_IDiseqc_SendModulationData failed !\n"); } else { do { j--; AVL_DVBSx_IBSP_Delay(1); r= AVL_DVBSx_IDiseqc_GetTxStatus(&TxStatus, pAVLChip_all); }while((TxStatus.m_TxDone != 1)&&j); if(r ==AVL_DVBSx_EC_OK ) { } else { pr_dbg("AVL_DVBSx_IDiseqc_SendModulationData Err. !\n"); } } return r; }
/***************************************************************************** 函 数 名 : bsp_power_ctrl_read_cb 功能描述 : C核核间回调函数 输入参数 : 输出参数 : 无 返 回 值 : 调用函数 : 被调函数 : *****************************************************************************/ static s32 bsp_power_ctrl_read_cb( void ) { int rt = 0; int read_len = 0; stCtrlMsg msg; u32 channel_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_ONOFF; read_len = bsp_icc_read(channel_id, (u8*)&msg, sizeof(stCtrlMsg)); if(read_len != (int)sizeof(stCtrlMsg)) { pr_dbg("read len(%x) != expected len(%x)\n", read_len, sizeof(stCtrlMsg)); return -1; } pr_dbg("bsp_power_ctrl_read_cb 0x%x\n", msg.pwr_type); switch(msg.pwr_type) { case E_POWER_ON_MODE_GET: bsp_power_icc_send_state(); break; case E_POWER_SHUT_DOWN: drv_shut_down(msg.reason); break; case E_POWER_POWER_OFF: bsp_drv_power_off(); break; case E_POWER_POWER_REBOOT: bsp_drv_power_reboot(); break; default: pr_dbg("invalid ctrl by ccore\n"); break; } return rt; }
static int ite9173_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *p) { Bool locked = 0; Word bandwidth=8; Dword ret = 0; struct ite9173_state *state = fe->demodulator_priv; pr_dbg("ite9173_set_frontend\n"); bandwidth=p->u.ofdm.bandwidth; if(bandwidth==0) bandwidth=8; else if(bandwidth==1) bandwidth=7; else if(bandwidth==2) bandwidth=6; else bandwidth=8; state->freq=(p->frequency/1000); pr_dbg("state->freq ==== %d \n", state->freq); if(state->freq>0&&state->freq!=-1) { mutex_lock(&ite_lock); ret = Demodulator_acquireChannel(pdemod, bandwidth*1000,state->freq); mutex_unlock(&ite_lock); if(Error_NO_ERROR != ret) return -1; } else { printk("\n--Invalidate Fre!!!!!!!!!!!!!--\n"); } pr_dbg("ite9173_set_frontend--\n"); return 0; }
/***************************************************************************** 函 数 名 : power_off_reboot_operation 功能描述 : pmu rst 系统重启 输入参数 : 输出参数 : 无 返 回 值 : 调用函数 : 被调函数 : *****************************************************************************/ LOCAL_1 void power_off_reboot_operation( void ) { /* p531 FPGA复位需要同时复位F1/BBP/RF */ #ifdef BSP_CONFIG_P531_FPGA extern void p531_fpga_reset(void); p531_fpga_reset(); #endif pr_dbg( "system power reboot!\r\n" ); hi_syssc_pmu_reboot(); /* coverity[no_escape] */ for(;;) ; }