WARN_ON(!vb);
                if (vb)
                        pipe->frame_config_id[vb->i] = frame->isp_config_id;
-#ifndef ISP2401
                if (css_pipe_id == IA_CSS_PIPE_ID_CAPTURE &&
                    asd->pending_capture_request > 0) {
                        err = atomisp_css_offline_capture_configure(asd,
-#else
-               if (css_pipe_id == IA_CSS_PIPE_ID_CAPTURE) {
-                       if (asd->pending_capture_request > 0) {
-                               err = atomisp_css_offline_capture_configure(asd,
-#endif
                                        asd->params.offline_parm.num_captures,
                                        asd->params.offline_parm.skip_frames,
                                        asd->params.offline_parm.offset);
                 */
                wake_up(&vb->done);
        }
-#ifndef ISP2401
-
-#else
+#ifdef ISP2401
        atomic_set(&pipe->wdt_count, 0);
 #endif
        /*
 {
        struct atomisp_device *isp = video_get_drvdata(vdev);
        struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
-#ifndef ISP2401
        struct v4l2_subdev_pad_config pad_cfg;
-#else
-    struct v4l2_subdev_pad_config pad_cfg;
-#endif
        struct v4l2_subdev_format format = {
                .which = V4L2_SUBDEV_FORMAT_TRY,
-#ifndef ISP2401
        };
-#else
-               };
-#endif
+
        struct v4l2_mbus_framefmt *snr_mbus_fmt = &format.format;
        const struct atomisp_format_bridge *fmt;
        struct atomisp_input_stream_info *stream_info =
-#ifndef ISP2401
            (struct atomisp_input_stream_info *)snr_mbus_fmt->reserved;
-#else
-               (struct atomisp_input_stream_info *)snr_mbus_fmt->reserved;
-#endif
        uint16_t stream_index;
        int source_pad = atomisp_subdev_source_pad(vdev);
        int ret;
                snr_mbus_fmt->width, snr_mbus_fmt->height);
 
        ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
-#ifndef ISP2401
                               pad, set_fmt, &pad_cfg, &format);
-#else
-                       pad, set_fmt, &pad_cfg, &format);
-#endif
        if (ret)
                return ret;
 
                        struct atomisp_ae_window *arg)
 {
        struct atomisp_device *isp = asd->isp;
-#ifndef ISP2401
        /* Coverity CID 298071 - initialzize struct */
-#endif
        struct v4l2_subdev_selection sel = { 0 };
 
        sel.r.left = arg->x_left;
 
        return NULL;
 }
 
-#ifndef ISP2401
 const struct atomisp_format_bridge *atomisp_get_format_bridge_from_mbus(
        u32 mbus_code)
-#else
-const struct atomisp_format_bridge *atomisp_get_format_bridge_from_mbus(u32
-                                                                       mbus_code)
-#endif
 {
        unsigned int i;
 
                /* this buffer will have a per-frame parameter */
                pipe->frame_request_config_id[buf->index] = buf->reserved2 &
                                        ~ATOMISP_BUFFER_HAS_PER_FRAME_SETTING;
-#ifndef ISP2401
                dev_dbg(isp->dev, "This buffer requires per_frame setting which has isp_config_id %d\n",
                        pipe->frame_request_config_id[buf->index]);
-#else
-               dev_dbg(isp->dev, "This buffer requires per_frame setting \
-                               which has isp_config_id %d\n",
-                               pipe->frame_request_config_id[buf->index]);
-#endif
        } else {
                pipe->frame_request_config_id[buf->index] = 0;
        }
        buf->reserved2 = pipe->frame_config_id[buf->index];
        rt_mutex_unlock(&isp->mutex);
 
-#ifndef ISP2401
        dev_dbg(isp->dev, "dqbuf buffer %d (%s) for asd%d with exp_id %d, isp_config_id %d\n",
-#else
-       dev_dbg(isp->dev, "dqbuf buffer %d (%s) for asd%d with exp_id %d, \
-                       isp_config_id %d\n",
-#endif
                buf->index, vdev->name, asd->index, buf->reserved >> 16,
                buf->reserved2);
        return 0;
        else
                return 1;
 }
-#ifndef ISP2401
-int atomisp_stream_on_master_slave_sensor(struct atomisp_device *isp, bool isp_timeout)
-#else
+
 int atomisp_stream_on_master_slave_sensor(struct atomisp_device *isp,
        bool isp_timeout)
-#endif
 {
        unsigned int master = -1, slave = -1, delay_slave = 0;
        int i, ret;
 
                r.width = ffmt[pad]->width;
                r.height = ffmt[pad]->height;
 
-#ifndef ISP2401
-               atomisp_subdev_set_selection(sd, cfg, which, pad, target, flags,
-                                            &r);
+               atomisp_subdev_set_selection(sd, cfg, which, pad,
+                                            target, flags, &r);
                break;
        }
-#else
-                       atomisp_subdev_set_selection(sd, cfg, which, pad,
-                                                    target, flags, &r);
-                       break;
-               }
-#endif
        }
 }
 
                             i < ATOMISP_SUBDEV_PADS_NUM; i++) {
                                struct v4l2_rect tmp = *crop[pad];
 
-#ifndef ISP2401
                                atomisp_subdev_set_selection(
                                        sd, cfg, which, i, V4L2_SEL_TGT_COMPOSE,
                                        flags, &tmp);
                        }
