spin_lock_irqsave(&isp->lock, flags);
        if (isp->sw_contex.power_state != ATOM_ISP_POWER_UP ||
-           isp->css_initialized == false) {
+           !isp->css_initialized) {
                spin_unlock_irqrestore(&isp->lock, flags);
                return IRQ_HANDLED;
        }
        }
 
        if (*value == 0) {
-               asd->params.fpn_en = 0;
+               asd->params.fpn_en = false;
                return 0;
        }
 
 
        /* if subdev type is SOC camera,we do not need to set DVS */
        if (isp->inputs[asd->input_curr].type == SOC_CAMERA)
-               asd->params.video_dis_en = 0;
+               asd->params.video_dis_en = false;
 
        if (asd->params.video_dis_en &&
            asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) {
                        ffmt = req_ffmt;
                        dev_warn(isp->dev,
                          "can not enable video dis due to sensor limitation.");
-                       asd->params.video_dis_en = 0;
+                       asd->params.video_dis_en = false;
                }
        }
        dev_dbg(isp->dev, "sensor width: %d, height: %d\n",
            (ffmt->width < req_ffmt->width || ffmt->height < req_ffmt->height)) {
                dev_warn(isp->dev,
                         "can not enable video dis due to sensor limitation.");
-               asd->params.video_dis_en = 0;
+               asd->params.video_dis_en = false;
        }
 
        atomisp_subdev_set_ffmt(&asd->subdev, fh.pad,
 
        if (!user_shading_table->enable) {
                atomisp_css_set_shading_table(asd, NULL);
-               asd->params.sc_en = 0;
+               asd->params.sc_en = false;
                return 0;
        }
 
        free_table = asd->params.css_param.shading_table;
        asd->params.css_param.shading_table = shading_table;
        atomisp_css_set_shading_table(asd, shading_table);
-       asd->params.sc_en = 1;
+       asd->params.sc_en = true;
 
 out:
        if (free_table != NULL)
 
 {
        unsigned int i;
 
-       isp->sw_contex.file_input = 0;
+       isp->sw_contex.file_input = false;
        isp->need_gfx_throttle = true;
        isp->isp_fatal_error = false;
        isp->mipi_frame_size = 0;
        v4l2_ctrl_s_ctrl(asd->run_mode, ATOMISP_RUN_MODE_STILL_CAPTURE);
        memset(&asd->params.css_param, 0, sizeof(asd->params.css_param));
        asd->params.color_effect = V4L2_COLORFX_NONE;
-       asd->params.bad_pixel_en = 1;
-       asd->params.gdc_cac_en = 0;
-       asd->params.video_dis_en = 0;
-       asd->params.sc_en = 0;
-       asd->params.fpn_en = 0;
-       asd->params.xnr_en = 0;
+       asd->params.bad_pixel_en = true;
+       asd->params.gdc_cac_en = false;
+       asd->params.video_dis_en = false;
+       asd->params.sc_en = false;
+       asd->params.fpn_en = false;
+       asd->params.xnr_en = false;
        asd->params.false_color = 0;
        asd->params.online_process = 1;
        asd->params.yuv_ds_en = 0;
 
        }
 
        rt_mutex_lock(&isp->mutex);
-       isp->sw_contex.file_input = 1;
+       isp->sw_contex.file_input = true;
        rt_mutex_unlock(&isp->mutex);
 
        return 0;
 
        }
 
        for (i = SH_CSS_QUEUE_C_ID; i < SH_CSS_MAX_NUM_QUEUES; i++) {
-               if (queue_availability[thread_id][i] == true) {
+               if (queue_availability[thread_id][i]) {
                        queue_availability[thread_id][i] = false;
                        buffer_type_to_queue_id_map[thread_id][buf_type] = i;
                        break;
 
 #elif defined(USE_INPUT_SYSTEM_VERSION_2401)
 input_system_error_t ia_css_isys_init(void)
 {
-       input_system_error_t error = INPUT_SYSTEM_ERR_NO_ERROR;
-
        ia_css_isys_csi_rx_lut_rmgr_init();
        ia_css_isys_ibuf_rmgr_init();
        ia_css_isys_dma_channel_rmgr_init();
        isys_irqc_status_enable(ISYS_IRQ1_ID);
        isys_irqc_status_enable(ISYS_IRQ2_ID);
 
-       return error;
+       return INPUT_SYSTEM_ERR_NO_ERROR;
 }
 #endif
 
 
                break;
        }
 
-       if (rc == false)
+       if (!rc)
                return false;
 
        if (!acquire_sid(me->stream2mmio_id, &(me->stream2mmio_sid_id))) {
 
        rc = calculate_stream2mmio_cfg(isys_cfg, metadata,
                        &(channel_cfg->stream2mmio_cfg));
-       if (rc == false)
+       if (!rc)
                return false;
 
        rc = calculate_ibuf_ctrl_cfg(
                        input_port,
                        isys_cfg,
                        &(channel_cfg->ibuf_ctrl_cfg));
-       if (rc == false)
+       if (!rc)
                return false;
        if (metadata)
                channel_cfg->ibuf_ctrl_cfg.stores_per_frame = isys_cfg->metadata.lines_per_frame;
                        channel,
                        isys_cfg,
                        &(channel_cfg->dma_cfg));
-       if (rc == false)
+       if (!rc)
                return false;
 
        rc = calculate_isys2401_dma_port_cfg(
                        false,
                        metadata,
                        &(channel_cfg->dma_src_port_cfg));
-       if (rc == false)
+       if (!rc)
                return false;
 
        rc = calculate_isys2401_dma_port_cfg(
                        isys_cfg->raw_packed,
                        metadata,
                        &(channel_cfg->dma_dest_port_cfg));
-       if (rc == false)
+       if (!rc)
                return false;
 
        return true;
 
 
                But the below is more descriptive.
        */
-       assert(found_sp_thread != false);
+       assert(found_sp_thread);
 }
 
 static void pipeline_unmap_num_to_sp_thread(unsigned int pipe_num)
 
 
        /* get the SP thread id */
        rc = ia_css_pipeline_get_sp_thread_id(ia_css_pipe_get_pipe_num(pipe), &sp_thread_id);
-       if (rc != true)
+       if (!rc)
                return IA_CSS_ERR_INTERNAL_ERROR;
        /* get the target input terminal */
        sp_pipeline_input_terminal = &(sh_css_sp_group.pipe_io[sp_thread_id].input);
                                        &(isys_stream_descr));
                }
 
