linux/drivers/staging/media/atomisp/pci/atomisp_cmd.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Support for Medifield PNW Camera Imaging ISP subsystem.
   4 *
   5 * Copyright (c) 2010 Intel Corporation. All Rights Reserved.
   6 *
   7 * Copyright (c) 2010 Silicon Hive www.siliconhive.com.
   8 *
   9 * This program is free software; you can redistribute it and/or
  10 * modify it under the terms of the GNU General Public License version
  11 * 2 as published by the Free Software Foundation.
  12 *
  13 * This program is distributed in the hope that it will be useful,
  14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 * GNU General Public License for more details.
  17 *
  18 *
  19 */
  20#include <linux/errno.h>
  21#include <linux/firmware.h>
  22#include <linux/pci.h>
  23#include <linux/interrupt.h>
  24#include <linux/io.h>
  25#include <linux/kernel.h>
  26#include <linux/kfifo.h>
  27#include <linux/pm_runtime.h>
  28#include <linux/timer.h>
  29
  30#include <asm/iosf_mbi.h>
  31
  32#include <media/v4l2-event.h>
  33#include <media/videobuf-vmalloc.h>
  34
  35#define CREATE_TRACE_POINTS
  36#include "atomisp_trace_event.h"
  37
  38#include "atomisp_cmd.h"
  39#include "atomisp_common.h"
  40#include "atomisp_fops.h"
  41#include "atomisp_internal.h"
  42#include "atomisp_ioctl.h"
  43#include "atomisp-regs.h"
  44#include "atomisp_tables.h"
  45#include "atomisp_acc.h"
  46#include "atomisp_compat.h"
  47#include "atomisp_subdev.h"
  48#include "atomisp_dfs_tables.h"
  49
  50#include <hmm/hmm.h>
  51
  52#include "sh_css_hrt.h"
  53#include "sh_css_defs.h"
  54#include "system_global.h"
  55#include "sh_css_internal.h"
  56#include "sh_css_sp.h"
  57#include "gp_device.h"
  58#include "device_access.h"
  59#include "irq.h"
  60
  61#include "ia_css_types.h"
  62#include "ia_css_stream.h"
  63#include "ia_css_debug.h"
  64#include "bits.h"
  65
  66/* We should never need to run the flash for more than 2 frames.
  67 * At 15fps this means 133ms. We set the timeout a bit longer.
  68 * Each flash driver is supposed to set its own timeout, but
  69 * just in case someone else changed the timeout, we set it
  70 * here to make sure we don't damage the flash hardware. */
  71#define FLASH_TIMEOUT 800 /* ms */
  72
  73union host {
  74        struct {
  75                void *kernel_ptr;
  76                void __user *user_ptr;
  77                int size;
  78        } scalar;
  79        struct {
  80                void *hmm_ptr;
  81        } ptr;
  82};
  83
  84/*
  85 * get sensor:dis71430/ov2720 related info from v4l2_subdev->priv data field.
  86 * subdev->priv is set in mrst.c
  87 */
  88struct camera_mipi_info *atomisp_to_sensor_mipi_info(struct v4l2_subdev *sd)
  89{
  90        return (struct camera_mipi_info *)v4l2_get_subdev_hostdata(sd);
  91}
  92
  93/*
  94 * get struct atomisp_video_pipe from v4l2 video_device
  95 */
  96struct atomisp_video_pipe *atomisp_to_video_pipe(struct video_device *dev)
  97{
  98        return (struct atomisp_video_pipe *)
  99               container_of(dev, struct atomisp_video_pipe, vdev);
 100}
 101
 102/*
 103 * get struct atomisp_acc_pipe from v4l2 video_device
 104 */
 105struct atomisp_acc_pipe *atomisp_to_acc_pipe(struct video_device *dev)
 106{
 107        return (struct atomisp_acc_pipe *)
 108               container_of(dev, struct atomisp_acc_pipe, vdev);
 109}
 110
 111static unsigned short atomisp_get_sensor_fps(struct atomisp_sub_device *asd)
 112{
 113        struct v4l2_subdev_frame_interval fi = { 0 };
 114        struct atomisp_device *isp = asd->isp;
 115
 116        unsigned short fps = 0;
 117        int ret;
 118
 119        ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
 120                               video, g_frame_interval, &fi);
 121
 122        if (!ret && fi.interval.numerator)
 123                fps = fi.interval.denominator / fi.interval.numerator;
 124
 125        return fps;
 126}
 127
 128/*
 129 * DFS progress is shown as follows:
 130 * 1. Target frequency is calculated according to FPS/Resolution/ISP running
 131 *    mode.
 132 * 2. Ratio is calculated using formula: 2 * HPLL / target frequency - 1
 133 *    with proper rounding.
 134 * 3. Set ratio to ISPFREQ40, 1 to FREQVALID and ISPFREQGUAR40
 135 *    to 200MHz in ISPSSPM1.
 136 * 4. Wait for FREQVALID to be cleared by P-Unit.
 137 * 5. Wait for field ISPFREQSTAT40 in ISPSSPM1 turn to ratio set in 3.
 138 */
 139static int write_target_freq_to_hw(struct atomisp_device *isp,
 140                                   unsigned int new_freq)
 141{
 142        unsigned int ratio, timeout, guar_ratio;
 143        u32 isp_sspm1 = 0;
 144        int i;
 145
 146        if (!isp->hpll_freq) {
 147                dev_err(isp->dev, "failed to get hpll_freq. no change to freq\n");
 148                return -EINVAL;
 149        }
 150
 151        iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
 152        if (isp_sspm1 & ISP_FREQ_VALID_MASK) {
 153                dev_dbg(isp->dev, "clearing ISPSSPM1 valid bit.\n");
 154                iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_WRITE, ISPSSPM1,
 155                               isp_sspm1 & ~(1 << ISP_FREQ_VALID_OFFSET));
 156        }
 157
 158        ratio = (2 * isp->hpll_freq + new_freq / 2) / new_freq - 1;
 159        guar_ratio = (2 * isp->hpll_freq + 200 / 2) / 200 - 1;
 160
 161        iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
 162        isp_sspm1 &= ~(0x1F << ISP_REQ_FREQ_OFFSET);
 163
 164        for (i = 0; i < ISP_DFS_TRY_TIMES; i++) {
 165                iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_WRITE, ISPSSPM1,
 166                               isp_sspm1
 167                               | ratio << ISP_REQ_FREQ_OFFSET
 168                               | 1 << ISP_FREQ_VALID_OFFSET
 169                               | guar_ratio << ISP_REQ_GUAR_FREQ_OFFSET);
 170
 171                iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
 172                timeout = 20;
 173                while ((isp_sspm1 & ISP_FREQ_VALID_MASK) && timeout) {
 174                        iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
 175                        dev_dbg(isp->dev, "waiting for ISPSSPM1 valid bit to be 0.\n");
 176                        udelay(100);
 177                        timeout--;
 178                }
 179
 180                if (timeout != 0)
 181                        break;
 182        }
 183
 184        if (timeout == 0) {
 185                dev_err(isp->dev, "DFS failed due to HW error.\n");
 186                return -EINVAL;
 187        }
 188
 189        iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
 190        timeout = 10;
 191        while (((isp_sspm1 >> ISP_FREQ_STAT_OFFSET) != ratio) && timeout) {
 192                iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
 193                dev_dbg(isp->dev, "waiting for ISPSSPM1 status bit to be 0x%x.\n",
 194                        new_freq);
 195                udelay(100);
 196                timeout--;
 197        }
 198        if (timeout == 0) {
 199                dev_err(isp->dev, "DFS target freq is rejected by HW.\n");
 200                return -EINVAL;
 201        }
 202
 203        return 0;
 204}
 205
 206int atomisp_freq_scaling(struct atomisp_device *isp,
 207                         enum atomisp_dfs_mode mode,
 208                         bool force)
 209{
 210        struct pci_dev *pdev = to_pci_dev(isp->dev);
 211        /* FIXME! Only use subdev[0] status yet */
 212        struct atomisp_sub_device *asd = &isp->asd[0];
 213        const struct atomisp_dfs_config *dfs;
 214        unsigned int new_freq;
 215        struct atomisp_freq_scaling_rule curr_rules;
 216        int i, ret;
 217        unsigned short fps = 0;
 218
 219        if (isp->sw_contex.power_state != ATOM_ISP_POWER_UP) {
 220                dev_err(isp->dev, "DFS cannot proceed due to no power.\n");
 221                return -EINVAL;
 222        }
 223
 224        if ((pdev->device & ATOMISP_PCI_DEVICE_SOC_MASK) ==
 225            ATOMISP_PCI_DEVICE_SOC_CHT && ATOMISP_USE_YUVPP(asd))
 226                isp->dfs = &dfs_config_cht_soc;
 227
 228        dfs = isp->dfs;
 229
 230        if (dfs->lowest_freq == 0 || dfs->max_freq_at_vmin == 0 ||
 231            dfs->highest_freq == 0 || dfs->dfs_table_size == 0 ||
 232            !dfs->dfs_table) {
 233                dev_err(isp->dev, "DFS configuration is invalid.\n");
 234                return -EINVAL;
 235        }
 236
 237        if (mode == ATOMISP_DFS_MODE_LOW) {
 238                new_freq = dfs->lowest_freq;
 239                goto done;
 240        }
 241
 242        if (mode == ATOMISP_DFS_MODE_MAX) {
 243                new_freq = dfs->highest_freq;
 244                goto done;
 245        }
 246
 247        fps = atomisp_get_sensor_fps(asd);
 248        if (fps == 0) {
 249                dev_info(isp->dev,
 250                         "Sensor didn't report FPS. Using DFS max mode.\n");
 251                new_freq = dfs->highest_freq;
 252                goto done;
 253        }
 254
 255        curr_rules.width = asd->fmt[asd->capture_pad].fmt.width;
 256        curr_rules.height = asd->fmt[asd->capture_pad].fmt.height;
 257        curr_rules.fps = fps;
 258        curr_rules.run_mode = asd->run_mode->val;
 259        /*
 260         * For continuous mode, we need to make the capture setting applied
 261         * since preview mode, because there is no chance to do this when
 262         * starting image capture.
 263         */
 264        if (asd->continuous_mode->val) {
 265                if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)
 266                        curr_rules.run_mode = ATOMISP_RUN_MODE_SDV;
 267                else
 268                        curr_rules.run_mode =
 269                            ATOMISP_RUN_MODE_CONTINUOUS_CAPTURE;
 270        }
 271
 272        /* search for the target frequency by looping freq rules*/
 273        for (i = 0; i < dfs->dfs_table_size; i++) {
 274                if (curr_rules.width != dfs->dfs_table[i].width &&
 275                    dfs->dfs_table[i].width != ISP_FREQ_RULE_ANY)
 276                        continue;
 277                if (curr_rules.height != dfs->dfs_table[i].height &&
 278                    dfs->dfs_table[i].height != ISP_FREQ_RULE_ANY)
 279                        continue;
 280                if (curr_rules.fps != dfs->dfs_table[i].fps &&
 281                    dfs->dfs_table[i].fps != ISP_FREQ_RULE_ANY)
 282                        continue;
 283                if (curr_rules.run_mode != dfs->dfs_table[i].run_mode &&
 284                    dfs->dfs_table[i].run_mode != ISP_FREQ_RULE_ANY)
 285                        continue;
 286                break;
 287        }
 288
 289        if (i == dfs->dfs_table_size)
 290                new_freq = dfs->max_freq_at_vmin;
 291        else
 292                new_freq = dfs->dfs_table[i].isp_freq;
 293
 294done:
 295        dev_dbg(isp->dev, "DFS target frequency=%d.\n", new_freq);
 296
 297        if ((new_freq == isp->sw_contex.running_freq) && !force)
 298                return 0;
 299
 300        dev_dbg(isp->dev, "Programming DFS frequency to %d\n", new_freq);
 301
 302        ret = write_target_freq_to_hw(isp, new_freq);
 303        if (!ret) {
 304                isp->sw_contex.running_freq = new_freq;
 305                trace_ipu_pstate(new_freq, -1);
 306        }
 307        return ret;
 308}
 309
 310/*
 311 * reset and restore ISP
 312 */
 313int atomisp_reset(struct atomisp_device *isp)
 314{
 315        /* Reset ISP by power-cycling it */
 316        int ret = 0;
 317
 318        dev_dbg(isp->dev, "%s\n", __func__);
 319        atomisp_css_suspend(isp);
 320        ret = atomisp_runtime_suspend(isp->dev);
 321        if (ret < 0)
 322                dev_err(isp->dev, "atomisp_runtime_suspend failed, %d\n", ret);
 323        ret = atomisp_mrfld_power_down(isp);
 324        if (ret < 0) {
 325                dev_err(isp->dev, "can not disable ISP power\n");
 326        } else {
 327                ret = atomisp_mrfld_power_up(isp);
 328                if (ret < 0)
 329                        dev_err(isp->dev, "can not enable ISP power\n");
 330                ret = atomisp_runtime_resume(isp->dev);
 331                if (ret < 0)
 332                        dev_err(isp->dev, "atomisp_runtime_resume failed, %d\n", ret);
 333        }
 334        ret = atomisp_css_resume(isp);
 335        if (ret)
 336                isp->isp_fatal_error = true;
 337
 338        return ret;
 339}
 340
 341/*
 342 * interrupt disable functions
 343 */
 344static void disable_isp_irq(enum hrt_isp_css_irq irq)
 345{
 346        irq_disable_channel(IRQ0_ID, irq);
 347
 348        if (irq != hrt_isp_css_irq_sp)
 349                return;
 350
 351        cnd_sp_irq_enable(SP0_ID, false);
 352}
 353
 354/*
 355 * interrupt clean function
 356 */
 357static void clear_isp_irq(enum hrt_isp_css_irq irq)
 358{
 359        irq_clear_all(IRQ0_ID);
 360}
 361
 362void atomisp_msi_irq_init(struct atomisp_device *isp)
 363{
 364        struct pci_dev *pdev = to_pci_dev(isp->dev);
 365        u32 msg32;
 366        u16 msg16;
 367
 368        pci_read_config_dword(pdev, PCI_MSI_CAPID, &msg32);
 369        msg32 |= 1 << MSI_ENABLE_BIT;
 370        pci_write_config_dword(pdev, PCI_MSI_CAPID, msg32);
 371
 372        msg32 = (1 << INTR_IER) | (1 << INTR_IIR);
 373        pci_write_config_dword(pdev, PCI_INTERRUPT_CTRL, msg32);
 374
 375        pci_read_config_word(pdev, PCI_COMMAND, &msg16);
 376        msg16 |= (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
 377                  PCI_COMMAND_INTX_DISABLE);
 378        pci_write_config_word(pdev, PCI_COMMAND, msg16);
 379}
 380
 381void atomisp_msi_irq_uninit(struct atomisp_device *isp)
 382{
 383        struct pci_dev *pdev = to_pci_dev(isp->dev);
 384        u32 msg32;
 385        u16 msg16;
 386
 387        pci_read_config_dword(pdev, PCI_MSI_CAPID, &msg32);
 388        msg32 &=  ~(1 << MSI_ENABLE_BIT);
 389        pci_write_config_dword(pdev, PCI_MSI_CAPID, msg32);
 390
 391        msg32 = 0x0;
 392        pci_write_config_dword(pdev, PCI_INTERRUPT_CTRL, msg32);
 393
 394        pci_read_config_word(pdev, PCI_COMMAND, &msg16);
 395        msg16 &= ~(PCI_COMMAND_MASTER);
 396        pci_write_config_word(pdev, PCI_COMMAND, msg16);
 397}
 398
 399static void atomisp_sof_event(struct atomisp_sub_device *asd)
 400{
 401        struct v4l2_event event = {0};
 402
 403        event.type = V4L2_EVENT_FRAME_SYNC;
 404        event.u.frame_sync.frame_sequence = atomic_read(&asd->sof_count);
 405
 406        v4l2_event_queue(asd->subdev.devnode, &event);
 407}
 408
 409void atomisp_eof_event(struct atomisp_sub_device *asd, uint8_t exp_id)
 410{
 411        struct v4l2_event event = {0};
 412
 413        event.type = V4L2_EVENT_FRAME_END;
 414        event.u.frame_sync.frame_sequence = exp_id;
 415
 416        v4l2_event_queue(asd->subdev.devnode, &event);
 417}
 418
 419static void atomisp_3a_stats_ready_event(struct atomisp_sub_device *asd,
 420        uint8_t exp_id)
 421{
 422        struct v4l2_event event = {0};
 423
 424        event.type = V4L2_EVENT_ATOMISP_3A_STATS_READY;
 425        event.u.frame_sync.frame_sequence = exp_id;
 426
 427        v4l2_event_queue(asd->subdev.devnode, &event);
 428}
 429
 430static void atomisp_metadata_ready_event(struct atomisp_sub_device *asd,
 431        enum atomisp_metadata_type md_type)
 432{
 433        struct v4l2_event event = {0};
 434
 435        event.type = V4L2_EVENT_ATOMISP_METADATA_READY;
 436        event.u.data[0] = md_type;
 437
 438        v4l2_event_queue(asd->subdev.devnode, &event);
 439}
 440
 441static void atomisp_reset_event(struct atomisp_sub_device *asd)
 442{
 443        struct v4l2_event event = {0};
 444
 445        event.type = V4L2_EVENT_ATOMISP_CSS_RESET;
 446
 447        v4l2_event_queue(asd->subdev.devnode, &event);
 448}
 449
 450static void print_csi_rx_errors(enum mipi_port_id port,
 451                                struct atomisp_device *isp)
 452{
 453        u32 infos = 0;
 454
 455        atomisp_css_rx_get_irq_info(port, &infos);
 456
 457        dev_err(isp->dev, "CSI Receiver port %d errors:\n", port);
 458        if (infos & IA_CSS_RX_IRQ_INFO_BUFFER_OVERRUN)
 459                dev_err(isp->dev, "  buffer overrun");
 460        if (infos & IA_CSS_RX_IRQ_INFO_ERR_SOT)
 461                dev_err(isp->dev, "  start-of-transmission error");
 462        if (infos & IA_CSS_RX_IRQ_INFO_ERR_SOT_SYNC)
 463                dev_err(isp->dev, "  start-of-transmission sync error");
 464        if (infos & IA_CSS_RX_IRQ_INFO_ERR_CONTROL)
 465                dev_err(isp->dev, "  control error");
 466        if (infos & IA_CSS_RX_IRQ_INFO_ERR_ECC_DOUBLE)
 467                dev_err(isp->dev, "  2 or more ECC errors");
 468        if (infos & IA_CSS_RX_IRQ_INFO_ERR_CRC)
 469                dev_err(isp->dev, "  CRC mismatch");
 470        if (infos & IA_CSS_RX_IRQ_INFO_ERR_UNKNOWN_ID)
 471                dev_err(isp->dev, "  unknown error");
 472        if (infos & IA_CSS_RX_IRQ_INFO_ERR_FRAME_SYNC)
 473                dev_err(isp->dev, "  frame sync error");
 474        if (infos & IA_CSS_RX_IRQ_INFO_ERR_FRAME_DATA)
 475                dev_err(isp->dev, "  frame data error");
 476        if (infos & IA_CSS_RX_IRQ_INFO_ERR_DATA_TIMEOUT)
 477                dev_err(isp->dev, "  data timeout");
 478        if (infos & IA_CSS_RX_IRQ_INFO_ERR_UNKNOWN_ESC)
 479                dev_err(isp->dev, "  unknown escape command entry");
 480        if (infos & IA_CSS_RX_IRQ_INFO_ERR_LINE_SYNC)
 481                dev_err(isp->dev, "  line sync error");
 482}
 483
 484/* Clear irq reg */
 485static void clear_irq_reg(struct atomisp_device *isp)
 486{
 487        struct pci_dev *pdev = to_pci_dev(isp->dev);
 488        u32 msg_ret;
 489
 490        pci_read_config_dword(pdev, PCI_INTERRUPT_CTRL, &msg_ret);
 491        msg_ret |= 1 << INTR_IIR;
 492        pci_write_config_dword(pdev, PCI_INTERRUPT_CTRL, msg_ret);
 493}
 494
 495static struct atomisp_sub_device *
 496__get_asd_from_port(struct atomisp_device *isp, enum mipi_port_id port)
 497{
 498        int i;
 499
 500        /* Check which isp subdev to send eof */
 501        for (i = 0; i < isp->num_of_streams; i++) {
 502                struct atomisp_sub_device *asd = &isp->asd[i];
 503                struct camera_mipi_info *mipi_info;
 504
 505                mipi_info = atomisp_to_sensor_mipi_info(
 506                                isp->inputs[asd->input_curr].camera);
 507
 508                if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED &&
 509                    __get_mipi_port(isp, mipi_info->port) == port) {
 510                        return asd;
 511                }
 512        }
 513
 514        return NULL;
 515}
 516
 517/* interrupt handling function*/
 518irqreturn_t atomisp_isr(int irq, void *dev)
 519{
 520        struct atomisp_device *isp = (struct atomisp_device *)dev;
 521        struct atomisp_sub_device *asd;
 522        struct atomisp_css_event eof_event;
 523        unsigned int irq_infos = 0;
 524        unsigned long flags;
 525        unsigned int i;
 526        int err;
 527
 528        spin_lock_irqsave(&isp->lock, flags);
 529        if (isp->sw_contex.power_state != ATOM_ISP_POWER_UP ||
 530            !isp->css_initialized) {
 531                spin_unlock_irqrestore(&isp->lock, flags);
 532                return IRQ_HANDLED;
 533        }
 534        err = atomisp_css_irq_translate(isp, &irq_infos);
 535        if (err) {
 536                spin_unlock_irqrestore(&isp->lock, flags);
 537                return IRQ_NONE;
 538        }
 539
 540        clear_irq_reg(isp);
 541
 542        if (!atomisp_streaming_count(isp) && !atomisp_is_acc_enabled(isp))
 543                goto out_nowake;
 544
 545        for (i = 0; i < isp->num_of_streams; i++) {
 546                asd = &isp->asd[i];
 547
 548                if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
 549                        continue;
 550                /*
 551                 * Current SOF only support one stream, so the SOF only valid
 552                 * either solely one stream is running
 553                 */
 554                if (irq_infos & IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF) {
 555                        atomic_inc(&asd->sof_count);
 556                        atomisp_sof_event(asd);
 557
 558                        /* If sequence_temp and sequence are the same
 559                         * there where no frames lost so we can increase
 560                         * sequence_temp.
 561                         * If not then processing of frame is still in progress
 562                         * and driver needs to keep old sequence_temp value.
 563                         * NOTE: There is assumption here that ISP will not
 564                         * start processing next frame from sensor before old
 565                         * one is completely done. */
 566                        if (atomic_read(&asd->sequence) == atomic_read(
 567                                &asd->sequence_temp))
 568                                atomic_set(&asd->sequence_temp,
 569                                           atomic_read(&asd->sof_count));
 570                }
 571                if (irq_infos & IA_CSS_IRQ_INFO_EVENTS_READY)
 572                        atomic_set(&asd->sequence,
 573                                   atomic_read(&asd->sequence_temp));
 574        }
 575
 576        if (irq_infos & IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF) {
 577                dev_dbg_ratelimited(isp->dev,
 578                                    "irq:0x%x (SOF)\n",
 579                                    irq_infos);
 580                irq_infos &= ~IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF;
 581        }
 582
 583        if ((irq_infos & IA_CSS_IRQ_INFO_INPUT_SYSTEM_ERROR) ||
 584            (irq_infos & IA_CSS_IRQ_INFO_IF_ERROR)) {
 585                /* handle mipi receiver error */
 586                u32 rx_infos;
 587                enum mipi_port_id port;
 588
 589                for (port = MIPI_PORT0_ID; port <= MIPI_PORT2_ID;
 590                     port++) {
 591                        print_csi_rx_errors(port, isp);
 592                        atomisp_css_rx_get_irq_info(port, &rx_infos);
 593                        atomisp_css_rx_clear_irq_info(port, rx_infos);
 594                }
 595        }
 596
 597        if (irq_infos & IA_CSS_IRQ_INFO_ISYS_EVENTS_READY) {
 598                while (ia_css_dequeue_isys_event(&eof_event.event) ==
 599                       0) {
 600                        /* EOF Event does not have the css_pipe returned */
 601                        asd = __get_asd_from_port(isp, eof_event.event.port);
 602                        if (!asd) {
 603                                dev_err(isp->dev, "%s: ISYS event, but no subdev.event:%d",
 604                                        __func__, eof_event.event.type);
 605                                continue;
 606                        }
 607
 608                        atomisp_eof_event(asd, eof_event.event.exp_id);
 609                        dev_dbg_ratelimited(isp->dev,
 610                                            "%s ISYS event: EOF exp_id %d, asd %d\n",
 611                                            __func__, eof_event.event.exp_id,
 612                                            asd->index);
 613                }
 614
 615                irq_infos &= ~IA_CSS_IRQ_INFO_ISYS_EVENTS_READY;
 616                if (irq_infos == 0)
 617                        goto out_nowake;
 618        }
 619
 620        spin_unlock_irqrestore(&isp->lock, flags);
 621
 622        dev_dbg_ratelimited(isp->dev, "irq:0x%x (unhandled)\n", irq_infos);
 623
 624        return IRQ_WAKE_THREAD;
 625
 626out_nowake:
 627        spin_unlock_irqrestore(&isp->lock, flags);
 628
 629        if (irq_infos)
 630                dev_dbg_ratelimited(isp->dev, "irq:0x%x (ignored, as not streaming anymore)\n",
 631                                    irq_infos);
 632
 633        return IRQ_HANDLED;
 634}
 635
 636void atomisp_clear_css_buffer_counters(struct atomisp_sub_device *asd)
 637{
 638        int i;
 639
 640        memset(asd->s3a_bufs_in_css, 0, sizeof(asd->s3a_bufs_in_css));
 641        for (i = 0; i < ATOMISP_INPUT_STREAM_NUM; i++)
 642                memset(asd->metadata_bufs_in_css[i], 0,
 643                       sizeof(asd->metadata_bufs_in_css[i]));
 644        asd->dis_bufs_in_css = 0;
 645        asd->video_out_capture.buffers_in_css = 0;
 646        asd->video_out_vf.buffers_in_css = 0;
 647        asd->video_out_preview.buffers_in_css = 0;
 648        asd->video_out_video_capture.buffers_in_css = 0;
 649}
 650
 651/* ISP2400 */
 652bool atomisp_buffers_queued(struct atomisp_sub_device *asd)
 653{
 654        return asd->video_out_capture.buffers_in_css ||
 655               asd->video_out_vf.buffers_in_css ||
 656               asd->video_out_preview.buffers_in_css ||
 657               asd->video_out_video_capture.buffers_in_css;
 658}
 659
 660/* ISP2401 */
 661bool atomisp_buffers_queued_pipe(struct atomisp_video_pipe *pipe)
 662{
 663        return pipe->buffers_in_css ? true : false;
 664}
 665
 666/* 0x100000 is the start of dmem inside SP */
 667#define SP_DMEM_BASE    0x100000
 668
 669void dump_sp_dmem(struct atomisp_device *isp, unsigned int addr,
 670                  unsigned int size)
 671{
 672        unsigned int data = 0;
 673        unsigned int size32 = DIV_ROUND_UP(size, sizeof(u32));
 674
 675        dev_dbg(isp->dev, "atomisp mmio base: %p\n", isp->base);
 676        dev_dbg(isp->dev, "%s, addr:0x%x, size: %d, size32: %d\n", __func__,
 677                addr, size, size32);
 678        if (size32 * 4 + addr > 0x4000) {
 679                dev_err(isp->dev, "illegal size (%d) or addr (0x%x)\n",
 680                        size32, addr);
 681                return;
 682        }
 683        addr += SP_DMEM_BASE;
 684        addr &= 0x003FFFFF;
 685        do {
 686                data = readl(isp->base + addr);
 687                dev_dbg(isp->dev, "%s, \t [0x%x]:0x%x\n", __func__, addr, data);
 688                addr += sizeof(u32);
 689        } while (--size32);
 690}
 691
 692static struct videobuf_buffer *atomisp_css_frame_to_vbuf(
 693    struct atomisp_video_pipe *pipe, struct ia_css_frame *frame)
 694{
 695        struct videobuf_vmalloc_memory *vm_mem;
 696        struct ia_css_frame *handle;
 697        int i;
 698
 699        for (i = 0; pipe->capq.bufs[i]; i++) {
 700                vm_mem = pipe->capq.bufs[i]->priv;
 701                handle = vm_mem->vaddr;
 702                if (handle && handle->data == frame->data)
 703                        return pipe->capq.bufs[i];
 704        }
 705
 706        return NULL;
 707}
 708
 709static void atomisp_flush_video_pipe(struct atomisp_sub_device *asd,
 710                                     struct atomisp_video_pipe *pipe)
 711{
 712        unsigned long irqflags;
 713        int i;
 714
 715        if (!pipe->users)
 716                return;
 717
 718        for (i = 0; pipe->capq.bufs[i]; i++) {
 719                spin_lock_irqsave(&pipe->irq_lock, irqflags);
 720                if (pipe->capq.bufs[i]->state == VIDEOBUF_ACTIVE ||
 721                    pipe->capq.bufs[i]->state == VIDEOBUF_QUEUED) {
 722                        pipe->capq.bufs[i]->ts = ktime_get_ns();
 723                        pipe->capq.bufs[i]->field_count =
 724                            atomic_read(&asd->sequence) << 1;
 725                        dev_dbg(asd->isp->dev, "release buffers on device %s\n",
 726                                pipe->vdev.name);
 727                        if (pipe->capq.bufs[i]->state == VIDEOBUF_QUEUED)
 728                                list_del_init(&pipe->capq.bufs[i]->queue);
 729                        pipe->capq.bufs[i]->state = VIDEOBUF_ERROR;
 730                        wake_up(&pipe->capq.bufs[i]->done);
 731                }
 732                spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
 733        }
 734}
 735
 736/* Returns queued buffers back to video-core */
 737void atomisp_flush_bufs_and_wakeup(struct atomisp_sub_device *asd)
 738{
 739        atomisp_flush_video_pipe(asd, &asd->video_out_capture);
 740        atomisp_flush_video_pipe(asd, &asd->video_out_vf);
 741        atomisp_flush_video_pipe(asd, &asd->video_out_preview);
 742        atomisp_flush_video_pipe(asd, &asd->video_out_video_capture);
 743}
 744
 745/* clean out the parameters that did not apply */
 746void atomisp_flush_params_queue(struct atomisp_video_pipe *pipe)
 747{
 748        struct atomisp_css_params_with_list *param;
 749
 750        while (!list_empty(&pipe->per_frame_params)) {
 751                param = list_entry(pipe->per_frame_params.next,
 752                                   struct atomisp_css_params_with_list, list);
 753                list_del(&param->list);
 754                atomisp_free_css_parameters(&param->params);
 755                kvfree(param);
 756        }
 757}
 758
 759/* Re-queue per-frame parameters */
 760static void atomisp_recover_params_queue(struct atomisp_video_pipe *pipe)
 761{
 762        struct atomisp_css_params_with_list *param;
 763        int i;
 764
 765        for (i = 0; i < VIDEO_MAX_FRAME; i++) {
 766                param = pipe->frame_params[i];
 767                if (param)
 768                        list_add_tail(&param->list, &pipe->per_frame_params);
 769                pipe->frame_params[i] = NULL;
 770        }
 771        atomisp_handle_parameter_and_buffer(pipe);
 772}
 773
 774/* find atomisp_video_pipe with css pipe id, buffer type and atomisp run_mode */
 775static struct atomisp_video_pipe *__atomisp_get_pipe(
 776    struct atomisp_sub_device *asd,
 777    enum atomisp_input_stream_id stream_id,
 778    enum ia_css_pipe_id css_pipe_id,
 779    enum ia_css_buffer_type buf_type)
 780{
 781        struct atomisp_device *isp = asd->isp;
 782
 783        if (css_pipe_id == IA_CSS_PIPE_ID_COPY &&
 784            isp->inputs[asd->input_curr].camera_caps->
 785            sensor[asd->sensor_curr].stream_num > 1) {
 786                switch (stream_id) {
 787                case ATOMISP_INPUT_STREAM_PREVIEW:
 788                        return &asd->video_out_preview;
 789                case ATOMISP_INPUT_STREAM_POSTVIEW:
 790                        return &asd->video_out_vf;
 791                case ATOMISP_INPUT_STREAM_VIDEO:
 792                        return &asd->video_out_video_capture;
 793                case ATOMISP_INPUT_STREAM_CAPTURE:
 794                default:
 795                        return &asd->video_out_capture;
 796                }
 797        }
 798
 799        /* video is same in online as in continuouscapture mode */
 800        if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_LOWLAT) {
 801                /*
 802                 * Disable vf_pp and run CSS in still capture mode. In this
 803                 * mode, CSS does not cause extra latency with buffering, but
 804                 * scaling is not available.
 805                 */
 806                return &asd->video_out_capture;
 807        } else if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_SCALER) {
 808                /*
 809                 * Disable vf_pp and run CSS in video mode. This allows using
 810                 * ISP scaling but it has one frame delay due to CSS internal
 811                 * buffering.
 812                 */
 813                return &asd->video_out_video_capture;
 814        } else if (css_pipe_id == IA_CSS_PIPE_ID_YUVPP) {
 815                /*
 816                 * to SOC camera, yuvpp pipe is run for capture/video/SDV/ZSL.
 817                 */
 818                if (asd->continuous_mode->val) {
 819                        if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) {
 820                                /* SDV case */
 821                                switch (buf_type) {
 822                                case IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME:
 823                                        return &asd->video_out_video_capture;
 824                                case IA_CSS_BUFFER_TYPE_SEC_VF_OUTPUT_FRAME:
 825                                        return &asd->video_out_preview;
 826                                case IA_CSS_BUFFER_TYPE_OUTPUT_FRAME:
 827                                        return &asd->video_out_capture;
 828                                default:
 829                                        return &asd->video_out_vf;
 830                                }
 831                        } else if (asd->run_mode->val == ATOMISP_RUN_MODE_PREVIEW) {
 832                                /* ZSL case */
 833                                switch (buf_type) {
 834                                case IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME:
 835                                        return &asd->video_out_preview;
 836                                case IA_CSS_BUFFER_TYPE_OUTPUT_FRAME:
 837                                        return &asd->video_out_capture;
 838                                default:
 839                                        return &asd->video_out_vf;
 840                                }
 841                        }
 842                } else if (buf_type == IA_CSS_BUFFER_TYPE_OUTPUT_FRAME) {
 843                        switch (asd->run_mode->val) {
 844                        case ATOMISP_RUN_MODE_VIDEO:
 845                                return &asd->video_out_video_capture;
 846                        case ATOMISP_RUN_MODE_PREVIEW:
 847                                return &asd->video_out_preview;
 848                        default:
 849                                return &asd->video_out_capture;
 850                        }
 851                } else if (buf_type == IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME) {
 852                        if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)
 853                                return &asd->video_out_preview;
 854                        else
 855                                return &asd->video_out_vf;
 856                }
 857        } else if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) {
 858                /* For online video or SDV video pipe. */
 859                if (css_pipe_id == IA_CSS_PIPE_ID_VIDEO ||
 860                    css_pipe_id == IA_CSS_PIPE_ID_COPY) {
 861                        if (buf_type == IA_CSS_BUFFER_TYPE_OUTPUT_FRAME)
 862                                return &asd->video_out_video_capture;
 863                        return &asd->video_out_preview;
 864                }
 865        } else if (asd->run_mode->val == ATOMISP_RUN_MODE_PREVIEW) {
 866                /* For online preview or ZSL preview pipe. */
 867                if (css_pipe_id == IA_CSS_PIPE_ID_PREVIEW ||
 868                    css_pipe_id == IA_CSS_PIPE_ID_COPY)
 869                        return &asd->video_out_preview;
 870        }
 871        /* For capture pipe. */
 872        if (buf_type == IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME)
 873                return &asd->video_out_vf;
 874        return &asd->video_out_capture;
 875}
 876
 877enum atomisp_metadata_type
 878atomisp_get_metadata_type(struct atomisp_sub_device *asd,
 879                          enum ia_css_pipe_id pipe_id)
 880{
 881        if (!asd->continuous_mode->val)
 882                return ATOMISP_MAIN_METADATA;
 883
 884        if (pipe_id == IA_CSS_PIPE_ID_CAPTURE) /* online capture pipe */
 885                return ATOMISP_SEC_METADATA;
 886        else
 887                return ATOMISP_MAIN_METADATA;
 888}
 889
 890void atomisp_buf_done(struct atomisp_sub_device *asd, int error,
 891                      enum ia_css_buffer_type buf_type,
 892                      enum ia_css_pipe_id css_pipe_id,
 893                      bool q_buffers, enum atomisp_input_stream_id stream_id)
 894{
 895        struct videobuf_buffer *vb = NULL;
 896        struct atomisp_video_pipe *pipe = NULL;
 897        struct atomisp_css_buffer buffer;
 898        bool requeue = false;
 899        int err;
 900        unsigned long irqflags;
 901        struct ia_css_frame *frame = NULL;
 902        struct atomisp_s3a_buf *s3a_buf = NULL, *_s3a_buf_tmp;
 903        struct atomisp_dis_buf *dis_buf = NULL, *_dis_buf_tmp;
 904        struct atomisp_metadata_buf *md_buf = NULL, *_md_buf_tmp;
 905        enum atomisp_metadata_type md_type;
 906        struct atomisp_device *isp = asd->isp;
 907        struct v4l2_control ctrl;
 908        bool reset_wdt_timer = false;
 909
 910        if (
 911            buf_type != IA_CSS_BUFFER_TYPE_METADATA &&
 912            buf_type != IA_CSS_BUFFER_TYPE_3A_STATISTICS &&
 913            buf_type != IA_CSS_BUFFER_TYPE_DIS_STATISTICS &&
 914            buf_type != IA_CSS_BUFFER_TYPE_OUTPUT_FRAME &&
 915            buf_type != IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME &&
 916            buf_type != IA_CSS_BUFFER_TYPE_RAW_OUTPUT_FRAME &&
 917            buf_type != IA_CSS_BUFFER_TYPE_SEC_VF_OUTPUT_FRAME &&
 918            buf_type != IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME) {
 919                dev_err(isp->dev, "%s, unsupported buffer type: %d\n",
 920                        __func__, buf_type);
 921                return;
 922        }
 923
 924        memset(&buffer, 0, sizeof(struct atomisp_css_buffer));
 925        buffer.css_buffer.type = buf_type;
 926        err = atomisp_css_dequeue_buffer(asd, stream_id, css_pipe_id,
 927                                         buf_type, &buffer);
 928        if (err) {
 929                dev_err(isp->dev,
 930                        "atomisp_css_dequeue_buffer failed: 0x%x\n", err);
 931                return;
 932        }
 933
 934        /* need to know the atomisp pipe for frame buffers */
 935        pipe = __atomisp_get_pipe(asd, stream_id, css_pipe_id, buf_type);
 936        if (!pipe) {
 937                dev_err(isp->dev, "error getting atomisp pipe\n");
 938                return;
 939        }
 940
 941        switch (buf_type) {
 942        case IA_CSS_BUFFER_TYPE_3A_STATISTICS:
 943                list_for_each_entry_safe(s3a_buf, _s3a_buf_tmp,
 944                                         &asd->s3a_stats_in_css, list) {
 945                        if (s3a_buf->s3a_data ==
 946                            buffer.css_buffer.data.stats_3a) {
 947                                list_del_init(&s3a_buf->list);
 948                                list_add_tail(&s3a_buf->list,
 949                                              &asd->s3a_stats_ready);
 950                                break;
 951                        }
 952                }
 953
 954                asd->s3a_bufs_in_css[css_pipe_id]--;
 955                atomisp_3a_stats_ready_event(asd, buffer.css_buffer.exp_id);
 956                dev_dbg(isp->dev, "%s: s3a stat with exp_id %d is ready\n",
 957                        __func__, s3a_buf->s3a_data->exp_id);
 958                break;
 959        case IA_CSS_BUFFER_TYPE_METADATA:
 960                if (error)
 961                        break;
 962
 963                md_type = atomisp_get_metadata_type(asd, css_pipe_id);
 964                list_for_each_entry_safe(md_buf, _md_buf_tmp,
 965                                         &asd->metadata_in_css[md_type], list) {
 966                        if (md_buf->metadata ==
 967                            buffer.css_buffer.data.metadata) {
 968                                list_del_init(&md_buf->list);
 969                                list_add_tail(&md_buf->list,
 970                                              &asd->metadata_ready[md_type]);
 971                                break;
 972                        }
 973                }
 974                asd->metadata_bufs_in_css[stream_id][css_pipe_id]--;
 975                atomisp_metadata_ready_event(asd, md_type);
 976                dev_dbg(isp->dev, "%s: metadata with exp_id %d is ready\n",
 977                        __func__, md_buf->metadata->exp_id);
 978                break;
 979        case IA_CSS_BUFFER_TYPE_DIS_STATISTICS:
 980                list_for_each_entry_safe(dis_buf, _dis_buf_tmp,
 981                                         &asd->dis_stats_in_css, list) {
 982                        if (dis_buf->dis_data ==
 983                            buffer.css_buffer.data.stats_dvs) {
 984                                spin_lock_irqsave(&asd->dis_stats_lock,
 985                                                  irqflags);
 986                                list_del_init(&dis_buf->list);
 987                                list_add(&dis_buf->list, &asd->dis_stats);
 988                                asd->params.dis_proj_data_valid = true;
 989                                spin_unlock_irqrestore(&asd->dis_stats_lock,
 990                                                       irqflags);
 991                                break;
 992                        }
 993                }
 994                asd->dis_bufs_in_css--;
 995                dev_dbg(isp->dev, "%s: dis stat with exp_id %d is ready\n",
 996                        __func__, dis_buf->dis_data->exp_id);
 997                break;
 998        case IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME:
 999        case IA_CSS_BUFFER_TYPE_SEC_VF_OUTPUT_FRAME:
1000                if (IS_ISP2401)
1001                        reset_wdt_timer = true;
1002
1003                pipe->buffers_in_css--;
1004                frame = buffer.css_buffer.data.frame;
1005                if (!frame) {
1006                        WARN_ON(1);
1007                        break;
1008                }
1009                if (!frame->valid)
1010                        error = true;
1011
1012                /* FIXME:
1013                 * YUVPP doesn't set postview exp_id correctlly in SDV mode.
1014                 * This is a WORKAROUND to set exp_id. see HSDES-1503911606.
1015                 */
1016                if (IS_BYT && buf_type == IA_CSS_BUFFER_TYPE_SEC_VF_OUTPUT_FRAME &&
1017                    asd->continuous_mode->val && ATOMISP_USE_YUVPP(asd))
1018                        frame->exp_id = (asd->postview_exp_id++) %
1019                                        (ATOMISP_MAX_EXP_ID + 1);
1020
1021                dev_dbg(isp->dev, "%s: vf frame with exp_id %d is ready\n",
1022                        __func__, frame->exp_id);
1023                if (asd->params.flash_state == ATOMISP_FLASH_ONGOING) {
1024                        if (frame->flash_state
1025                            == IA_CSS_FRAME_FLASH_STATE_PARTIAL)
1026                                dev_dbg(isp->dev, "%s thumb partially flashed\n",
1027                                        __func__);
1028                        else if (frame->flash_state
1029                                 == IA_CSS_FRAME_FLASH_STATE_FULL)
1030                                dev_dbg(isp->dev, "%s thumb completely flashed\n",
1031                                        __func__);
1032                        else
1033                                dev_dbg(isp->dev, "%s thumb no flash in this frame\n",
1034                                        __func__);
1035                }
1036                vb = atomisp_css_frame_to_vbuf(pipe, frame);
1037                WARN_ON(!vb);
1038                if (vb)
1039                        pipe->frame_config_id[vb->i] = frame->isp_config_id;
1040                if (css_pipe_id == IA_CSS_PIPE_ID_CAPTURE &&
1041                    asd->pending_capture_request > 0) {
1042                        err = atomisp_css_offline_capture_configure(asd,
1043                                asd->params.offline_parm.num_captures,
1044                                asd->params.offline_parm.skip_frames,
1045                                asd->params.offline_parm.offset);
1046
1047                        asd->pending_capture_request--;
1048
1049                        if (IS_ISP2401)
1050                                asd->re_trigger_capture = false;
1051
1052                        dev_dbg(isp->dev, "Trigger capture again for new buffer. err=%d\n",
1053                                err);
1054                } else if (IS_ISP2401) {
1055                        asd->re_trigger_capture = true;
1056                }
1057                break;
1058        case IA_CSS_BUFFER_TYPE_OUTPUT_FRAME:
1059        case IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME:
1060                if (IS_ISP2401)
1061                        reset_wdt_timer = true;
1062
1063                pipe->buffers_in_css--;
1064                frame = buffer.css_buffer.data.frame;
1065                if (!frame) {
1066                        WARN_ON(1);
1067                        break;
1068                }
1069
1070                if (!frame->valid)
1071                        error = true;
1072
1073                /* FIXME:
1074                 * YUVPP doesn't set preview exp_id correctlly in ZSL mode.
1075                 * This is a WORKAROUND to set exp_id. see HSDES-1503911606.
1076                 */
1077                if (IS_BYT && buf_type == IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME &&
1078                    asd->continuous_mode->val && ATOMISP_USE_YUVPP(asd))
1079                        frame->exp_id = (asd->preview_exp_id++) %
1080                                        (ATOMISP_MAX_EXP_ID + 1);
1081
1082                dev_dbg(isp->dev, "%s: main frame with exp_id %d is ready\n",
1083                        __func__, frame->exp_id);
1084                vb = atomisp_css_frame_to_vbuf(pipe, frame);
1085                if (!vb) {
1086                        WARN_ON(1);
1087                        break;
1088                }
1089
1090                /* free the parameters */
1091                if (pipe->frame_params[vb->i]) {
1092                        if (asd->params.dvs_6axis ==
1093                            pipe->frame_params[vb->i]->params.dvs_6axis)
1094                                asd->params.dvs_6axis = NULL;
1095                        atomisp_free_css_parameters(
1096                            &pipe->frame_params[vb->i]->params);
1097                        kvfree(pipe->frame_params[vb->i]);
1098                        pipe->frame_params[vb->i] = NULL;
1099                }
1100
1101                pipe->frame_config_id[vb->i] = frame->isp_config_id;
1102                ctrl.id = V4L2_CID_FLASH_MODE;
1103                if (asd->params.flash_state == ATOMISP_FLASH_ONGOING) {
1104                        if (frame->flash_state
1105                            == IA_CSS_FRAME_FLASH_STATE_PARTIAL) {
1106                                asd->frame_status[vb->i] =
1107                                    ATOMISP_FRAME_STATUS_FLASH_PARTIAL;
1108                                dev_dbg(isp->dev, "%s partially flashed\n",
1109                                        __func__);
1110                        } else if (frame->flash_state
1111                                   == IA_CSS_FRAME_FLASH_STATE_FULL) {
1112                                asd->frame_status[vb->i] =
1113                                    ATOMISP_FRAME_STATUS_FLASH_EXPOSED;
1114                                asd->params.num_flash_frames--;
1115                                dev_dbg(isp->dev, "%s completely flashed\n",
1116                                        __func__);
1117                        } else {
1118                                asd->frame_status[vb->i] =
1119                                    ATOMISP_FRAME_STATUS_OK;
1120                                dev_dbg(isp->dev,
1121                                        "%s no flash in this frame\n",
1122                                        __func__);
1123                        }
1124
1125                        /* Check if flashing sequence is done */
1126                        if (asd->frame_status[vb->i] ==
1127                            ATOMISP_FRAME_STATUS_FLASH_EXPOSED)
1128                                asd->params.flash_state = ATOMISP_FLASH_DONE;
1129                } else if (isp->flash) {
1130                        if (v4l2_g_ctrl(isp->flash->ctrl_handler, &ctrl) ==
1131                            0 && ctrl.value == ATOMISP_FLASH_MODE_TORCH) {
1132                                ctrl.id = V4L2_CID_FLASH_TORCH_INTENSITY;
1133                                if (v4l2_g_ctrl(isp->flash->ctrl_handler, &ctrl)
1134                                    == 0 && ctrl.value > 0) {
1135                                        asd->frame_status[vb->i] =
1136                                            ATOMISP_FRAME_STATUS_FLASH_EXPOSED;
1137                                } else {
1138                                        asd->frame_status[vb->i] =
1139                                            ATOMISP_FRAME_STATUS_OK;
1140                                }
1141                        } else {
1142                                asd->frame_status[vb->i] =
1143                                    ATOMISP_FRAME_STATUS_OK;
1144                        }
1145                } else {
1146                        asd->frame_status[vb->i] = ATOMISP_FRAME_STATUS_OK;
1147                }
1148
1149                asd->params.last_frame_status = asd->frame_status[vb->i];
1150
1151                if (asd->continuous_mode->val) {
1152                        if (css_pipe_id == IA_CSS_PIPE_ID_PREVIEW ||
1153                            css_pipe_id == IA_CSS_PIPE_ID_VIDEO) {
1154                                asd->latest_preview_exp_id = frame->exp_id;
1155                        } else if (css_pipe_id ==
1156                                   IA_CSS_PIPE_ID_CAPTURE) {
1157                                if (asd->run_mode->val ==
1158                                    ATOMISP_RUN_MODE_VIDEO)
1159                                        dev_dbg(isp->dev, "SDV capture raw buffer id: %u\n",
1160                                                frame->exp_id);
1161                                else
1162                                        dev_dbg(isp->dev, "ZSL capture raw buffer id: %u\n",
1163                                                frame->exp_id);
1164                        }
1165                }
1166                /*
1167                 * Only after enabled the raw buffer lock
1168                 * and in continuous mode.
1169                 * in preview/video pipe, each buffer will
1170                 * be locked automatically, so record it here.
1171                 */
1172                if (((css_pipe_id == IA_CSS_PIPE_ID_PREVIEW) ||
1173                     (css_pipe_id == IA_CSS_PIPE_ID_VIDEO)) &&
1174                    asd->enable_raw_buffer_lock->val &&
1175                    asd->continuous_mode->val) {
1176                        atomisp_set_raw_buffer_bitmap(asd, frame->exp_id);
1177                        WARN_ON(frame->exp_id > ATOMISP_MAX_EXP_ID);
1178                }
1179
1180                if (asd->params.css_update_params_needed) {
1181                        atomisp_apply_css_parameters(asd,
1182                                                     &asd->params.css_param);
1183                        if (asd->params.css_param.update_flag.dz_config)
1184                                asd->params.config.dz_config = &asd->params.css_param.dz_config;
1185                        /* New global dvs 6axis config should be blocked
1186                         * here if there's a buffer with per-frame parameters
1187                         * pending in CSS frame buffer queue.
1188                         * This is to aviod zooming vibration since global
1189                         * parameters take effect immediately while
1190                         * per-frame parameters are taken after previous
1191                         * buffers in CSS got processed.
1192                         */
1193                        if (asd->params.dvs_6axis)
1194                                atomisp_css_set_dvs_6axis(asd,
1195                                                          asd->params.dvs_6axis);
1196                        else
1197                                asd->params.css_update_params_needed = false;
1198                        /* The update flag should not be cleaned here
1199                         * since it is still going to be used to make up
1200                         * following per-frame parameters.
1201                         * This will introduce more copy work since each
1202                         * time when updating global parameters, the whole
1203                         * parameter set are applied.
1204                         * FIXME: A new set of parameter copy functions can
1205                         * be added to make up per-frame parameters based on
1206                         * solid structures stored in asd->params.css_param
1207                         * instead of using shadow pointers in update flag.
1208                         */
1209                        atomisp_css_update_isp_params(asd);
1210                }
1211                break;
1212        default:
1213                break;
1214        }
1215        if (vb) {
1216                vb->ts = ktime_get_ns();
1217                vb->field_count = atomic_read(&asd->sequence) << 1;
1218                /*mark videobuffer done for dequeue*/
1219                spin_lock_irqsave(&pipe->irq_lock, irqflags);
1220                vb->state = !error ? VIDEOBUF_DONE : VIDEOBUF_ERROR;
1221                spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
1222
1223                /*
1224                 * Frame capture done, wake up any process block on
1225                 * current active buffer
1226                 * possibly hold by videobuf_dqbuf()
1227                 */
1228                wake_up(&vb->done);
1229        }
1230        if (IS_ISP2401)
1231                atomic_set(&pipe->wdt_count, 0);
1232
1233        /*
1234         * Requeue should only be done for 3a and dis buffers.
1235         * Queue/dequeue order will change if driver recycles image buffers.
1236         */
1237        if (requeue) {
1238                err = atomisp_css_queue_buffer(asd,
1239                                               stream_id, css_pipe_id,
1240                                               buf_type, &buffer);
1241                if (err)
1242                        dev_err(isp->dev, "%s, q to css fails: %d\n",
1243                                __func__, err);
1244                return;
1245        }
1246        if (!error && q_buffers)
1247                atomisp_qbuffers_to_css(asd);
1248
1249        if (IS_ISP2401) {
1250                /* If there are no buffers queued then
1251                * delete wdt timer. */
1252                if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
1253                        return;
1254                if (!atomisp_buffers_queued_pipe(pipe))
1255                        atomisp_wdt_stop_pipe(pipe, false);
1256                else if (reset_wdt_timer)
1257                        /* SOF irq should not reset wdt timer. */
1258                        atomisp_wdt_refresh_pipe(pipe,
1259                                                ATOMISP_WDT_KEEP_CURRENT_DELAY);
1260        }
1261}
1262
1263void atomisp_delayed_init_work(struct work_struct *work)
1264{
1265        struct atomisp_sub_device *asd = container_of(work,
1266                                         struct atomisp_sub_device,
1267                                         delayed_init_work);
1268        /*
1269         * to SOC camera, use yuvpp pipe and no support continuous mode.
1270         */
1271        if (!ATOMISP_USE_YUVPP(asd)) {
1272                struct v4l2_event event = {0};
1273                struct ia_css_stream *stream;
1274
1275                stream = asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream;
1276
1277
1278                if (ia_css_alloc_continuous_frame_remain(stream))
1279                        return;
1280
1281                ia_css_update_continuous_frames(stream);
1282
1283                event.type = V4L2_EVENT_ATOMISP_RAW_BUFFERS_ALLOC_DONE;
1284                v4l2_event_queue(asd->subdev.devnode, &event);
1285        }
1286
1287        /* signal streamon after delayed init is done */
1288        asd->delayed_init = ATOMISP_DELAYED_INIT_DONE;
1289        complete(&asd->init_done);
1290}
1291
1292static void __atomisp_css_recover(struct atomisp_device *isp, bool isp_timeout)
1293{
1294        struct pci_dev *pdev = to_pci_dev(isp->dev);
1295        enum ia_css_pipe_id css_pipe_id;
1296        bool stream_restart[MAX_STREAM_NUM] = {0};
1297        bool depth_mode = false;
1298        int i, ret, depth_cnt = 0;
1299
1300        if (!isp->sw_contex.file_input)
1301                atomisp_css_irq_enable(isp,
1302                                       IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF, false);
1303
1304        BUG_ON(isp->num_of_streams > MAX_STREAM_NUM);
1305
1306        for (i = 0; i < isp->num_of_streams; i++) {
1307                struct atomisp_sub_device *asd = &isp->asd[i];
1308                struct ia_css_pipeline *acc_pipeline;
1309                struct ia_css_pipe *acc_pipe = NULL;
1310
1311                if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED &&
1312                    !asd->stream_prepared)
1313                        continue;
1314
1315                /*
1316                * AtomISP::waitStageUpdate is blocked when WDT happens.
1317                * By calling acc_done() for all loaded fw_handles,
1318                * HAL will be unblocked.
1319                */
1320                acc_pipe = asd->stream_env[i].pipes[IA_CSS_PIPE_ID_ACC];
1321                if (acc_pipe) {
1322                        acc_pipeline = ia_css_pipe_get_pipeline(acc_pipe);
1323                        if (acc_pipeline) {
1324                                struct ia_css_pipeline_stage *stage;
1325
1326                                for (stage = acc_pipeline->stages; stage;
1327                                     stage = stage->next) {
1328                                        const struct ia_css_fw_info *fw;
1329
1330                                        fw = stage->firmware;
1331                                        atomisp_acc_done(asd, fw->handle);
1332                                }
1333                        }
1334                }
1335
1336                depth_cnt++;
1337
1338                if (asd->delayed_init == ATOMISP_DELAYED_INIT_QUEUED)
1339                        cancel_work_sync(&asd->delayed_init_work);
1340
1341                complete(&asd->init_done);
1342                asd->delayed_init = ATOMISP_DELAYED_INIT_NOT_QUEUED;
1343
1344                stream_restart[asd->index] = true;
1345
1346                asd->streaming = ATOMISP_DEVICE_STREAMING_STOPPING;
1347
1348                /* stream off sensor */
1349                ret = v4l2_subdev_call(
1350                          isp->inputs[asd->input_curr].
1351                          camera, video, s_stream, 0);
1352                if (ret)
1353                        dev_warn(isp->dev,
1354                                 "can't stop streaming on sensor!\n");
1355
1356                atomisp_acc_unload_extensions(asd);
1357
1358                atomisp_clear_css_buffer_counters(asd);
1359
1360                css_pipe_id = atomisp_get_css_pipe_id(asd);
1361                atomisp_css_stop(asd, css_pipe_id, true);
1362
1363                asd->streaming = ATOMISP_DEVICE_STREAMING_DISABLED;
1364
1365                asd->preview_exp_id = 1;
1366                asd->postview_exp_id = 1;
1367                /* notify HAL the CSS reset */
1368                dev_dbg(isp->dev,
1369                        "send reset event to %s\n", asd->subdev.devnode->name);
1370                atomisp_reset_event(asd);
1371        }
1372
1373        /* clear irq */
1374        disable_isp_irq(hrt_isp_css_irq_sp);
1375        clear_isp_irq(hrt_isp_css_irq_sp);
1376
1377        /* Set the SRSE to 3 before resetting */
1378        pci_write_config_dword(pdev, PCI_I_CONTROL,
1379                               isp->saved_regs.i_control | MRFLD_PCI_I_CONTROL_SRSE_RESET_MASK);
1380
1381        /* reset ISP and restore its state */
1382        isp->isp_timeout = true;
1383        atomisp_reset(isp);
1384        isp->isp_timeout = false;
1385
1386        if (!isp_timeout) {
1387                for (i = 0; i < isp->num_of_streams; i++) {
1388                        if (isp->asd[i].depth_mode->val)
1389                                return;
1390                }
1391        }
1392
1393        for (i = 0; i < isp->num_of_streams; i++) {
1394                struct atomisp_sub_device *asd = &isp->asd[i];
1395
1396                if (!stream_restart[i])
1397                        continue;
1398
1399                if (isp->inputs[asd->input_curr].type != FILE_INPUT)
1400                        atomisp_css_input_set_mode(asd,
1401                                                   IA_CSS_INPUT_MODE_BUFFERED_SENSOR);
1402
1403                css_pipe_id = atomisp_get_css_pipe_id(asd);
1404                if (atomisp_css_start(asd, css_pipe_id, true))
1405                        dev_warn(isp->dev,
1406                                 "start SP failed, so do not set streaming to be enable!\n");
1407                else
1408                        asd->streaming = ATOMISP_DEVICE_STREAMING_ENABLED;
1409
1410                atomisp_csi2_configure(asd);
1411        }
1412
1413        if (!isp->sw_contex.file_input) {
1414                atomisp_css_irq_enable(isp, IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF,
1415                                       atomisp_css_valid_sof(isp));
1416
1417                if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_AUTO, true) < 0)
1418                        dev_dbg(isp->dev, "DFS auto failed while recovering!\n");
1419        } else {
1420                if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_MAX, true) < 0)
1421                        dev_dbg(isp->dev, "DFS max failed while recovering!\n");
1422        }
1423
1424        for (i = 0; i < isp->num_of_streams; i++) {
1425                struct atomisp_sub_device *asd;
1426
1427                asd = &isp->asd[i];
1428
1429                if (!stream_restart[i])
1430                        continue;
1431
1432                if (asd->continuous_mode->val &&
1433                    asd->delayed_init == ATOMISP_DELAYED_INIT_NOT_QUEUED) {
1434                        reinit_completion(&asd->init_done);
1435                        asd->delayed_init = ATOMISP_DELAYED_INIT_QUEUED;
1436                        queue_work(asd->delayed_init_workq,
1437                                   &asd->delayed_init_work);
1438                }
1439                /*
1440                 * dequeueing buffers is not needed. CSS will recycle
1441                 * buffers that it has.
1442                 */
1443                atomisp_flush_bufs_and_wakeup(asd);
1444
1445                /* Requeue unprocessed per-frame parameters. */
1446                atomisp_recover_params_queue(&asd->video_out_capture);
1447                atomisp_recover_params_queue(&asd->video_out_preview);
1448                atomisp_recover_params_queue(&asd->video_out_video_capture);
1449
1450                if ((asd->depth_mode->val) &&
1451                    (depth_cnt == ATOMISP_DEPTH_SENSOR_STREAMON_COUNT)) {
1452                        depth_mode = true;
1453                        continue;
1454                }
1455
1456                ret = v4l2_subdev_call(
1457                          isp->inputs[asd->input_curr].camera, video,
1458                          s_stream, 1);
1459                if (ret)
1460                        dev_warn(isp->dev,
1461                                 "can't start streaming on sensor!\n");
1462        }
1463
1464        if (depth_mode) {
1465                if (atomisp_stream_on_master_slave_sensor(isp, true))
1466                        dev_warn(isp->dev,
1467                                 "master slave sensor stream on failed!\n");
1468        }
1469}
1470
1471void atomisp_wdt_work(struct work_struct *work)
1472{
1473        struct atomisp_device *isp = container_of(work, struct atomisp_device,
1474                                     wdt_work);
1475        int i;
1476        unsigned int pipe_wdt_cnt[MAX_STREAM_NUM][4] = { {0} };
1477        bool css_recover = false;
1478
1479        rt_mutex_lock(&isp->mutex);
1480        if (!atomisp_streaming_count(isp)) {
1481                atomic_set(&isp->wdt_work_queued, 0);
1482                rt_mutex_unlock(&isp->mutex);
1483                return;
1484        }
1485
1486        if (!IS_ISP2401) {
1487                dev_err(isp->dev, "timeout %d of %d\n",
1488                        atomic_read(&isp->wdt_count) + 1,
1489                        ATOMISP_ISP_MAX_TIMEOUT_COUNT);
1490
1491                if (atomic_inc_return(&isp->wdt_count) < ATOMISP_ISP_MAX_TIMEOUT_COUNT)
1492                        css_recover = true;
1493        } else {
1494                css_recover = true;
1495
1496                for (i = 0; i < isp->num_of_streams; i++) {
1497                        struct atomisp_sub_device *asd = &isp->asd[i];
1498
1499                        pipe_wdt_cnt[i][0] +=
1500                            atomic_read(&asd->video_out_capture.wdt_count);
1501                        pipe_wdt_cnt[i][1] +=
1502                            atomic_read(&asd->video_out_vf.wdt_count);
1503                        pipe_wdt_cnt[i][2] +=
1504                            atomic_read(&asd->video_out_preview.wdt_count);
1505                        pipe_wdt_cnt[i][3] +=
1506                            atomic_read(&asd->video_out_video_capture.wdt_count);
1507                        css_recover =
1508                            (pipe_wdt_cnt[i][0] <= ATOMISP_ISP_MAX_TIMEOUT_COUNT &&
1509                            pipe_wdt_cnt[i][1] <= ATOMISP_ISP_MAX_TIMEOUT_COUNT &&
1510                            pipe_wdt_cnt[i][2] <= ATOMISP_ISP_MAX_TIMEOUT_COUNT &&
1511                            pipe_wdt_cnt[i][3] <= ATOMISP_ISP_MAX_TIMEOUT_COUNT)
1512                            ? true : false;
1513                        dev_err(isp->dev,
1514                                "pipe on asd%d timeout cnt: (%d, %d, %d, %d) of %d, recover = %d\n",
1515                                asd->index, pipe_wdt_cnt[i][0], pipe_wdt_cnt[i][1],
1516                                pipe_wdt_cnt[i][2], pipe_wdt_cnt[i][3],
1517                                ATOMISP_ISP_MAX_TIMEOUT_COUNT, css_recover);
1518                }
1519        }
1520
1521        if (css_recover) {
1522                ia_css_debug_dump_sp_sw_debug_info();
1523                ia_css_debug_dump_debug_info(__func__);
1524                for (i = 0; i < isp->num_of_streams; i++) {
1525                        struct atomisp_sub_device *asd = &isp->asd[i];
1526
1527                        if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
1528                                continue;
1529                        dev_err(isp->dev, "%s, vdev %s buffers in css: %d\n",
1530                                __func__,
1531                                asd->video_out_capture.vdev.name,
1532                                asd->video_out_capture.
1533                                buffers_in_css);
1534                        dev_err(isp->dev,
1535                                "%s, vdev %s buffers in css: %d\n",
1536                                __func__,
1537                                asd->video_out_vf.vdev.name,
1538                                asd->video_out_vf.
1539                                buffers_in_css);
1540                        dev_err(isp->dev,
1541                                "%s, vdev %s buffers in css: %d\n",
1542                                __func__,
1543                                asd->video_out_preview.vdev.name,
1544                                asd->video_out_preview.
1545                                buffers_in_css);
1546                        dev_err(isp->dev,
1547                                "%s, vdev %s buffers in css: %d\n",
1548                                __func__,
1549                                asd->video_out_video_capture.vdev.name,
1550                                asd->video_out_video_capture.
1551                                buffers_in_css);
1552                        dev_err(isp->dev,
1553                                "%s, s3a buffers in css preview pipe:%d\n",
1554                                __func__,
1555                                asd->s3a_bufs_in_css[IA_CSS_PIPE_ID_PREVIEW]);
1556                        dev_err(isp->dev,
1557                                "%s, s3a buffers in css capture pipe:%d\n",
1558                                __func__,
1559                                asd->s3a_bufs_in_css[IA_CSS_PIPE_ID_CAPTURE]);
1560                        dev_err(isp->dev,
1561                                "%s, s3a buffers in css video pipe:%d\n",
1562                                __func__,
1563                                asd->s3a_bufs_in_css[IA_CSS_PIPE_ID_VIDEO]);
1564                        dev_err(isp->dev,
1565                                "%s, dis buffers in css: %d\n",
1566                                __func__, asd->dis_bufs_in_css);
1567                        dev_err(isp->dev,
1568                                "%s, metadata buffers in css preview pipe:%d\n",
1569                                __func__,
1570                                asd->metadata_bufs_in_css
1571                                [ATOMISP_INPUT_STREAM_GENERAL]
1572                                [IA_CSS_PIPE_ID_PREVIEW]);
1573                        dev_err(isp->dev,
1574                                "%s, metadata buffers in css capture pipe:%d\n",
1575                                __func__,
1576                                asd->metadata_bufs_in_css
1577                                [ATOMISP_INPUT_STREAM_GENERAL]
1578                                [IA_CSS_PIPE_ID_CAPTURE]);
1579                        dev_err(isp->dev,
1580                                "%s, metadata buffers in css video pipe:%d\n",
1581                                __func__,
1582                                asd->metadata_bufs_in_css
1583                                [ATOMISP_INPUT_STREAM_GENERAL]
1584                                [IA_CSS_PIPE_ID_VIDEO]);
1585                        if (asd->enable_raw_buffer_lock->val) {
1586                                unsigned int j;
1587
1588                                dev_err(isp->dev, "%s, raw_buffer_locked_count %d\n",
1589                                        __func__, asd->raw_buffer_locked_count);
1590                                for (j = 0; j <= ATOMISP_MAX_EXP_ID / 32; j++)
1591                                        dev_err(isp->dev, "%s, raw_buffer_bitmap[%d]: 0x%x\n",
1592                                                __func__, j,
1593                                                asd->raw_buffer_bitmap[j]);
1594                        }
1595                }
1596
1597                /*sh_css_dump_sp_state();*/
1598                /*sh_css_dump_isp_state();*/
1599        } else {
1600                for (i = 0; i < isp->num_of_streams; i++) {
1601                        struct atomisp_sub_device *asd = &isp->asd[i];
1602
1603                        if (asd->streaming ==
1604                            ATOMISP_DEVICE_STREAMING_ENABLED) {
1605                                atomisp_clear_css_buffer_counters(asd);
1606                                atomisp_flush_bufs_and_wakeup(asd);
1607                                complete(&asd->init_done);
1608                        }
1609                        if (IS_ISP2401)
1610                                atomisp_wdt_stop(asd, false);
1611                }
1612
1613                if (!IS_ISP2401) {
1614                        atomic_set(&isp->wdt_count, 0);
1615                } else {
1616                        isp->isp_fatal_error = true;
1617                        atomic_set(&isp->wdt_work_queued, 0);
1618
1619                        rt_mutex_unlock(&isp->mutex);
1620                        return;
1621                }
1622        }
1623
1624        __atomisp_css_recover(isp, true);
1625        if (IS_ISP2401) {
1626                for (i = 0; i < isp->num_of_streams; i++) {
1627                        struct atomisp_sub_device *asd = &isp->asd[i];
1628
1629                        if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
1630                                continue;
1631
1632                        atomisp_wdt_refresh(asd,
1633                                            isp->sw_contex.file_input ?
1634                                            ATOMISP_ISP_FILE_TIMEOUT_DURATION :
1635                                            ATOMISP_ISP_TIMEOUT_DURATION);
1636                }
1637        }
1638
1639        dev_err(isp->dev, "timeout recovery handling done\n");
1640        atomic_set(&isp->wdt_work_queued, 0);
1641
1642        rt_mutex_unlock(&isp->mutex);
1643}
1644
1645void atomisp_css_flush(struct atomisp_device *isp)
1646{
1647        int i;
1648
1649        if (!atomisp_streaming_count(isp))
1650                return;
1651
1652        /* Disable wdt */
1653        for (i = 0; i < isp->num_of_streams; i++) {
1654                struct atomisp_sub_device *asd = &isp->asd[i];
1655
1656                atomisp_wdt_stop(asd, true);
1657        }
1658
1659        /* Start recover */
1660        __atomisp_css_recover(isp, false);
1661        /* Restore wdt */
1662        for (i = 0; i < isp->num_of_streams; i++) {
1663                struct atomisp_sub_device *asd = &isp->asd[i];
1664
1665                if (asd->streaming !=
1666                    ATOMISP_DEVICE_STREAMING_ENABLED)
1667                        continue;
1668
1669                atomisp_wdt_refresh(asd,
1670                                    isp->sw_contex.file_input ?
1671                                    ATOMISP_ISP_FILE_TIMEOUT_DURATION :
1672                                    ATOMISP_ISP_TIMEOUT_DURATION);
1673        }
1674        dev_dbg(isp->dev, "atomisp css flush done\n");
1675}
1676
1677void atomisp_wdt(struct timer_list *t)
1678{
1679        struct atomisp_sub_device *asd;
1680        struct atomisp_device *isp;
1681
1682        if (!IS_ISP2401) {
1683                asd = from_timer(asd, t, wdt);
1684                isp = asd->isp;
1685        } else {
1686                struct atomisp_video_pipe *pipe = from_timer(pipe, t, wdt);
1687
1688                asd = pipe->asd;
1689                isp = asd->isp;
1690
1691                atomic_inc(&pipe->wdt_count);
1692                dev_warn(isp->dev,
1693                        "[WARNING]asd %d pipe %s ISP timeout %d!\n",
1694                        asd->index, pipe->vdev.name,
1695                        atomic_read(&pipe->wdt_count));
1696        }
1697
1698        if (atomic_read(&isp->wdt_work_queued)) {
1699                dev_dbg(isp->dev, "ISP watchdog was put into workqueue\n");
1700                return;
1701        }
1702        atomic_set(&isp->wdt_work_queued, 1);
1703        queue_work(isp->wdt_work_queue, &isp->wdt_work);
1704}
1705
1706/* ISP2400 */
1707void atomisp_wdt_start(struct atomisp_sub_device *asd)
1708{
1709        atomisp_wdt_refresh(asd, ATOMISP_ISP_TIMEOUT_DURATION);
1710}
1711
1712/* ISP2401 */
1713void atomisp_wdt_refresh_pipe(struct atomisp_video_pipe *pipe,
1714                              unsigned int delay)
1715{
1716        unsigned long next;
1717
1718        if (delay != ATOMISP_WDT_KEEP_CURRENT_DELAY)
1719                pipe->wdt_duration = delay;
1720
1721        next = jiffies + pipe->wdt_duration;
1722
1723        /* Override next if it has been pushed beyon the "next" time */
1724        if (atomisp_is_wdt_running(pipe) && time_after(pipe->wdt_expires, next))
1725                next = pipe->wdt_expires;
1726
1727        pipe->wdt_expires = next;
1728
1729        if (atomisp_is_wdt_running(pipe))
1730                dev_dbg(pipe->asd->isp->dev, "WDT will hit after %d ms (%s)\n",
1731                        ((int)(next - jiffies) * 1000 / HZ), pipe->vdev.name);
1732        else
1733                dev_dbg(pipe->asd->isp->dev, "WDT starts with %d ms period (%s)\n",
1734                        ((int)(next - jiffies) * 1000 / HZ), pipe->vdev.name);
1735
1736        mod_timer(&pipe->wdt, next);
1737}
1738
1739void atomisp_wdt_refresh(struct atomisp_sub_device *asd, unsigned int delay)
1740{
1741        if (!IS_ISP2401) {
1742                unsigned long next;
1743
1744                if (delay != ATOMISP_WDT_KEEP_CURRENT_DELAY)
1745                        asd->wdt_duration = delay;
1746
1747                next = jiffies + asd->wdt_duration;
1748
1749                /* Override next if it has been pushed beyon the "next" time */
1750                if (atomisp_is_wdt_running(asd) && time_after(asd->wdt_expires, next))
1751                        next = asd->wdt_expires;
1752
1753                asd->wdt_expires = next;
1754
1755                if (atomisp_is_wdt_running(asd))
1756                        dev_dbg(asd->isp->dev, "WDT will hit after %d ms\n",
1757                                ((int)(next - jiffies) * 1000 / HZ));
1758                else
1759                        dev_dbg(asd->isp->dev, "WDT starts with %d ms period\n",
1760                                ((int)(next - jiffies) * 1000 / HZ));
1761
1762                mod_timer(&asd->wdt, next);
1763                atomic_set(&asd->isp->wdt_count, 0);
1764        } else {
1765                dev_dbg(asd->isp->dev, "WDT refresh all:\n");
1766                if (atomisp_is_wdt_running(&asd->video_out_capture))
1767                        atomisp_wdt_refresh_pipe(&asd->video_out_capture, delay);
1768                if (atomisp_is_wdt_running(&asd->video_out_preview))
1769                        atomisp_wdt_refresh_pipe(&asd->video_out_preview, delay);
1770                if (atomisp_is_wdt_running(&asd->video_out_vf))
1771                        atomisp_wdt_refresh_pipe(&asd->video_out_vf, delay);
1772                if (atomisp_is_wdt_running(&asd->video_out_video_capture))
1773                        atomisp_wdt_refresh_pipe(&asd->video_out_video_capture, delay);
1774        }
1775}
1776
1777/* ISP2401 */
1778void atomisp_wdt_stop_pipe(struct atomisp_video_pipe *pipe, bool sync)
1779{
1780        if (!atomisp_is_wdt_running(pipe))
1781                return;
1782
1783        dev_dbg(pipe->asd->isp->dev,
1784                "WDT stop asd %d (%s)\n", pipe->asd->index, pipe->vdev.name);
1785
1786        if (sync) {
1787                del_timer_sync(&pipe->wdt);
1788                cancel_work_sync(&pipe->asd->isp->wdt_work);
1789        } else {
1790                del_timer(&pipe->wdt);
1791        }
1792}
1793
1794/* ISP 2401 */
1795void atomisp_wdt_start_pipe(struct atomisp_video_pipe *pipe)
1796{
1797        atomisp_wdt_refresh_pipe(pipe, ATOMISP_ISP_TIMEOUT_DURATION);
1798}
1799
1800void atomisp_wdt_stop(struct atomisp_sub_device *asd, bool sync)
1801{
1802        dev_dbg(asd->isp->dev, "WDT stop:\n");
1803
1804        if (!IS_ISP2401) {
1805                if (sync) {
1806                        del_timer_sync(&asd->wdt);
1807                        cancel_work_sync(&asd->isp->wdt_work);
1808                } else {
1809                        del_timer(&asd->wdt);
1810                }
1811        } else {
1812                atomisp_wdt_stop_pipe(&asd->video_out_capture, sync);
1813                atomisp_wdt_stop_pipe(&asd->video_out_preview, sync);
1814                atomisp_wdt_stop_pipe(&asd->video_out_vf, sync);
1815                atomisp_wdt_stop_pipe(&asd->video_out_video_capture, sync);
1816        }
1817}
1818
1819void atomisp_setup_flash(struct atomisp_sub_device *asd)
1820{
1821        struct atomisp_device *isp = asd->isp;
1822        struct v4l2_control ctrl;
1823
1824        if (!isp->flash)
1825                return;
1826
1827        if (asd->params.flash_state != ATOMISP_FLASH_REQUESTED &&
1828            asd->params.flash_state != ATOMISP_FLASH_DONE)
1829                return;
1830
1831        if (asd->params.num_flash_frames) {
1832                /* make sure the timeout is set before setting flash mode */
1833                ctrl.id = V4L2_CID_FLASH_TIMEOUT;
1834                ctrl.value = FLASH_TIMEOUT;
1835
1836                if (v4l2_s_ctrl(NULL, isp->flash->ctrl_handler, &ctrl)) {
1837                        dev_err(isp->dev, "flash timeout configure failed\n");
1838                        return;
1839                }
1840
1841                ia_css_stream_request_flash(asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream);
1842
1843                asd->params.flash_state = ATOMISP_FLASH_ONGOING;
1844        } else {
1845                asd->params.flash_state = ATOMISP_FLASH_IDLE;
1846        }
1847}
1848
1849irqreturn_t atomisp_isr_thread(int irq, void *isp_ptr)
1850{
1851        struct atomisp_device *isp = isp_ptr;
1852        unsigned long flags;
1853        bool frame_done_found[MAX_STREAM_NUM] = {0};
1854        bool css_pipe_done[MAX_STREAM_NUM] = {0};
1855        unsigned int i;
1856        struct atomisp_sub_device *asd;
1857
1858        dev_dbg(isp->dev, ">%s\n", __func__);
1859
1860        spin_lock_irqsave(&isp->lock, flags);
1861
1862        if (!atomisp_streaming_count(isp) && !atomisp_is_acc_enabled(isp)) {
1863                spin_unlock_irqrestore(&isp->lock, flags);
1864                return IRQ_HANDLED;
1865        }
1866
1867        spin_unlock_irqrestore(&isp->lock, flags);
1868
1869        /*
1870         * The standard CSS2.0 API tells the following calling sequence of
1871         * dequeue ready buffers:
1872         * while (ia_css_dequeue_event(...)) {
1873         *      switch (event.type) {
1874         *      ...
1875         *      ia_css_pipe_dequeue_buffer()
1876         *      }
1877         * }
1878         * That is, dequeue event and buffer are one after another.
1879         *
1880         * But the following implementation is to first deuque all the event
1881         * to a FIFO, then process the event in the FIFO.
1882         * This will not have issue in single stream mode, but it do have some
1883         * issue in multiple stream case. The issue is that
1884         * ia_css_pipe_dequeue_buffer() will not return the corrent buffer in
1885         * a specific pipe.
1886         *
1887         * This is due to ia_css_pipe_dequeue_buffer() does not take the
1888         * ia_css_pipe parameter.
1889         *
1890         * So:
1891         * For CSS2.0: we change the way to not dequeue all the event at one
1892         * time, instead, dequue one and process one, then another
1893         */
1894        rt_mutex_lock(&isp->mutex);
1895        if (atomisp_css_isr_thread(isp, frame_done_found, css_pipe_done))
1896                goto out;
1897
1898        for (i = 0; i < isp->num_of_streams; i++) {
1899                asd = &isp->asd[i];
1900                if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
1901                        continue;
1902                atomisp_setup_flash(asd);
1903        }
1904out:
1905        rt_mutex_unlock(&isp->mutex);
1906        for (i = 0; i < isp->num_of_streams; i++) {
1907                asd = &isp->asd[i];
1908                if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED
1909                    && css_pipe_done[asd->index]
1910                    && isp->sw_contex.file_input)
1911                        v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1912                                         video, s_stream, 1);
1913                /* FIXME! FIX ACC implementation */
1914                if (asd->acc.pipeline && css_pipe_done[asd->index])
1915                        atomisp_css_acc_done(asd);
1916        }
1917        dev_dbg(isp->dev, "<%s\n", __func__);
1918
1919        return IRQ_HANDLED;
1920}
1921
1922/*
1923 * utils for buffer allocation/free
1924 */
1925
1926int atomisp_get_frame_pgnr(struct atomisp_device *isp,
1927                           const struct ia_css_frame *frame, u32 *p_pgnr)
1928{
1929        if (!frame) {
1930                dev_err(isp->dev, "%s: NULL frame pointer ERROR.\n", __func__);
1931                return -EINVAL;
1932        }
1933
1934        *p_pgnr = DIV_ROUND_UP(frame->data_bytes, PAGE_SIZE);
1935        return 0;
1936}
1937
1938/*
1939 * Get internal fmt according to V4L2 fmt
1940 */
1941static enum ia_css_frame_format
1942v4l2_fmt_to_sh_fmt(u32 fmt)
1943{
1944        switch (fmt) {
1945        case V4L2_PIX_FMT_YUV420:
1946                                return IA_CSS_FRAME_FORMAT_YUV420;
1947        case V4L2_PIX_FMT_YVU420:
1948                return IA_CSS_FRAME_FORMAT_YV12;
1949        case V4L2_PIX_FMT_YUV422P:
1950                return IA_CSS_FRAME_FORMAT_YUV422;
1951        case V4L2_PIX_FMT_YUV444:
1952                return IA_CSS_FRAME_FORMAT_YUV444;
1953        case V4L2_PIX_FMT_NV12:
1954                return IA_CSS_FRAME_FORMAT_NV12;
1955        case V4L2_PIX_FMT_NV21:
1956                return IA_CSS_FRAME_FORMAT_NV21;
1957        case V4L2_PIX_FMT_NV16:
1958                return IA_CSS_FRAME_FORMAT_NV16;
1959        case V4L2_PIX_FMT_NV61:
1960                return IA_CSS_FRAME_FORMAT_NV61;
1961        case V4L2_PIX_FMT_UYVY:
1962                return IA_CSS_FRAME_FORMAT_UYVY;
1963        case V4L2_PIX_FMT_YUYV:
1964                return IA_CSS_FRAME_FORMAT_YUYV;
1965        case V4L2_PIX_FMT_RGB24:
1966                return IA_CSS_FRAME_FORMAT_PLANAR_RGB888;
1967        case V4L2_PIX_FMT_RGB32:
1968                return IA_CSS_FRAME_FORMAT_RGBA888;
1969        case V4L2_PIX_FMT_RGB565:
1970                return IA_CSS_FRAME_FORMAT_RGB565;
1971        case V4L2_PIX_FMT_JPEG:
1972        case V4L2_PIX_FMT_CUSTOM_M10MO_RAW:
1973                return IA_CSS_FRAME_FORMAT_BINARY_8;
1974        case V4L2_PIX_FMT_SBGGR16:
1975        case V4L2_PIX_FMT_SBGGR10:
1976        case V4L2_PIX_FMT_SGBRG10:
1977        case V4L2_PIX_FMT_SGRBG10:
1978        case V4L2_PIX_FMT_SRGGB10:
1979        case V4L2_PIX_FMT_SBGGR12:
1980        case V4L2_PIX_FMT_SGBRG12:
1981        case V4L2_PIX_FMT_SGRBG12:
1982        case V4L2_PIX_FMT_SRGGB12:
1983        case V4L2_PIX_FMT_SBGGR8:
1984        case V4L2_PIX_FMT_SGBRG8:
1985        case V4L2_PIX_FMT_SGRBG8:
1986        case V4L2_PIX_FMT_SRGGB8:
1987                return IA_CSS_FRAME_FORMAT_RAW;
1988        default:
1989                return -EINVAL;
1990        }
1991}
1992
1993/*
1994 * raw format match between SH format and V4L2 format
1995 */
1996static int raw_output_format_match_input(u32 input, u32 output)
1997{
1998        if ((input == ATOMISP_INPUT_FORMAT_RAW_12) &&
1999            ((output == V4L2_PIX_FMT_SRGGB12) ||
2000             (output == V4L2_PIX_FMT_SGRBG12) ||
2001             (output == V4L2_PIX_FMT_SBGGR12) ||
2002             (output == V4L2_PIX_FMT_SGBRG12)))
2003                return 0;
2004
2005        if ((input == ATOMISP_INPUT_FORMAT_RAW_10) &&
2006            ((output == V4L2_PIX_FMT_SRGGB10) ||
2007             (output == V4L2_PIX_FMT_SGRBG10) ||
2008             (output == V4L2_PIX_FMT_SBGGR10) ||
2009             (output == V4L2_PIX_FMT_SGBRG10)))
2010                return 0;
2011
2012        if ((input == ATOMISP_INPUT_FORMAT_RAW_8) &&
2013            ((output == V4L2_PIX_FMT_SRGGB8) ||
2014             (output == V4L2_PIX_FMT_SGRBG8) ||
2015             (output == V4L2_PIX_FMT_SBGGR8) ||
2016             (output == V4L2_PIX_FMT_SGBRG8)))
2017                return 0;
2018
2019        if ((input == ATOMISP_INPUT_FORMAT_RAW_16) && (output == V4L2_PIX_FMT_SBGGR16))
2020                return 0;
2021
2022        return -EINVAL;
2023}
2024
2025static u32 get_pixel_depth(u32 pixelformat)
2026{
2027        switch (pixelformat) {
2028        case V4L2_PIX_FMT_YUV420:
2029        case V4L2_PIX_FMT_NV12:
2030        case V4L2_PIX_FMT_NV21:
2031        case V4L2_PIX_FMT_YVU420:
2032                return 12;
2033        case V4L2_PIX_FMT_YUV422P:
2034        case V4L2_PIX_FMT_YUYV:
2035        case V4L2_PIX_FMT_UYVY:
2036        case V4L2_PIX_FMT_NV16:
2037        case V4L2_PIX_FMT_NV61:
2038        case V4L2_PIX_FMT_RGB565:
2039        case V4L2_PIX_FMT_SBGGR16:
2040        case V4L2_PIX_FMT_SBGGR12:
2041        case V4L2_PIX_FMT_SGBRG12:
2042        case V4L2_PIX_FMT_SGRBG12:
2043        case V4L2_PIX_FMT_SRGGB12:
2044        case V4L2_PIX_FMT_SBGGR10:
2045        case V4L2_PIX_FMT_SGBRG10:
2046        case V4L2_PIX_FMT_SGRBG10:
2047        case V4L2_PIX_FMT_SRGGB10:
2048                return 16;
2049        case V4L2_PIX_FMT_RGB24:
2050        case V4L2_PIX_FMT_YUV444:
2051                return 24;
2052        case V4L2_PIX_FMT_RGB32:
2053                return 32;
2054        case V4L2_PIX_FMT_JPEG:
2055        case V4L2_PIX_FMT_CUSTOM_M10MO_RAW:
2056        case V4L2_PIX_FMT_SBGGR8:
2057        case V4L2_PIX_FMT_SGBRG8:
2058        case V4L2_PIX_FMT_SGRBG8:
2059        case V4L2_PIX_FMT_SRGGB8:
2060                return 8;
2061        default:
2062                return 8 * 2;   /* raw type now */
2063        }
2064}
2065
2066bool atomisp_is_mbuscode_raw(uint32_t code)
2067{
2068        return code >= 0x3000 && code < 0x4000;
2069}
2070
2071/*
2072 * ISP features control function
2073 */
2074
2075/*
2076 * Set ISP capture mode based on current settings
2077 */
2078static void atomisp_update_capture_mode(struct atomisp_sub_device *asd)
2079{
2080        if (asd->params.gdc_cac_en)
2081                atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_ADVANCED);
2082        else if (asd->params.low_light)
2083                atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_LOW_LIGHT);
2084        else if (asd->video_out_capture.sh_fmt == IA_CSS_FRAME_FORMAT_RAW)
2085                atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_RAW);
2086        else
2087                atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_PRIMARY);
2088}
2089
2090/* ISP2401 */
2091int atomisp_set_sensor_runmode(struct atomisp_sub_device *asd,
2092                               struct atomisp_s_runmode *runmode)
2093{
2094        struct atomisp_device *isp = asd->isp;
2095        struct v4l2_ctrl *c;
2096        int ret = 0;
2097
2098        if (!(runmode && (runmode->mode & RUNMODE_MASK)))
2099                return -EINVAL;
2100
2101        mutex_lock(asd->ctrl_handler.lock);
2102        c = v4l2_ctrl_find(isp->inputs[asd->input_curr].camera->ctrl_handler,
2103                           V4L2_CID_RUN_MODE);
2104
2105        if (c)
2106                ret = v4l2_ctrl_s_ctrl(c, runmode->mode);
2107
2108        mutex_unlock(asd->ctrl_handler.lock);
2109        return ret;
2110}
2111
2112/*
2113 * Function to enable/disable lens geometry distortion correction (GDC) and
2114 * chromatic aberration correction (CAC)
2115 */
2116int atomisp_gdc_cac(struct atomisp_sub_device *asd, int flag,
2117                    __s32 *value)
2118{
2119        if (flag == 0) {
2120                *value = asd->params.gdc_cac_en;
2121                return 0;
2122        }
2123
2124        asd->params.gdc_cac_en = !!*value;
2125        if (asd->params.gdc_cac_en) {
2126                asd->params.config.morph_table = asd->params.css_param.morph_table;
2127        } else {
2128                asd->params.config.morph_table = NULL;
2129        }
2130        asd->params.css_update_params_needed = true;
2131        atomisp_update_capture_mode(asd);
2132        return 0;
2133}
2134
2135/*
2136 * Function to enable/disable low light mode including ANR
2137 */
2138int atomisp_low_light(struct atomisp_sub_device *asd, int flag,
2139                      __s32 *value)
2140{
2141        if (flag == 0) {
2142                *value = asd->params.low_light;
2143                return 0;
2144        }
2145
2146        asd->params.low_light = (*value != 0);
2147        atomisp_update_capture_mode(asd);
2148        return 0;
2149}
2150
2151/*
2152 * Function to enable/disable extra noise reduction (XNR) in low light
2153 * condition
2154 */
2155int atomisp_xnr(struct atomisp_sub_device *asd, int flag,
2156                int *xnr_enable)
2157{
2158        if (flag == 0) {
2159                *xnr_enable = asd->params.xnr_en;
2160                return 0;
2161        }
2162
2163        atomisp_css_capture_enable_xnr(asd, !!*xnr_enable);
2164
2165        return 0;
2166}
2167
2168/*
2169 * Function to configure bayer noise reduction
2170 */
2171int atomisp_nr(struct atomisp_sub_device *asd, int flag,
2172               struct atomisp_nr_config *arg)
2173{
2174        if (flag == 0) {
2175                /* Get nr config from current setup */
2176                if (atomisp_css_get_nr_config(asd, arg))
2177                        return -EINVAL;
2178        } else {
2179                /* Set nr config to isp parameters */
2180                memcpy(&asd->params.css_param.nr_config, arg,
2181                       sizeof(struct ia_css_nr_config));
2182                asd->params.config.nr_config = &asd->params.css_param.nr_config;
2183                asd->params.css_update_params_needed = true;
2184        }
2185        return 0;
2186}
2187
2188/*
2189 * Function to configure temporal noise reduction (TNR)
2190 */
2191int atomisp_tnr(struct atomisp_sub_device *asd, int flag,
2192                struct atomisp_tnr_config *config)
2193{
2194        /* Get tnr config from current setup */
2195        if (flag == 0) {
2196                /* Get tnr config from current setup */
2197                if (atomisp_css_get_tnr_config(asd, config))
2198                        return -EINVAL;
2199        } else {
2200                /* Set tnr config to isp parameters */
2201                memcpy(&asd->params.css_param.tnr_config, config,
2202                       sizeof(struct ia_css_tnr_config));
2203                asd->params.config.tnr_config = &asd->params.css_param.tnr_config;
2204                asd->params.css_update_params_needed = true;
2205        }
2206
2207        return 0;
2208}
2209
2210/*
2211 * Function to configure black level compensation
2212 */
2213int atomisp_black_level(struct atomisp_sub_device *asd, int flag,
2214                        struct atomisp_ob_config *config)
2215{
2216        if (flag == 0) {
2217                /* Get ob config from current setup */
2218                if (atomisp_css_get_ob_config(asd, config))
2219                        return -EINVAL;
2220        } else {
2221                /* Set ob config to isp parameters */
2222                memcpy(&asd->params.css_param.ob_config, config,
2223                       sizeof(struct ia_css_ob_config));
2224                asd->params.config.ob_config = &asd->params.css_param.ob_config;
2225                asd->params.css_update_params_needed = true;
2226        }
2227
2228        return 0;
2229}
2230
2231/*
2232 * Function to configure edge enhancement
2233 */
2234int atomisp_ee(struct atomisp_sub_device *asd, int flag,
2235               struct atomisp_ee_config *config)
2236{
2237        if (flag == 0) {
2238                /* Get ee config from current setup */
2239                if (atomisp_css_get_ee_config(asd, config))
2240                        return -EINVAL;
2241        } else {
2242                /* Set ee config to isp parameters */
2243                memcpy(&asd->params.css_param.ee_config, config,
2244                       sizeof(asd->params.css_param.ee_config));
2245                asd->params.config.ee_config = &asd->params.css_param.ee_config;
2246                asd->params.css_update_params_needed = true;
2247        }
2248
2249        return 0;
2250}
2251
2252/*
2253 * Function to update Gamma table for gamma, brightness and contrast config
2254 */
2255int atomisp_gamma(struct atomisp_sub_device *asd, int flag,
2256                  struct atomisp_gamma_table *config)
2257{
2258        if (flag == 0) {
2259                /* Get gamma table from current setup */
2260                if (atomisp_css_get_gamma_table(asd, config))
2261                        return -EINVAL;
2262        } else {
2263                /* Set gamma table to isp parameters */
2264                memcpy(&asd->params.css_param.gamma_table, config,
2265                       sizeof(asd->params.css_param.gamma_table));
2266                asd->params.config.gamma_table = &asd->params.css_param.gamma_table;
2267        }
2268
2269        return 0;
2270}
2271
2272/*
2273 * Function to update Ctc table for Chroma Enhancement
2274 */
2275int atomisp_ctc(struct atomisp_sub_device *asd, int flag,
2276                struct atomisp_ctc_table *config)
2277{
2278        if (flag == 0) {
2279                /* Get ctc table from current setup */
2280                if (atomisp_css_get_ctc_table(asd, config))
2281                        return -EINVAL;
2282        } else {
2283                /* Set ctc table to isp parameters */
2284                memcpy(&asd->params.css_param.ctc_table, config,
2285                       sizeof(asd->params.css_param.ctc_table));
2286                atomisp_css_set_ctc_table(asd, &asd->params.css_param.ctc_table);
2287        }
2288
2289        return 0;
2290}
2291
2292/*
2293 * Function to update gamma correction parameters
2294 */
2295int atomisp_gamma_correction(struct atomisp_sub_device *asd, int flag,
2296                             struct atomisp_gc_config *config)
2297{
2298        if (flag == 0) {
2299                /* Get gamma correction params from current setup */
2300                if (atomisp_css_get_gc_config(asd, config))
2301                        return -EINVAL;
2302        } else {
2303                /* Set gamma correction params to isp parameters */
2304                memcpy(&asd->params.css_param.gc_config, config,
2305                       sizeof(asd->params.css_param.gc_config));
2306                asd->params.config.gc_config = &asd->params.css_param.gc_config;
2307                asd->params.css_update_params_needed = true;
2308        }
2309
2310        return 0;
2311}
2312
2313/*
2314 * Function to update narrow gamma flag
2315 */
2316int atomisp_formats(struct atomisp_sub_device *asd, int flag,
2317                    struct atomisp_formats_config *config)
2318{
2319        if (flag == 0) {
2320                /* Get narrow gamma flag from current setup */
2321                if (atomisp_css_get_formats_config(asd, config))
2322                        return -EINVAL;
2323        } else {
2324                /* Set narrow gamma flag to isp parameters */
2325                memcpy(&asd->params.css_param.formats_config, config,
2326                       sizeof(asd->params.css_param.formats_config));
2327                asd->params.config.formats_config = &asd->params.css_param.formats_config;
2328        }
2329
2330        return 0;
2331}
2332
2333void atomisp_free_internal_buffers(struct atomisp_sub_device *asd)
2334{
2335        atomisp_free_css_parameters(&asd->params.css_param);
2336
2337        if (asd->raw_output_frame) {
2338                ia_css_frame_free(asd->raw_output_frame);
2339                asd->raw_output_frame = NULL;
2340        }
2341}
2342
2343static void atomisp_update_grid_info(struct atomisp_sub_device *asd,
2344                                     enum ia_css_pipe_id pipe_id,
2345                                     int source_pad)
2346{
2347        struct atomisp_device *isp = asd->isp;
2348        int err;
2349        u16 stream_id = atomisp_source_pad_to_stream_id(asd, source_pad);
2350
2351        if (atomisp_css_get_grid_info(asd, pipe_id, source_pad))
2352                return;
2353
2354        /* We must free all buffers because they no longer match
2355           the grid size. */
2356        atomisp_css_free_stat_buffers(asd);
2357
2358        err = atomisp_alloc_css_stat_bufs(asd, stream_id);
2359        if (err) {
2360                dev_err(isp->dev, "stat_buf allocate error\n");
2361                goto err;
2362        }
2363
2364        if (atomisp_alloc_3a_output_buf(asd)) {
2365                /* Failure for 3A buffers does not influence DIS buffers */
2366                if (asd->params.s3a_output_bytes != 0) {
2367                        /* For SOC sensor happens s3a_output_bytes == 0,
2368                         * using if condition to exclude false error log */
2369                        dev_err(isp->dev, "Failed to allocate memory for 3A statistics\n");
2370                }
2371                goto err;
2372        }
2373
2374        if (atomisp_alloc_dis_coef_buf(asd)) {
2375                dev_err(isp->dev,
2376                        "Failed to allocate memory for DIS statistics\n");
2377                goto err;
2378        }
2379
2380        if (atomisp_alloc_metadata_output_buf(asd)) {
2381                dev_err(isp->dev, "Failed to allocate memory for metadata\n");
2382                goto err;
2383        }
2384
2385        return;
2386
2387err:
2388        atomisp_css_free_stat_buffers(asd);
2389        return;
2390}
2391
2392static void atomisp_curr_user_grid_info(struct atomisp_sub_device *asd,
2393                                        struct atomisp_grid_info *info)
2394{
2395        memcpy(info, &asd->params.curr_grid_info.s3a_grid,
2396               sizeof(struct ia_css_3a_grid_info));
2397}
2398
2399int atomisp_compare_grid(struct atomisp_sub_device *asd,
2400                         struct atomisp_grid_info *atomgrid)
2401{
2402        struct atomisp_grid_info tmp = {0};
2403
2404        atomisp_curr_user_grid_info(asd, &tmp);
2405        return memcmp(atomgrid, &tmp, sizeof(tmp));
2406}
2407
2408/*
2409 * Function to update Gdc table for gdc
2410 */
2411int atomisp_gdc_cac_table(struct atomisp_sub_device *asd, int flag,
2412                          struct atomisp_morph_table *config)
2413{
2414        int ret;
2415        int i;
2416        struct atomisp_device *isp = asd->isp;
2417
2418        if (flag == 0) {
2419                /* Get gdc table from current setup */
2420                struct ia_css_morph_table tab = {0};
2421
2422                atomisp_css_get_morph_table(asd, &tab);
2423
2424                config->width = tab.width;
2425                config->height = tab.height;
2426
2427                for (i = 0; i < IA_CSS_MORPH_TABLE_NUM_PLANES; i++) {
2428                        ret = copy_to_user(config->coordinates_x[i],
2429                                           tab.coordinates_x[i], tab.height *
2430                                           tab.width * sizeof(*tab.coordinates_x[i]));
2431                        if (ret) {
2432                                dev_err(isp->dev,
2433                                        "Failed to copy to User for x\n");
2434                                return -EFAULT;
2435                        }
2436                        ret = copy_to_user(config->coordinates_y[i],
2437                                           tab.coordinates_y[i], tab.height *
2438                                           tab.width * sizeof(*tab.coordinates_y[i]));
2439                        if (ret) {
2440                                dev_err(isp->dev,
2441                                        "Failed to copy to User for y\n");
2442                                return -EFAULT;
2443                        }
2444                }
2445        } else {
2446                struct ia_css_morph_table *tab =
2447                            asd->params.css_param.morph_table;
2448
2449                /* free first if we have one */
2450                if (tab) {
2451                        atomisp_css_morph_table_free(tab);
2452                        asd->params.css_param.morph_table = NULL;
2453                }
2454
2455                /* allocate new one */
2456                tab = atomisp_css_morph_table_allocate(config->width,
2457                                                       config->height);
2458
2459                if (!tab) {
2460                        dev_err(isp->dev, "out of memory\n");
2461                        return -EINVAL;
2462                }
2463
2464                for (i = 0; i < IA_CSS_MORPH_TABLE_NUM_PLANES; i++) {
2465                        ret = copy_from_user(tab->coordinates_x[i],
2466                                             config->coordinates_x[i],
2467                                             config->height * config->width *
2468                                             sizeof(*config->coordinates_x[i]));
2469                        if (ret) {
2470                                dev_err(isp->dev,
2471                                        "Failed to copy from User for x, ret %d\n",
2472                                        ret);
2473                                atomisp_css_morph_table_free(tab);
2474                                return -EFAULT;
2475                        }
2476                        ret = copy_from_user(tab->coordinates_y[i],
2477                                             config->coordinates_y[i],
2478                                             config->height * config->width *
2479                                             sizeof(*config->coordinates_y[i]));
2480                        if (ret) {
2481                                dev_err(isp->dev,
2482                                        "Failed to copy from User for y, ret is %d\n",
2483                                        ret);
2484                                atomisp_css_morph_table_free(tab);
2485                                return -EFAULT;
2486                        }
2487                }
2488                asd->params.css_param.morph_table = tab;
2489                if (asd->params.gdc_cac_en)
2490                        asd->params.config.morph_table = tab;
2491        }
2492
2493        return 0;
2494}
2495
2496int atomisp_macc_table(struct atomisp_sub_device *asd, int flag,
2497                       struct atomisp_macc_config *config)
2498{
2499        struct ia_css_macc_table *macc_table;
2500
2501        switch (config->color_effect) {
2502        case V4L2_COLORFX_NONE:
2503                macc_table = &asd->params.css_param.macc_table;
2504                break;
2505        case V4L2_COLORFX_SKY_BLUE:
2506                macc_table = &blue_macc_table;
2507                break;
2508        case V4L2_COLORFX_GRASS_GREEN:
2509                macc_table = &green_macc_table;
2510                break;
2511        case V4L2_COLORFX_SKIN_WHITEN_LOW:
2512                macc_table = &skin_low_macc_table;
2513                break;
2514        case V4L2_COLORFX_SKIN_WHITEN:
2515                macc_table = &skin_medium_macc_table;
2516                break;
2517        case V4L2_COLORFX_SKIN_WHITEN_HIGH:
2518                macc_table = &skin_high_macc_table;
2519                break;
2520        default:
2521                return -EINVAL;
2522        }
2523
2524        if (flag == 0) {
2525                /* Get macc table from current setup */
2526                memcpy(&config->table, macc_table,
2527                       sizeof(struct ia_css_macc_table));
2528        } else {
2529                memcpy(macc_table, &config->table,
2530                       sizeof(struct ia_css_macc_table));
2531                if (config->color_effect == asd->params.color_effect)
2532                        asd->params.config.macc_table = macc_table;
2533        }
2534
2535        return 0;
2536}
2537
2538int atomisp_set_dis_vector(struct atomisp_sub_device *asd,
2539                           struct atomisp_dis_vector *vector)
2540{
2541        atomisp_css_video_set_dis_vector(asd, vector);
2542
2543        asd->params.dis_proj_data_valid = false;
2544        asd->params.css_update_params_needed = true;
2545        return 0;
2546}
2547
2548/*
2549 * Function to set/get image stablization statistics
2550 */
2551int atomisp_get_dis_stat(struct atomisp_sub_device *asd,
2552                         struct atomisp_dis_statistics *stats)
2553{
2554        return atomisp_css_get_dis_stat(asd, stats);
2555}
2556
2557/*
2558 * Function  set camrea_prefiles.xml current sensor pixel array size
2559 */
2560int atomisp_set_array_res(struct atomisp_sub_device *asd,
2561                          struct atomisp_resolution  *config)
2562{
2563        dev_dbg(asd->isp->dev, ">%s start\n", __func__);
2564        if (!config) {
2565                dev_err(asd->isp->dev, "Set sensor array size is not valid\n");
2566                return -EINVAL;
2567        }
2568
2569        asd->sensor_array_res.width = config->width;
2570        asd->sensor_array_res.height = config->height;
2571        return 0;
2572}
2573
2574/*
2575 * Function to get DVS2 BQ resolution settings
2576 */
2577int atomisp_get_dvs2_bq_resolutions(struct atomisp_sub_device *asd,
2578                                    struct atomisp_dvs2_bq_resolutions *bq_res)
2579{
2580        struct ia_css_pipe_config *pipe_cfg = NULL;
2581        struct ia_css_stream_config *stream_cfg = NULL;
2582        struct ia_css_stream_input_config *input_config = NULL;
2583
2584        struct ia_css_stream *stream =
2585                    asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream;
2586        if (!stream) {
2587                dev_warn(asd->isp->dev, "stream is not created");
2588                return -EAGAIN;
2589        }
2590
2591        pipe_cfg = &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL]
2592                   .pipe_configs[IA_CSS_PIPE_ID_VIDEO];
2593        stream_cfg = &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL]
2594                     .stream_config;
2595        input_config = &stream_cfg->input_config;
2596
2597        if (!bq_res)
2598                return -EINVAL;
2599
2600        /* the GDC output resolution */
2601        bq_res->output_bq.width_bq = pipe_cfg->output_info[0].res.width / 2;
2602        bq_res->output_bq.height_bq = pipe_cfg->output_info[0].res.height / 2;
2603
2604        bq_res->envelope_bq.width_bq = 0;
2605        bq_res->envelope_bq.height_bq = 0;
2606        /* the GDC input resolution */
2607        if (!asd->continuous_mode->val) {
2608                bq_res->source_bq.width_bq = bq_res->output_bq.width_bq +
2609                                             pipe_cfg->dvs_envelope.width / 2;
2610                bq_res->source_bq.height_bq = bq_res->output_bq.height_bq +
2611                                              pipe_cfg->dvs_envelope.height / 2;
2612                /*
2613                 * Bad pixels caused by spatial filter processing
2614                 * ISP filter resolution should be given by CSS/FW, but for now
2615                 * there is not such API to query, and it is fixed value, so
2616                 * hardcoded here.
2617                 */
2618                bq_res->ispfilter_bq.width_bq = 12 / 2;
2619                bq_res->ispfilter_bq.height_bq = 12 / 2;
2620                /* spatial filter shift, always 4 pixels */
2621                bq_res->gdc_shift_bq.width_bq = 4 / 2;
2622                bq_res->gdc_shift_bq.height_bq = 4 / 2;
2623
2624                if (asd->params.video_dis_en) {
2625                        bq_res->envelope_bq.width_bq = pipe_cfg->dvs_envelope.width
2626                                                       / 2 - bq_res->ispfilter_bq.width_bq;
2627                        bq_res->envelope_bq.height_bq = pipe_cfg->dvs_envelope.height
2628                                                        / 2 - bq_res->ispfilter_bq.height_bq;
2629                }
2630        } else {
2631                unsigned int w_padding;
2632                unsigned int gdc_effective_input = 0;
2633
2634                /* For GDC:
2635                 * gdc_effective_input = effective_input + envelope
2636                 *
2637                 * From the comment and formula in BZ1786,
2638                 * we see the source_bq should be:
2639                 * effective_input / bayer_ds_ratio
2640                 */
2641                bq_res->source_bq.width_bq =
2642                    (input_config->effective_res.width *
2643                     pipe_cfg->bayer_ds_out_res.width /
2644                     input_config->effective_res.width + 1) / 2;
2645                bq_res->source_bq.height_bq =
2646                    (input_config->effective_res.height *
2647                     pipe_cfg->bayer_ds_out_res.height /
2648                     input_config->effective_res.height + 1) / 2;
2649
2650                if (!asd->params.video_dis_en) {
2651                        /*
2652                         * We adjust the ispfilter_bq to:
2653                         * ispfilter_bq = 128/BDS
2654                         * we still need firmware team to provide an offical
2655                         * formula for SDV.
2656                         */
2657                        bq_res->ispfilter_bq.width_bq = 128 *
2658                                                        pipe_cfg->bayer_ds_out_res.width /
2659                                                        input_config->effective_res.width / 2;
2660                        bq_res->ispfilter_bq.height_bq = 128 *
2661                                                         pipe_cfg->bayer_ds_out_res.width /
2662                                                         input_config->effective_res.width / 2;
2663
2664                        if (IS_HWREVISION(asd->isp, ATOMISP_HW_REVISION_ISP2401)) {
2665                                /* No additional left padding for ISYS2401 */
2666                                bq_res->gdc_shift_bq.width_bq = 4 / 2;
2667                                bq_res->gdc_shift_bq.height_bq = 4 / 2;
2668                        } else {
2669                                /*
2670                                 * For the w_padding and gdc_shift_bq cacluation
2671                                 * Please see the BZ 1786 and 4358 for more info.
2672                                 * Just test that this formula can work now,
2673                                 * but we still have no offical formula.
2674                                 *
2675                                 * w_padding = ceiling(gdc_effective_input
2676                                 *             /128, 1) * 128 - effective_width
2677                                 * gdc_shift_bq = w_padding/BDS/2 + ispfilter_bq/2
2678                                 */
2679                                gdc_effective_input =
2680                                    input_config->effective_res.width +
2681                                    pipe_cfg->dvs_envelope.width;
2682                                w_padding = roundup(gdc_effective_input, 128) -
2683                                            input_config->effective_res.width;
2684                                w_padding = w_padding *
2685                                            pipe_cfg->bayer_ds_out_res.width /
2686                                            input_config->effective_res.width + 1;
2687                                w_padding = roundup(w_padding / 2, 1);
2688
2689                                bq_res->gdc_shift_bq.width_bq = bq_res->ispfilter_bq.width_bq / 2
2690                                                                + w_padding;
2691                                bq_res->gdc_shift_bq.height_bq = 4 / 2;
2692                        }
2693                } else {
2694                        unsigned int dvs_w, dvs_h, dvs_w_max, dvs_h_max;
2695
2696                        bq_res->ispfilter_bq.width_bq = 8 / 2;
2697                        bq_res->ispfilter_bq.height_bq = 8 / 2;
2698
2699                        if (IS_HWREVISION(asd->isp, ATOMISP_HW_REVISION_ISP2401)) {
2700                                /* No additional left padding for ISYS2401 */
2701                                bq_res->gdc_shift_bq.width_bq = 4 / 2;
2702                                bq_res->gdc_shift_bq.height_bq = 4 / 2;
2703                        } else {
2704                                w_padding =
2705                                    roundup(input_config->effective_res.width, 128) -
2706                                    input_config->effective_res.width;
2707                                if (w_padding < 12)
2708                                        w_padding = 12;
2709                                bq_res->gdc_shift_bq.width_bq = 4 / 2 +
2710                                                                ((w_padding - 12) *
2711                                                                 pipe_cfg->bayer_ds_out_res.width /
2712                                                                 input_config->effective_res.width + 1) / 2;
2713                                bq_res->gdc_shift_bq.height_bq = 4 / 2;
2714                        }
2715
2716                        dvs_w = pipe_cfg->bayer_ds_out_res.width -
2717                                pipe_cfg->output_info[0].res.width;
2718                        dvs_h = pipe_cfg->bayer_ds_out_res.height -
2719                                pipe_cfg->output_info[0].res.height;
2720                        dvs_w_max = rounddown(
2721                                        pipe_cfg->output_info[0].res.width / 5,
2722                                        ATOM_ISP_STEP_WIDTH);
2723                        dvs_h_max = rounddown(
2724                                        pipe_cfg->output_info[0].res.height / 5,
2725                                        ATOM_ISP_STEP_HEIGHT);
2726                        bq_res->envelope_bq.width_bq =
2727                            min((dvs_w / 2), (dvs_w_max / 2)) -
2728                            bq_res->ispfilter_bq.width_bq;
2729                        bq_res->envelope_bq.height_bq =
2730                            min((dvs_h / 2), (dvs_h_max / 2)) -
2731                            bq_res->ispfilter_bq.height_bq;
2732                }
2733        }
2734
2735        dev_dbg(asd->isp->dev,
2736                "source_bq.width_bq %d, source_bq.height_bq %d,\nispfilter_bq.width_bq %d, ispfilter_bq.height_bq %d,\ngdc_shift_bq.width_bq %d, gdc_shift_bq.height_bq %d,\nenvelope_bq.width_bq %d, envelope_bq.height_bq %d,\noutput_bq.width_bq %d, output_bq.height_bq %d\n",
2737                bq_res->source_bq.width_bq, bq_res->source_bq.height_bq,
2738                bq_res->ispfilter_bq.width_bq, bq_res->ispfilter_bq.height_bq,
2739                bq_res->gdc_shift_bq.width_bq, bq_res->gdc_shift_bq.height_bq,
2740                bq_res->envelope_bq.width_bq, bq_res->envelope_bq.height_bq,
2741                bq_res->output_bq.width_bq, bq_res->output_bq.height_bq);
2742
2743        return 0;
2744}
2745
2746int atomisp_set_dis_coefs(struct atomisp_sub_device *asd,
2747                          struct atomisp_dis_coefficients *coefs)
2748{
2749        return atomisp_css_set_dis_coefs(asd, coefs);
2750}
2751
2752/*
2753 * Function to set/get 3A stat from isp
2754 */
2755int atomisp_3a_stat(struct atomisp_sub_device *asd, int flag,
2756                    struct atomisp_3a_statistics *config)
2757{
2758        struct atomisp_device *isp = asd->isp;
2759        struct atomisp_s3a_buf *s3a_buf;
2760        unsigned long ret;
2761
2762        if (flag != 0)
2763                return -EINVAL;
2764
2765        /* sanity check to avoid writing into unallocated memory. */
2766        if (asd->params.s3a_output_bytes == 0)
2767                return -EINVAL;
2768
2769        if (atomisp_compare_grid(asd, &config->grid_info) != 0) {
2770                /* If the grid info in the argument differs from the current
2771                   grid info, we tell the caller to reset the grid size and
2772                   try again. */
2773                return -EAGAIN;
2774        }
2775
2776        if (list_empty(&asd->s3a_stats_ready)) {
2777                dev_err(isp->dev, "3a statistics is not valid.\n");
2778                return -EAGAIN;
2779        }
2780
2781        s3a_buf = list_entry(asd->s3a_stats_ready.next,
2782                             struct atomisp_s3a_buf, list);
2783        if (s3a_buf->s3a_map)
2784                ia_css_translate_3a_statistics(
2785                    asd->params.s3a_user_stat, s3a_buf->s3a_map);
2786        else
2787                ia_css_get_3a_statistics(asd->params.s3a_user_stat,
2788                                         s3a_buf->s3a_data);
2789
2790        config->exp_id = s3a_buf->s3a_data->exp_id;
2791        config->isp_config_id = s3a_buf->s3a_data->isp_config_id;
2792
2793        ret = copy_to_user(config->data, asd->params.s3a_user_stat->data,
2794                           asd->params.s3a_output_bytes);
2795        if (ret) {
2796                dev_err(isp->dev, "copy to user failed: copied %lu bytes\n",
2797                        ret);
2798                return -EFAULT;
2799        }
2800
2801        /* Move to free buffer list */
2802        list_del_init(&s3a_buf->list);
2803        list_add_tail(&s3a_buf->list, &asd->s3a_stats);
2804        dev_dbg(isp->dev, "%s: finish getting exp_id %d 3a stat, isp_config_id %d\n",
2805                __func__,
2806                config->exp_id, config->isp_config_id);
2807        return 0;
2808}
2809
2810int atomisp_get_metadata(struct atomisp_sub_device *asd, int flag,
2811                         struct atomisp_metadata *md)
2812{
2813        struct atomisp_device *isp = asd->isp;
2814        struct ia_css_stream_info *stream_info;
2815        struct camera_mipi_info *mipi_info;
2816        struct atomisp_metadata_buf *md_buf;
2817        enum atomisp_metadata_type md_type = ATOMISP_MAIN_METADATA;
2818        int ret, i;
2819
2820        if (flag != 0)
2821                return -EINVAL;
2822
2823        stream_info = &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].
2824                      stream_info;
2825
2826        /* We always return the resolution and stride even if there is
2827         * no valid metadata. This allows the caller to get the information
2828         * needed to allocate user-space buffers. */
2829        md->width  = stream_info->metadata_info.resolution.width;
2830        md->height = stream_info->metadata_info.resolution.height;
2831        md->stride = stream_info->metadata_info.stride;
2832
2833        /* sanity check to avoid writing into unallocated memory.
2834         * This does not return an error because it is a valid way
2835         * for applications to detect that metadata is not enabled. */
2836        if (md->width == 0 || md->height == 0 || !md->data)
2837                return 0;
2838
2839        /* This is done in the atomisp_buf_done() */
2840        if (list_empty(&asd->metadata_ready[md_type])) {
2841                dev_warn(isp->dev, "Metadata queue is empty now!\n");
2842                return -EAGAIN;
2843        }
2844
2845        mipi_info = atomisp_to_sensor_mipi_info(
2846                        isp->inputs[asd->input_curr].camera);
2847        if (!mipi_info)
2848                return -EINVAL;
2849
2850        if (mipi_info->metadata_effective_width) {
2851                for (i = 0; i < md->height; i++)
2852                        md->effective_width[i] =
2853                            mipi_info->metadata_effective_width[i];
2854        }
2855
2856        md_buf = list_entry(asd->metadata_ready[md_type].next,
2857                            struct atomisp_metadata_buf, list);
2858        md->exp_id = md_buf->metadata->exp_id;
2859        if (md_buf->md_vptr) {
2860                ret = copy_to_user(md->data,
2861                                   md_buf->md_vptr,
2862                                   stream_info->metadata_info.size);
2863        } else {
2864                hmm_load(md_buf->metadata->address,
2865                         asd->params.metadata_user[md_type],
2866                         stream_info->metadata_info.size);
2867
2868                ret = copy_to_user(md->data,
2869                                   asd->params.metadata_user[md_type],
2870                                   stream_info->metadata_info.size);
2871        }
2872        if (ret) {
2873                dev_err(isp->dev, "copy to user failed: copied %d bytes\n",
2874                        ret);
2875                return -EFAULT;
2876        }
2877
2878        list_del_init(&md_buf->list);
2879        list_add_tail(&md_buf->list, &asd->metadata[md_type]);
2880
2881        dev_dbg(isp->dev, "%s: HAL de-queued metadata type %d with exp_id %d\n",
2882                __func__, md_type, md->exp_id);
2883        return 0;
2884}
2885
2886int atomisp_get_metadata_by_type(struct atomisp_sub_device *asd, int flag,
2887                                 struct atomisp_metadata_with_type *md)
2888{
2889        struct atomisp_device *isp = asd->isp;
2890        struct ia_css_stream_info *stream_info;
2891        struct camera_mipi_info *mipi_info;
2892        struct atomisp_metadata_buf *md_buf;
2893        enum atomisp_metadata_type md_type;
2894        int ret, i;
2895
2896        if (flag != 0)
2897                return -EINVAL;
2898
2899        stream_info = &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].
2900                      stream_info;
2901
2902        /* We always return the resolution and stride even if there is
2903         * no valid metadata. This allows the caller to get the information
2904         * needed to allocate user-space buffers. */
2905        md->width  = stream_info->metadata_info.resolution.width;
2906        md->height = stream_info->metadata_info.resolution.height;
2907        md->stride = stream_info->metadata_info.stride;
2908
2909        /* sanity check to avoid writing into unallocated memory.
2910         * This does not return an error because it is a valid way
2911         * for applications to detect that metadata is not enabled. */
2912        if (md->width == 0 || md->height == 0 || !md->data)
2913                return 0;
2914
2915        md_type = md->type;
2916        if (md_type < 0 || md_type >= ATOMISP_METADATA_TYPE_NUM)
2917                return -EINVAL;
2918
2919        /* This is done in the atomisp_buf_done() */
2920        if (list_empty(&asd->metadata_ready[md_type])) {
2921                dev_warn(isp->dev, "Metadata queue is empty now!\n");
2922                return -EAGAIN;
2923        }
2924
2925        mipi_info = atomisp_to_sensor_mipi_info(
2926                        isp->inputs[asd->input_curr].camera);
2927        if (!mipi_info)
2928                return -EINVAL;
2929
2930        if (mipi_info->metadata_effective_width) {
2931                for (i = 0; i < md->height; i++)
2932                        md->effective_width[i] =
2933                            mipi_info->metadata_effective_width[i];
2934        }
2935
2936        md_buf = list_entry(asd->metadata_ready[md_type].next,
2937                            struct atomisp_metadata_buf, list);
2938        md->exp_id = md_buf->metadata->exp_id;
2939        if (md_buf->md_vptr) {
2940                ret = copy_to_user(md->data,
2941                                   md_buf->md_vptr,
2942                                   stream_info->metadata_info.size);
2943        } else {
2944                hmm_load(md_buf->metadata->address,
2945                         asd->params.metadata_user[md_type],
2946                         stream_info->metadata_info.size);
2947
2948                ret = copy_to_user(md->data,
2949                                   asd->params.metadata_user[md_type],
2950                                   stream_info->metadata_info.size);
2951        }
2952        if (ret) {
2953                dev_err(isp->dev, "copy to user failed: copied %d bytes\n",
2954                        ret);
2955                return -EFAULT;
2956        } else {
2957                list_del_init(&md_buf->list);
2958                list_add_tail(&md_buf->list, &asd->metadata[md_type]);
2959        }
2960        dev_dbg(isp->dev, "%s: HAL de-queued metadata type %d with exp_id %d\n",
2961                __func__, md_type, md->exp_id);
2962        return 0;
2963}
2964
2965/*
2966 * Function to calculate real zoom region for every pipe
2967 */
2968int atomisp_calculate_real_zoom_region(struct atomisp_sub_device *asd,
2969                                       struct ia_css_dz_config   *dz_config,
2970                                       enum ia_css_pipe_id css_pipe_id)
2971
2972{
2973        struct atomisp_stream_env *stream_env =
2974                    &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL];
2975        struct atomisp_resolution  eff_res, out_res;
2976        int w_offset, h_offset;
2977
2978        memset(&eff_res, 0, sizeof(eff_res));
2979        memset(&out_res, 0, sizeof(out_res));
2980
2981        if (dz_config->dx || dz_config->dy)
2982                return 0;
2983
2984        if (css_pipe_id != IA_CSS_PIPE_ID_PREVIEW
2985            && css_pipe_id != IA_CSS_PIPE_ID_CAPTURE) {
2986                dev_err(asd->isp->dev, "%s the set pipe no support crop region"
2987                        , __func__);
2988                return -EINVAL;
2989        }
2990
2991        eff_res.width =
2992            stream_env->stream_config.input_config.effective_res.width;
2993        eff_res.height =
2994            stream_env->stream_config.input_config.effective_res.height;
2995        if (eff_res.width == 0 || eff_res.height == 0) {
2996                dev_err(asd->isp->dev, "%s err effective resolution"
2997                        , __func__);
2998                return -EINVAL;
2999        }
3000
3001        if (dz_config->zoom_region.resolution.width
3002            == asd->sensor_array_res.width
3003            || dz_config->zoom_region.resolution.height
3004            == asd->sensor_array_res.height) {
3005                /*no need crop region*/
3006                dz_config->zoom_region.origin.x = 0;
3007                dz_config->zoom_region.origin.y = 0;
3008                dz_config->zoom_region.resolution.width = eff_res.width;
3009                dz_config->zoom_region.resolution.height = eff_res.height;
3010                return 0;
3011        }
3012
3013        /* FIXME:
3014         * This is not the correct implementation with Google's definition, due
3015         * to firmware limitation.
3016         * map real crop region base on above calculating base max crop region.
3017         */
3018
3019        if (!IS_ISP2401) {
3020                dz_config->zoom_region.origin.x = dz_config->zoom_region.origin.x
3021                                                  * eff_res.width
3022                                                  / asd->sensor_array_res.width;
3023                dz_config->zoom_region.origin.y = dz_config->zoom_region.origin.y
3024                                                  * eff_res.height
3025                                                  / asd->sensor_array_res.height;
3026                dz_config->zoom_region.resolution.width = dz_config->zoom_region.resolution.width
3027                                                          * eff_res.width
3028                                                          / asd->sensor_array_res.width;
3029                dz_config->zoom_region.resolution.height = dz_config->zoom_region.resolution.height
3030                                                          * eff_res.height
3031                                                          / asd->sensor_array_res.height;
3032                /*
3033                 * Set same ratio of crop region resolution and current pipe output
3034                 * resolution
3035                 */
3036                out_res.width = stream_env->pipe_configs[css_pipe_id].output_info[0].res.width;
3037                out_res.height = stream_env->pipe_configs[css_pipe_id].output_info[0].res.height;
3038                if (out_res.width == 0 || out_res.height == 0) {
3039                        dev_err(asd->isp->dev, "%s err current pipe output resolution"
3040                                , __func__);
3041                        return -EINVAL;
3042                }
3043        } else {
3044                out_res.width = stream_env->pipe_configs[css_pipe_id].output_info[0].res.width;
3045                out_res.height = stream_env->pipe_configs[css_pipe_id].output_info[0].res.height;
3046                if (out_res.width == 0 || out_res.height == 0) {
3047                        dev_err(asd->isp->dev, "%s err current pipe output resolution"
3048                                , __func__);
3049                        return -EINVAL;
3050                }
3051
3052                if (asd->sensor_array_res.width * out_res.height
3053                    < out_res.width * asd->sensor_array_res.height) {
3054                        h_offset = asd->sensor_array_res.height
3055                                   - asd->sensor_array_res.width
3056                                   * out_res.height / out_res.width;
3057                        h_offset = h_offset / 2;
3058                        if (dz_config->zoom_region.origin.y < h_offset)
3059                                dz_config->zoom_region.origin.y = 0;
3060                        else
3061                                dz_config->zoom_region.origin.y = dz_config->zoom_region.origin.y - h_offset;
3062                        w_offset = 0;
3063                } else {
3064                        w_offset = asd->sensor_array_res.width
3065                                   - asd->sensor_array_res.height
3066                                   * out_res.width / out_res.height;
3067                        w_offset = w_offset / 2;
3068                        if (dz_config->zoom_region.origin.x < w_offset)
3069                                dz_config->zoom_region.origin.x = 0;
3070                        else
3071                                dz_config->zoom_region.origin.x = dz_config->zoom_region.origin.x - w_offset;
3072                        h_offset = 0;
3073                }
3074                dz_config->zoom_region.origin.x = dz_config->zoom_region.origin.x
3075                                                  * eff_res.width
3076                                                  / (asd->sensor_array_res.width - 2 * w_offset);
3077                dz_config->zoom_region.origin.y = dz_config->zoom_region.origin.y
3078                                                  * eff_res.height
3079                                                  / (asd->sensor_array_res.height - 2 * h_offset);
3080                dz_config->zoom_region.resolution.width = dz_config->zoom_region.resolution.width
3081                                                  * eff_res.width
3082                                                  / (asd->sensor_array_res.width - 2 * w_offset);
3083                dz_config->zoom_region.resolution.height = dz_config->zoom_region.resolution.height
3084                                                  * eff_res.height
3085                                                  / (asd->sensor_array_res.height - 2 * h_offset);
3086        }
3087
3088        if (out_res.width * dz_config->zoom_region.resolution.height
3089            > dz_config->zoom_region.resolution.width * out_res.height) {
3090                dz_config->zoom_region.resolution.height =
3091                    dz_config->zoom_region.resolution.width
3092                    * out_res.height / out_res.width;
3093        } else {
3094                dz_config->zoom_region.resolution.width =
3095                    dz_config->zoom_region.resolution.height
3096                    * out_res.width / out_res.height;
3097        }
3098        dev_dbg(asd->isp->dev,
3099                "%s crop region:(%d,%d),(%d,%d) eff_res(%d, %d) array_size(%d,%d) out_res(%d, %d)\n",
3100                __func__, dz_config->zoom_region.origin.x,
3101                dz_config->zoom_region.origin.y,
3102                dz_config->zoom_region.resolution.width,
3103                dz_config->zoom_region.resolution.height,
3104                eff_res.width, eff_res.height,
3105                asd->sensor_array_res.width,
3106                asd->sensor_array_res.height,
3107                out_res.width, out_res.height);
3108
3109        if ((dz_config->zoom_region.origin.x +
3110             dz_config->zoom_region.resolution.width
3111             > eff_res.width) ||
3112            (dz_config->zoom_region.origin.y +
3113             dz_config->zoom_region.resolution.height
3114             > eff_res.height))
3115                return -EINVAL;
3116
3117        return 0;
3118}
3119
3120/*
3121 * Function to check the zoom region whether is effective
3122 */
3123static bool atomisp_check_zoom_region(
3124    struct atomisp_sub_device *asd,
3125    struct ia_css_dz_config *dz_config)
3126{
3127        struct atomisp_resolution  config;
3128        bool flag = false;
3129        unsigned int w, h;
3130
3131        memset(&config, 0, sizeof(struct atomisp_resolution));
3132
3133        if (dz_config->dx && dz_config->dy)
3134                return true;
3135
3136        config.width = asd->sensor_array_res.width;
3137        config.height = asd->sensor_array_res.height;
3138        w = dz_config->zoom_region.origin.x +
3139            dz_config->zoom_region.resolution.width;
3140        h = dz_config->zoom_region.origin.y +
3141            dz_config->zoom_region.resolution.height;
3142
3143        if ((w <= config.width) && (h <= config.height) && w > 0 && h > 0)
3144                flag = true;
3145        else
3146                /* setting error zoom region */
3147                dev_err(asd->isp->dev,
3148                        "%s zoom region ERROR:dz_config:(%d,%d),(%d,%d)array_res(%d, %d)\n",
3149                        __func__, dz_config->zoom_region.origin.x,
3150                        dz_config->zoom_region.origin.y,
3151                        dz_config->zoom_region.resolution.width,
3152                        dz_config->zoom_region.resolution.height,
3153                        config.width, config.height);
3154
3155        return flag;
3156}
3157
3158void atomisp_apply_css_parameters(
3159    struct atomisp_sub_device *asd,
3160    struct atomisp_css_params *css_param)
3161{
3162        if (css_param->update_flag.wb_config)
3163                asd->params.config.wb_config = &css_param->wb_config;
3164
3165        if (css_param->update_flag.ob_config)
3166                asd->params.config.ob_config = &css_param->ob_config;
3167
3168        if (css_param->update_flag.dp_config)
3169                asd->params.config.dp_config = &css_param->dp_config;
3170
3171        if (css_param->update_flag.nr_config)
3172                asd->params.config.nr_config = &css_param->nr_config;
3173
3174        if (css_param->update_flag.ee_config)
3175                asd->params.config.ee_config = &css_param->ee_config;
3176
3177        if (css_param->update_flag.tnr_config)
3178                asd->params.config.tnr_config = &css_param->tnr_config;
3179
3180        if (css_param->update_flag.a3a_config)
3181                asd->params.config.s3a_config = &css_param->s3a_config;
3182
3183        if (css_param->update_flag.ctc_config)
3184                asd->params.config.ctc_config = &css_param->ctc_config;
3185
3186        if (css_param->update_flag.cnr_config)
3187                asd->params.config.cnr_config = &css_param->cnr_config;
3188
3189        if (css_param->update_flag.ecd_config)
3190                asd->params.config.ecd_config = &css_param->ecd_config;
3191
3192        if (css_param->update_flag.ynr_config)
3193                asd->params.config.ynr_config = &css_param->ynr_config;
3194
3195        if (css_param->update_flag.fc_config)
3196                asd->params.config.fc_config = &css_param->fc_config;
3197
3198        if (css_param->update_flag.macc_config)
3199                asd->params.config.macc_config = &css_param->macc_config;
3200
3201        if (css_param->update_flag.aa_config)
3202                asd->params.config.aa_config = &css_param->aa_config;
3203
3204        if (css_param->update_flag.anr_config)
3205                asd->params.config.anr_config = &css_param->anr_config;
3206
3207        if (css_param->update_flag.xnr_config)
3208                asd->params.config.xnr_config = &css_param->xnr_config;
3209
3210        if (css_param->update_flag.yuv2rgb_cc_config)
3211                asd->params.config.yuv2rgb_cc_config = &css_param->yuv2rgb_cc_config;
3212
3213        if (css_param->update_flag.rgb2yuv_cc_config)
3214                asd->params.config.rgb2yuv_cc_config = &css_param->rgb2yuv_cc_config;
3215
3216        if (css_param->update_flag.macc_table)
3217                asd->params.config.macc_table = &css_param->macc_table;
3218
3219        if (css_param->update_flag.xnr_table)
3220                asd->params.config.xnr_table = &css_param->xnr_table;
3221
3222        if (css_param->update_flag.r_gamma_table)
3223                asd->params.config.r_gamma_table = &css_param->r_gamma_table;
3224
3225        if (css_param->update_flag.g_gamma_table)
3226                asd->params.config.g_gamma_table = &css_param->g_gamma_table;
3227
3228        if (css_param->update_flag.b_gamma_table)
3229                asd->params.config.b_gamma_table = &css_param->b_gamma_table;
3230
3231        if (css_param->update_flag.anr_thres)
3232                atomisp_css_set_anr_thres(asd, &css_param->anr_thres);
3233
3234        if (css_param->update_flag.shading_table)
3235                asd->params.config.shading_table = css_param->shading_table;
3236
3237        if (css_param->update_flag.morph_table && asd->params.gdc_cac_en)
3238                asd->params.config.morph_table = css_param->morph_table;
3239
3240        if (css_param->update_flag.dvs2_coefs) {
3241                struct ia_css_dvs_grid_info *dvs_grid_info =
3242                    atomisp_css_get_dvs_grid_info(
3243                        &asd->params.curr_grid_info);
3244
3245                if (dvs_grid_info && dvs_grid_info->enable)
3246                        atomisp_css_set_dvs2_coefs(asd, css_param->dvs2_coeff);
3247        }
3248
3249        if (css_param->update_flag.dvs_6axis_config)
3250                atomisp_css_set_dvs_6axis(asd, css_param->dvs_6axis);
3251
3252        atomisp_css_set_isp_config_id(asd, css_param->isp_config_id);
3253        /*
3254         * These configurations are on used by ISP1.x, not for ISP2.x,
3255         * so do not handle them. see comments of ia_css_isp_config.
3256         * 1 cc_config
3257         * 2 ce_config
3258         * 3 de_config
3259         * 4 gc_config
3260         * 5 gamma_table
3261         * 6 ctc_table
3262         * 7 dvs_coefs
3263         */
3264}
3265
3266static unsigned int long copy_from_compatible(void *to, const void *from,
3267        unsigned long n, bool from_user)
3268{
3269        if (from_user)
3270                return copy_from_user(to, (void __user *)from, n);
3271        else
3272                memcpy(to, from, n);
3273        return 0;
3274}
3275
3276int atomisp_cp_general_isp_parameters(struct atomisp_sub_device *asd,
3277                                      struct atomisp_parameters *arg,
3278                                      struct atomisp_css_params *css_param,
3279                                      bool from_user)
3280{
3281        struct atomisp_parameters *cur_config = &css_param->update_flag;
3282
3283        if (!arg || !asd || !css_param)
3284                return -EINVAL;
3285
3286        if (arg->wb_config && (from_user || !cur_config->wb_config)) {
3287                if (copy_from_compatible(&css_param->wb_config, arg->wb_config,
3288                                         sizeof(struct ia_css_wb_config),
3289                                         from_user))
3290                        return -EFAULT;
3291                css_param->update_flag.wb_config =
3292                    (struct atomisp_wb_config *)&css_param->wb_config;
3293        }
3294
3295        if (arg->ob_config && (from_user || !cur_config->ob_config)) {
3296                if (copy_from_compatible(&css_param->ob_config, arg->ob_config,
3297                                         sizeof(struct ia_css_ob_config),
3298                                         from_user))
3299                        return -EFAULT;
3300                css_param->update_flag.ob_config =
3301                    (struct atomisp_ob_config *)&css_param->ob_config;
3302        }
3303
3304        if (arg->dp_config && (from_user || !cur_config->dp_config)) {
3305                if (copy_from_compatible(&css_param->dp_config, arg->dp_config,
3306                                         sizeof(struct ia_css_dp_config),
3307                                         from_user))
3308                        return -EFAULT;
3309                css_param->update_flag.dp_config =
3310                    (struct atomisp_dp_config *)&css_param->dp_config;
3311        }
3312
3313        if (asd->run_mode->val != ATOMISP_RUN_MODE_VIDEO) {
3314                if (arg->dz_config && (from_user || !cur_config->dz_config)) {
3315                        if (copy_from_compatible(&css_param->dz_config,
3316                                                 arg->dz_config,
3317                                                 sizeof(struct ia_css_dz_config),
3318                                                 from_user))
3319                                return -EFAULT;
3320                        if (!atomisp_check_zoom_region(asd,
3321                                                       &css_param->dz_config)) {
3322                                dev_err(asd->isp->dev, "crop region error!");
3323                                return -EINVAL;
3324                        }
3325                        css_param->update_flag.dz_config =
3326                            (struct atomisp_dz_config *)
3327                            &css_param->dz_config;
3328                }
3329        }
3330
3331        if (arg->nr_config && (from_user || !cur_config->nr_config)) {
3332                if (copy_from_compatible(&css_param->nr_config, arg->nr_config,
3333                                         sizeof(struct ia_css_nr_config),
3334                                         from_user))
3335                        return -EFAULT;
3336                css_param->update_flag.nr_config =
3337                    (struct atomisp_nr_config *)&css_param->nr_config;
3338        }
3339
3340        if (arg->ee_config && (from_user || !cur_config->ee_config)) {
3341                if (copy_from_compatible(&css_param->ee_config, arg->ee_config,
3342                                         sizeof(struct ia_css_ee_config),
3343                                         from_user))
3344                        return -EFAULT;
3345                css_param->update_flag.ee_config =
3346                    (struct atomisp_ee_config *)&css_param->ee_config;
3347        }
3348
3349        if (arg->tnr_config && (from_user || !cur_config->tnr_config)) {
3350                if (copy_from_compatible(&css_param->tnr_config,
3351                                         arg->tnr_config,
3352                                         sizeof(struct ia_css_tnr_config),
3353                                         from_user))
3354                        return -EFAULT;
3355                css_param->update_flag.tnr_config =
3356                    (struct atomisp_tnr_config *)
3357                    &css_param->tnr_config;
3358        }
3359
3360        if (arg->a3a_config && (from_user || !cur_config->a3a_config)) {
3361                if (copy_from_compatible(&css_param->s3a_config,
3362                                         arg->a3a_config,
3363                                         sizeof(struct ia_css_3a_config),
3364                                         from_user))
3365                        return -EFAULT;
3366                css_param->update_flag.a3a_config =
3367                    (struct atomisp_3a_config *)&css_param->s3a_config;
3368        }
3369
3370        if (arg->ctc_config && (from_user || !cur_config->ctc_config)) {
3371                if (copy_from_compatible(&css_param->ctc_config,
3372                                         arg->ctc_config,
3373                                         sizeof(struct ia_css_ctc_config),
3374                                         from_user))
3375                        return -EFAULT;
3376                css_param->update_flag.ctc_config =
3377                    (struct atomisp_ctc_config *)
3378                    &css_param->ctc_config;
3379        }
3380
3381        if (arg->cnr_config && (from_user || !cur_config->cnr_config)) {
3382                if (copy_from_compatible(&css_param->cnr_config,
3383                                         arg->cnr_config,
3384                                         sizeof(struct ia_css_cnr_config),
3385                                         from_user))
3386                        return -EFAULT;
3387                css_param->update_flag.cnr_config =
3388                    (struct atomisp_cnr_config *)
3389                    &css_param->cnr_config;
3390        }
3391
3392        if (arg->ecd_config && (from_user || !cur_config->ecd_config)) {
3393                if (copy_from_compatible(&css_param->ecd_config,
3394                                         arg->ecd_config,
3395                                         sizeof(struct ia_css_ecd_config),
3396                                         from_user))
3397                        return -EFAULT;
3398                css_param->update_flag.ecd_config =
3399                    (struct atomisp_ecd_config *)
3400                    &css_param->ecd_config;
3401        }
3402
3403        if (arg->ynr_config && (from_user || !cur_config->ynr_config)) {
3404                if (copy_from_compatible(&css_param->ynr_config,
3405                                         arg->ynr_config,
3406                                         sizeof(struct ia_css_ynr_config),
3407                                         from_user))
3408                        return -EFAULT;
3409                css_param->update_flag.ynr_config =
3410                    (struct atomisp_ynr_config *)
3411                    &css_param->ynr_config;
3412        }
3413
3414        if (arg->fc_config && (from_user || !cur_config->fc_config)) {
3415                if (copy_from_compatible(&css_param->fc_config,
3416                                         arg->fc_config,
3417                                         sizeof(struct ia_css_fc_config),
3418                                         from_user))
3419                        return -EFAULT;
3420                css_param->update_flag.fc_config =
3421                    (struct atomisp_fc_config *)&css_param->fc_config;
3422        }
3423
3424        if (arg->macc_config && (from_user || !cur_config->macc_config)) {
3425                if (copy_from_compatible(&css_param->macc_config,
3426                                         arg->macc_config,
3427                                         sizeof(struct ia_css_macc_config),
3428                                         from_user))
3429                        return -EFAULT;
3430                css_param->update_flag.macc_config =
3431                    (struct atomisp_macc_config *)
3432                    &css_param->macc_config;
3433        }
3434
3435        if (arg->aa_config && (from_user || !cur_config->aa_config)) {
3436                if (copy_from_compatible(&css_param->aa_config, arg->aa_config,
3437                                         sizeof(struct ia_css_aa_config),
3438                                         from_user))
3439                        return -EFAULT;
3440                css_param->update_flag.aa_config =
3441                    (struct atomisp_aa_config *)&css_param->aa_config;
3442        }
3443
3444        if (arg->anr_config && (from_user || !cur_config->anr_config)) {
3445                if (copy_from_compatible(&css_param->anr_config,
3446                                         arg->anr_config,
3447                                         sizeof(struct ia_css_anr_config),
3448                                         from_user))
3449                        return -EFAULT;
3450                css_param->update_flag.anr_config =
3451                    (struct atomisp_anr_config *)
3452                    &css_param->anr_config;
3453        }
3454
3455        if (arg->xnr_config && (from_user || !cur_config->xnr_config)) {
3456                if (copy_from_compatible(&css_param->xnr_config,
3457                                         arg->xnr_config,
3458                                         sizeof(struct ia_css_xnr_config),
3459                                         from_user))
3460                        return -EFAULT;
3461                css_param->update_flag.xnr_config =
3462                    (struct atomisp_xnr_config *)
3463                    &css_param->xnr_config;
3464        }
3465
3466        if (arg->yuv2rgb_cc_config &&
3467            (from_user || !cur_config->yuv2rgb_cc_config)) {
3468                if (copy_from_compatible(&css_param->yuv2rgb_cc_config,
3469                                         arg->yuv2rgb_cc_config,
3470                                         sizeof(struct ia_css_cc_config),
3471                                         from_user))
3472                        return -EFAULT;
3473                css_param->update_flag.yuv2rgb_cc_config =
3474                    (struct atomisp_cc_config *)
3475                    &css_param->yuv2rgb_cc_config;
3476        }
3477
3478        if (arg->rgb2yuv_cc_config &&
3479            (from_user || !cur_config->rgb2yuv_cc_config)) {
3480                if (copy_from_compatible(&css_param->rgb2yuv_cc_config,
3481                                         arg->rgb2yuv_cc_config,
3482                                         sizeof(struct ia_css_cc_config),
3483                                         from_user))
3484                        return -EFAULT;
3485                css_param->update_flag.rgb2yuv_cc_config =
3486                    (struct atomisp_cc_config *)
3487                    &css_param->rgb2yuv_cc_config;
3488        }
3489
3490        if (arg->macc_table && (from_user || !cur_config->macc_table)) {
3491                if (copy_from_compatible(&css_param->macc_table,
3492                                         arg->macc_table,
3493                                         sizeof(struct ia_css_macc_table),
3494                                         from_user))
3495                        return -EFAULT;
3496                css_param->update_flag.macc_table =
3497                    (struct atomisp_macc_table *)
3498                    &css_param->macc_table;
3499        }
3500
3501        if (arg->xnr_table && (from_user || !cur_config->xnr_table)) {
3502                if (copy_from_compatible(&css_param->xnr_table,
3503                                         arg->xnr_table,
3504                                         sizeof(struct ia_css_xnr_table),
3505                                         from_user))
3506                        return -EFAULT;
3507                css_param->update_flag.xnr_table =
3508                    (struct atomisp_xnr_table *)&css_param->xnr_table;
3509        }
3510
3511        if (arg->r_gamma_table && (from_user || !cur_config->r_gamma_table)) {
3512                if (copy_from_compatible(&css_param->r_gamma_table,
3513                                         arg->r_gamma_table,
3514                                         sizeof(struct ia_css_rgb_gamma_table),
3515                                         from_user))
3516                        return -EFAULT;
3517                css_param->update_flag.r_gamma_table =
3518                    (struct atomisp_rgb_gamma_table *)
3519                    &css_param->r_gamma_table;
3520        }
3521
3522        if (arg->g_gamma_table && (from_user || !cur_config->g_gamma_table)) {
3523                if (copy_from_compatible(&css_param->g_gamma_table,
3524                                         arg->g_gamma_table,
3525                                         sizeof(struct ia_css_rgb_gamma_table),
3526                                         from_user))
3527                        return -EFAULT;
3528                css_param->update_flag.g_gamma_table =
3529                    (struct atomisp_rgb_gamma_table *)
3530                    &css_param->g_gamma_table;
3531        }
3532
3533        if (arg->b_gamma_table && (from_user || !cur_config->b_gamma_table)) {
3534                if (copy_from_compatible(&css_param->b_gamma_table,
3535                                         arg->b_gamma_table,
3536                                         sizeof(struct ia_css_rgb_gamma_table),
3537                                         from_user))
3538                        return -EFAULT;
3539                css_param->update_flag.b_gamma_table =
3540                    (struct atomisp_rgb_gamma_table *)
3541                    &css_param->b_gamma_table;
3542        }
3543
3544        if (arg->anr_thres && (from_user || !cur_config->anr_thres)) {
3545                if (copy_from_compatible(&css_param->anr_thres, arg->anr_thres,
3546                                         sizeof(struct ia_css_anr_thres),
3547                                         from_user))
3548                        return -EFAULT;
3549                css_param->update_flag.anr_thres =
3550                    (struct atomisp_anr_thres *)&css_param->anr_thres;
3551        }
3552
3553        if (from_user)
3554                css_param->isp_config_id = arg->isp_config_id;
3555        /*
3556         * These configurations are on used by ISP1.x, not for ISP2.x,
3557         * so do not handle them. see comments of ia_css_isp_config.
3558         * 1 cc_config
3559         * 2 ce_config
3560         * 3 de_config
3561         * 4 gc_config
3562         * 5 gamma_table
3563         * 6 ctc_table
3564         * 7 dvs_coefs
3565         */
3566        return 0;
3567}
3568
3569int atomisp_cp_lsc_table(struct atomisp_sub_device *asd,
3570                         struct atomisp_shading_table *source_st,
3571                         struct atomisp_css_params *css_param,
3572                         bool from_user)
3573{
3574        unsigned int i;
3575        unsigned int len_table;
3576        struct ia_css_shading_table *shading_table;
3577        struct ia_css_shading_table *old_table;
3578        struct atomisp_shading_table *st, dest_st;
3579
3580        if (!source_st)
3581                return 0;
3582
3583        if (!css_param)
3584                return -EINVAL;
3585
3586        if (!from_user && css_param->update_flag.shading_table)
3587                return 0;
3588
3589        if (IS_ISP2401) {
3590                if (copy_from_compatible(&dest_st, source_st,
3591                                        sizeof(struct atomisp_shading_table),
3592                                        from_user)) {
3593                        dev_err(asd->isp->dev, "copy shading table failed!");
3594                        return -EFAULT;
3595                }
3596                st = &dest_st;
3597        } else {
3598                st = source_st;
3599        }
3600
3601        old_table = css_param->shading_table;
3602
3603        /* user config is to disable the shading table. */
3604        if (!st->enable) {
3605                /* Generate a minimum table with enable = 0. */
3606                shading_table = atomisp_css_shading_table_alloc(1, 1);
3607                if (!shading_table)
3608                        return -ENOMEM;
3609                shading_table->enable = 0;
3610                goto set_lsc;
3611        }
3612
3613        /* Setting a new table. Validate first - all tables must be set */
3614        for (i = 0; i < ATOMISP_NUM_SC_COLORS; i++) {
3615                if (!st->data[i]) {
3616                        dev_err(asd->isp->dev, "shading table validate failed");
3617                        return -EINVAL;
3618                }
3619        }
3620
3621        /* Shading table size per color */
3622        if (!IS_ISP2401) {
3623                if (st->width > ISP2400_SH_CSS_MAX_SCTBL_WIDTH_PER_COLOR ||
3624                    st->height > ISP2400_SH_CSS_MAX_SCTBL_HEIGHT_PER_COLOR) {
3625                        dev_err(asd->isp->dev, "shading table w/h validate failed!");
3626                        return -EINVAL;
3627                }
3628        } else {
3629                if (st->width > ISP2401_SH_CSS_MAX_SCTBL_WIDTH_PER_COLOR ||
3630                    st->height > ISP2401_SH_CSS_MAX_SCTBL_HEIGHT_PER_COLOR) {
3631                        dev_err(asd->isp->dev, "shading table w/h validate failed!");
3632                        return -EINVAL;
3633                }
3634        }
3635
3636        shading_table = atomisp_css_shading_table_alloc(st->width, st->height);
3637        if (!shading_table)
3638                return -ENOMEM;
3639
3640        len_table = st->width * st->height * ATOMISP_SC_TYPE_SIZE;
3641        for (i = 0; i < ATOMISP_NUM_SC_COLORS; i++) {
3642                if (copy_from_compatible(shading_table->data[i],
3643                                         st->data[i], len_table, from_user)) {
3644                        atomisp_css_shading_table_free(shading_table);
3645                        return -EFAULT;
3646                }
3647        }
3648        shading_table->sensor_width = st->sensor_width;
3649        shading_table->sensor_height = st->sensor_height;
3650        shading_table->fraction_bits = st->fraction_bits;
3651        shading_table->enable = st->enable;
3652
3653        /* No need to update shading table if it is the same */
3654        if (old_table &&
3655            old_table->sensor_width == shading_table->sensor_width &&
3656            old_table->sensor_height == shading_table->sensor_height &&
3657            old_table->width == shading_table->width &&
3658            old_table->height == shading_table->height &&
3659            old_table->fraction_bits == shading_table->fraction_bits &&
3660            old_table->enable == shading_table->enable) {
3661                bool data_is_same = true;
3662
3663                for (i = 0; i < ATOMISP_NUM_SC_COLORS; i++) {
3664                        if (memcmp(shading_table->data[i], old_table->data[i],
3665                                   len_table) != 0) {
3666                                data_is_same = false;
3667                                break;
3668                        }
3669                }
3670
3671                if (data_is_same) {
3672                        atomisp_css_shading_table_free(shading_table);
3673                        return 0;
3674                }
3675        }
3676
3677set_lsc:
3678        /* set LSC to CSS */
3679        css_param->shading_table = shading_table;
3680        css_param->update_flag.shading_table = (struct atomisp_shading_table *)shading_table;
3681        asd->params.sc_en = shading_table;
3682
3683        if (old_table)
3684                atomisp_css_shading_table_free(old_table);
3685
3686        return 0;
3687}
3688
3689int atomisp_css_cp_dvs2_coefs(struct atomisp_sub_device *asd,
3690                              struct ia_css_dvs2_coefficients *coefs,
3691                              struct atomisp_css_params *css_param,
3692                              bool from_user)
3693{
3694        struct ia_css_dvs_grid_info *cur =
3695            atomisp_css_get_dvs_grid_info(&asd->params.curr_grid_info);
3696        int dvs_hor_coef_bytes, dvs_ver_coef_bytes;
3697        struct ia_css_dvs2_coefficients dvs2_coefs;
3698
3699        if (!coefs || !cur)
3700                return 0;
3701
3702        if (!from_user && css_param->update_flag.dvs2_coefs)
3703                return 0;
3704
3705        if (!IS_ISP2401) {
3706                if (sizeof(*cur) != sizeof(coefs->grid) ||
3707                    memcmp(&coefs->grid, cur, sizeof(coefs->grid))) {
3708                        dev_err(asd->isp->dev, "dvs grid mis-match!\n");
3709                        /* If the grid info in the argument differs from the current
3710                        grid info, we tell the caller to reset the grid size and
3711                        try again. */
3712                        return -EAGAIN;
3713                }
3714
3715                if (!coefs->hor_coefs.odd_real ||
3716                    !coefs->hor_coefs.odd_imag ||
3717                    !coefs->hor_coefs.even_real ||
3718                    !coefs->hor_coefs.even_imag ||
3719                    !coefs->ver_coefs.odd_real ||
3720                    !coefs->ver_coefs.odd_imag ||
3721                    !coefs->ver_coefs.even_real ||