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