-               if (rc != true)
+               if (!rc)
                        return IA_CSS_ERR_INTERNAL_ERROR;
 
                isys_stream_id = ia_css_isys_generate_stream_id(sp_thread_id, i);
                                &(isys_stream_descr),
                                &(sp_pipeline_input_terminal->context.virtual_input_system_stream[i]),
                                isys_stream_id);
-               if (rc != true)
+               if (!rc)
                        return IA_CSS_ERR_INTERNAL_ERROR;
 
                /* calculate the configuration of the virtual Input System (2401) */
                                &(sp_pipeline_input_terminal->context.virtual_input_system_stream[i]),
                                &(isys_stream_descr),
                                &(sp_pipeline_input_terminal->ctrl.virtual_input_system_stream_cfg[i]));
-               if (rc != true) {
+               if (!rc) {
                        ia_css_isys_stream_destroy(&(sp_pipeline_input_terminal->context.virtual_input_system_stream[i]));
                        return IA_CSS_ERR_INTERNAL_ERROR;
                }
        ifmtr_set_if_blocking_mode_reset = true;
 #endif
 
-       if (fw_explicitly_loaded == false) {
+       if (!fw_explicitly_loaded) {
                ia_css_unload_firmware();
        }
        ia_css_spctrl_unload_fw(SP0_ID);
 
                for (i = 0, j = 0; i < num_stage; i++) {
                        assert(j < num_output_stage);
-                       if (pipe->pipe_settings.yuvpp.is_output_stage[i] == true) {
+                       if (pipe->pipe_settings.yuvpp.is_output_stage[i]) {
                                tmp_out_frame = out_frame[j];
                                tmp_vf_frame = vf_frame[j];
                        } else {
                        }
                        /* we use output port 1 as internal output port */
                        tmp_in_frame = yuv_scaler_stage->args.out_frame[1];
-                       if (pipe->pipe_settings.yuvpp.is_output_stage[i] == true) {
+                       if (pipe->pipe_settings.yuvpp.is_output_stage[i]) {
                                if (tmp_vf_frame && (tmp_vf_frame->info.res.width != 0)) {
                                        in_frame = yuv_scaler_stage->args.out_vf_frame;
                                        err = add_vf_pp_stage(pipe, in_frame, tmp_vf_frame, &vf_pp_binary[j],
                                  struct ia_css_frame_info *info,
                                  unsigned int idx)
 {
-       enum ia_css_err err = IA_CSS_SUCCESS;
-
        assert(pipe != NULL);
        assert(info != NULL);
 
 
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                                                "sh_css_pipe_get_output_frame_info() leave:\n");
-       return err;
+       return IA_CSS_SUCCESS;
 }
 
 #if !defined(HAS_NO_INPUT_SYSTEM)
 enum ia_css_err
 ia_css_stream_set_output_padded_width(struct ia_css_stream *stream, unsigned int output_padded_width)
 {
-       enum ia_css_err err = IA_CSS_SUCCESS;
-
        struct ia_css_pipe *pipe;
 
        assert(stream != NULL);
        pipe->config.output_info[IA_CSS_PIPE_OUTPUT_STAGE_0].padded_width = output_padded_width;
        pipe->output_info[IA_CSS_PIPE_OUTPUT_STAGE_0].padded_width = output_padded_width;
 
-       return err;
+       return IA_CSS_SUCCESS;
 }
 
 static struct ia_css_binary *
                                (uint8_t) IA_CSS_PSYS_SW_EVENT_STAGE_ENABLE_DISABLE,
                                (uint8_t) thread_id,
                                (uint8_t) stage->stage_num,
-                               (enable == true) ? 1 : 0);
+                               enable ? 1 : 0);
                        if (err == IA_CSS_SUCCESS) {
                                if(enable)
                                        SH_CSS_QOS_STAGE_ENABLE(&(sh_css_sp_group.pipe[thread_id]),stage->stage_num);
 
        buffer_record = &hmm_buffer_record[0];
        for (i = 0; i < MAX_HMM_BUFFER_NUM; i++) {
-               if (buffer_record->in_use == false) {
+               if (!buffer_record->in_use) {
                        buffer_record->in_use = true;
                        buffer_record->type = type;
                        buffer_record->h_vbuf = h_vbuf;
 
        buffer_record = &hmm_buffer_record[0];
        for (i = 0; i < MAX_HMM_BUFFER_NUM; i++) {
-               if ((buffer_record->in_use == true) &&
+               if ((buffer_record->in_use) &&
                    (buffer_record->type == type) &&
                    (buffer_record->h_vbuf != NULL) &&
                    (buffer_record->h_vbuf->vptr == ddr_buffer_addr)) {
                buffer_record++;
        }
 
-       if (found_record == true)
+       if (found_record)
                return buffer_record;
        else
                return NULL;
 
        bool two_ppc,
        bool deinterleaved)
 {
-       enum ia_css_err err = IA_CSS_SUCCESS;
 #ifdef ISP2401
        struct ia_css_pipe *pipe = find_pipe_by_num(pipeline->pipe_num);
        const struct ia_css_resolution *res;
        ia_css_ref_configure(binary, (const struct ia_css_frame **)args->delay_frames, pipeline->dvs_frame_delay);
        ia_css_tnr_configure(binary, (const struct ia_css_frame **)args->tnr_frames);
        ia_css_bayer_io_config(binary, args);
-       return err;
+       return IA_CSS_SUCCESS;
 }
 
 static void