-#else
-                                       atomisp_subdev_set_selection(sd, cfg,
-                                                                    which, i,
-                                                                    V4L2_SEL_TGT_COMPOSE,
-                                                                    flags,
-                                                                    &tmp);
-                               }
-#endif
                }
 
                if (which == V4L2_SUBDEV_FORMAT_TRY)
        return hbin;
 }
 
-#ifndef ISP2401
-void atomisp_subdev_set_ffmt(struct v4l2_subdev *sd, struct v4l2_subdev_pad_config *cfg,
-                            uint32_t which, uint32_t pad,
-                            struct v4l2_mbus_framefmt *ffmt)
-#else
 void atomisp_subdev_set_ffmt(struct v4l2_subdev *sd,
                             struct v4l2_subdev_pad_config *cfg, uint32_t which,
                             uint32_t pad, struct v4l2_mbus_framefmt *ffmt)
-#endif
 {
        struct atomisp_sub_device *isp_sd = v4l2_get_subdevdata(sd);
        struct atomisp_device *isp = isp_sd->isp;
        struct v4l2_mbus_framefmt *__ffmt =
-#ifndef ISP2401
                atomisp_subdev_get_ffmt(sd, cfg, which, pad);
-#else
-           atomisp_subdev_get_ffmt(sd, cfg, which, pad);
-#endif
        uint16_t vdev_pad = atomisp_subdev_source_pad(sd->devnode);
        enum atomisp_input_stream_id stream_id;
 
  * to the format type.
  */
 static int isp_subdev_get_format(struct v4l2_subdev *sd,
-#ifndef ISP2401
-       struct v4l2_subdev_pad_config *cfg, struct v4l2_subdev_format *fmt)
-#else
                                 struct v4l2_subdev_pad_config *cfg,
                                 struct v4l2_subdev_format *fmt)
-#endif
 {
        fmt->format = *atomisp_subdev_get_ffmt(sd, cfg, fmt->which, fmt->pad);
 
  * to the format type.
  */
 static int isp_subdev_set_format(struct v4l2_subdev *sd,
-#ifndef ISP2401
-       struct v4l2_subdev_pad_config *cfg, struct v4l2_subdev_format *fmt)
-#else
                                 struct v4l2_subdev_pad_config *cfg,
                                 struct v4l2_subdev_format *fmt)
