lutdpc->dpc_size > LUT_DPC_MAX_SIZE)
                return -EINVAL;
 
-       if (lutdpc->en && !lutdpc->table)
+       if (lutdpc->en)
                return -EINVAL;
 
        for (i = 0; i < lutdpc->dpc_size; i++)
 
        table_size = gamma->tbl_size;
 
-       if (!gamma->bypass_r && !gamma_param->table_r) {
+       if (!gamma->bypass_r) {
                dev_err(dev,
                        "ipipe_get_gamma_params: table ptr empty for R\n");
                return -EINVAL;
        memcpy(gamma_param->table_r, gamma->table_r,
               (table_size * sizeof(struct vpfe_ipipe_gamma_entry)));
 
-       if (!gamma->bypass_g && !gamma_param->table_g) {
+       if (!gamma->bypass_g) {
                dev_err(dev, "ipipe_get_gamma_params: table ptr empty for G\n");
                return -EINVAL;
        }
        memcpy(gamma_param->table_g, gamma->table_g,
               (table_size * sizeof(struct vpfe_ipipe_gamma_entry)));
 
-       if (!gamma->bypass_b && !gamma_param->table_b) {
+       if (!gamma->bypass_b) {
                dev_err(dev, "ipipe_get_gamma_params: table ptr empty for B\n");
                return -EINVAL;
        }
 {
        struct vpfe_ipipe_3d_lut *lut_param = param;
        struct vpfe_ipipe_3d_lut *lut = &ipipe->config.lut;
-       struct device *dev = ipipe->subdev.v4l2_dev->dev;
 
        lut_param->en = lut->en;
-       if (!lut_param->table) {
-               dev_err(dev, "ipipe_get_3d_lut_params: Invalid table ptr\n");
-               return -EINVAL;
-       }
 
        memcpy(lut_param->table, &lut->table,
               (VPFE_IPIPE_MAX_SIZE_3D_LUT *
 {
        struct vpfe_ipipe_gbce *gbce_param = param;
        struct vpfe_ipipe_gbce *gbce = &ipipe->config.gbce;
-       struct device *dev = ipipe->subdev.v4l2_dev->dev;
 
        gbce_param->en = gbce->en;
        gbce_param->type = gbce->type;
-       if (!gbce_param->table) {
-               dev_err(dev, "ipipe_get_gbce_params: Invalid table ptr\n");
-               return -EINVAL;
-       }
 
        memcpy(gbce_param->table, gbce->table,
                (VPFE_IPIPE_MAX_SIZE_GBCE_LUT * sizeof(unsigned short)));
 
        regw_ip(base_addr, LUT_DPC_START_ADDR, DPC_LUT_ADR);
        regw_ip(base_addr, dpc->dpc_size, DPC_LUT_SIZ & LUT_DPC_SIZE_MASK);
 
-       if (dpc->table == NULL)
-               return;
-
        for (count = 0; count < dpc->dpc_size; count++) {
                if (count >= max_tbl_size)
                        lut_start_addr = DPC_TB1_START_ADDR;
 
        table_size = gamma->tbl_size;
 
-       if (!gamma->bypass_r && gamma->table_r != NULL)
+       if (!gamma->bypass_r)
                ipipe_update_gamma_tbl(isp5_base_addr, gamma->table_r,
                        table_size, GAMMA_R_START_ADDR);
-       if (!gamma->bypass_b && gamma->table_b != NULL)
+       if (!gamma->bypass_b)
                ipipe_update_gamma_tbl(isp5_base_addr, gamma->table_b,
                        table_size, GAMMA_B_START_ADDR);
-       if (!gamma->bypass_g && gamma->table_g != NULL)
+       if (!gamma->bypass_g)
                ipipe_update_gamma_tbl(isp5_base_addr, gamma->table_g,
                        table_size, GAMMA_G_START_ADDR);
 }
        if (!lut_3d->en)
                return;
 
-       /* lut_3d enabled */
-       if (!lut_3d->table)
-               return;
-
        /* valied table */
        tbl = lut_3d->table;
        for (i = 0; i < VPFE_IPIPE_MAX_SIZE_3D_LUT; i++) {
 
        regw_ip(base_addr, gbce->type, GBCE_TYP);
 
-       if (!gbce->table)
-               return;
-
        for (count = 0; count < VPFE_IPIPE_MAX_SIZE_GBCE_LUT; count += 2)
                w_ip_table(isp5_base_addr, ((gbce->table[count + 1] & mask) <<
                GBCE_ENTRY_SHIFT) | (gbce->table[count] & mask),
        regw_ip(base_addr, ee->es_gain_grad & YEE_THR_MASK, YEE_G_GAN);
        regw_ip(base_addr, ee->es_ofst_grad & YEE_THR_MASK, YEE_G_OFT);
 
-       if (ee->table == NULL)
-               return;
-
        for (count = 0; count < VPFE_IPIPE_MAX_SIZE_YEE_LUT; count += 2)
                w_ip_table(isp5_base_addr, ((ee->table[count + 1] &
                YEE_ENTRY_MASK) << YEE_ENTRY_SHIFT) |