-#endif
 {
        atomisp_subdev_set_ffmt(sd, cfg, fmt->which, fmt->pad, &fmt->format);
 
 
 /* V4L2 subdev pad operations */
 static const struct v4l2_subdev_pad_ops isp_subdev_v4l2_pad_ops = {
-#ifndef ISP2401
-        .enum_mbus_code = isp_subdev_enum_mbus_code,
-        .get_fmt = isp_subdev_get_format, .set_fmt = isp_subdev_set_format,
-        .get_selection = isp_subdev_get_selection,
-        .set_selection = isp_subdev_set_selection,
-        .link_validate = v4l2_subdev_link_validate_default,
-#else
        .enum_mbus_code = isp_subdev_enum_mbus_code,
        .get_fmt = isp_subdev_get_format,
        .set_fmt = isp_subdev_set_format,
        .get_selection = isp_subdev_get_selection,
        .set_selection = isp_subdev_set_selection,
        .link_validate = v4l2_subdev_link_validate_default,
-#endif
 };
 
 /* V4L2 subdev operations */
 static const struct v4l2_subdev_ops isp_subdev_v4l2_ops = {
-#ifndef ISP2401
-        .core = &isp_subdev_v4l2_core_ops, .pad = &isp_subdev_v4l2_pad_ops,
-#else
        .core = &isp_subdev_v4l2_core_ops,
        .pad = &isp_subdev_v4l2_pad_ops,
-#endif
 };
 
 static void isp_subdev_init_params(struct atomisp_sub_device *asd)
        pads[ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE].flags = MEDIA_PAD_FL_SOURCE;
        pads[ATOMISP_SUBDEV_PAD_SOURCE_VIDEO].flags = MEDIA_PAD_FL_SOURCE;
 
-#ifndef ISP2401
        asd->fmt[ATOMISP_SUBDEV_PAD_SINK].fmt.code =
                MEDIA_BUS_FMT_SBGGR10_1X10;
-#else
-       asd->fmt[ATOMISP_SUBDEV_PAD_SINK].fmt.code = MEDIA_BUS_FMT_SBGGR10_1X10;
-#endif
        asd->fmt[ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW].fmt.code =
                MEDIA_BUS_FMT_SBGGR10_1X10;
        asd->fmt[ATOMISP_SUBDEV_PAD_SOURCE_VF].fmt.code =
                return ret;
 
        atomisp_init_subdev_pipe(asd, &asd->video_in,
-#ifndef ISP2401
-                       V4L2_BUF_TYPE_VIDEO_OUTPUT);
-#else
                                 V4L2_BUF_TYPE_VIDEO_OUTPUT);
-#endif
 
        atomisp_init_subdev_pipe(asd, &asd->video_out_preview,
-#ifndef ISP2401
-                       V4L2_BUF_TYPE_VIDEO_CAPTURE);
-#else
                                 V4L2_BUF_TYPE_VIDEO_CAPTURE);
-#endif
 
        atomisp_init_subdev_pipe(asd, &asd->video_out_vf,
-#ifndef ISP2401
-                       V4L2_BUF_TYPE_VIDEO_CAPTURE);
-#else
                                 V4L2_BUF_TYPE_VIDEO_CAPTURE);
-#endif
 
        atomisp_init_subdev_pipe(asd, &asd->video_out_capture,
-#ifndef ISP2401
-                       V4L2_BUF_TYPE_VIDEO_CAPTURE);
-#else
                                 V4L2_BUF_TYPE_VIDEO_CAPTURE);
-#endif
 
        atomisp_init_subdev_pipe(asd, &asd->video_out_video_capture,
-#ifndef ISP2401
-                       V4L2_BUF_TYPE_VIDEO_CAPTURE);
-#else
                                 V4L2_BUF_TYPE_VIDEO_CAPTURE);
-#endif
 
        atomisp_init_acc_pipe(asd, &asd->video_acc);
 
        unsigned int i, pending_event;
 
        list_for_each_entry_safe(fh, fh_tmp,
-#ifndef ISP2401
                &asd->subdev.devnode->fh_list, list) {
-#else
-                                &asd->subdev.devnode->fh_list, list) {
-#endif
                pending_event = v4l2_event_pending(fh);
                for (i = 0; i < pending_event; i++)
                        v4l2_event_dequeue(fh, &event, 1);
        return ret;
 }
 
-#ifndef ISP2401
-
-#endif
 /*
  * atomisp_subdev_init - ISP Subdevice  initialization.
  * @dev: Device pointer specific to the ATOM ISP.