diff options
Diffstat (limited to 'drivers/media/video/omap3isp/ispstat.c')
| -rw-r--r-- | drivers/media/video/omap3isp/ispstat.c | 1102 |
1 files changed, 0 insertions, 1102 deletions
diff --git a/drivers/media/video/omap3isp/ispstat.c b/drivers/media/video/omap3isp/ispstat.c deleted file mode 100644 index b8640be..0000000 --- a/drivers/media/video/omap3isp/ispstat.c +++ /dev/null @@ -1,1102 +0,0 @@ -/* - * ispstat.c - * - * TI OMAP3 ISP - Statistics core - * - * Copyright (C) 2010 Nokia Corporation - * Copyright (C) 2009 Texas Instruments, Inc - * - * Contacts: David Cohen <dacohen@gmail.com> - * Laurent Pinchart <laurent.pinchart@ideasonboard.com> - * Sakari Ailus <sakari.ailus@iki.fi> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA - * 02110-1301 USA - */ - -#include <linux/dma-mapping.h> -#include <linux/slab.h> -#include <linux/uaccess.h> - -#include "isp.h" - -#define IS_COHERENT_BUF(stat) ((stat)->dma_ch >= 0) - -/* - * MAGIC_SIZE must always be the greatest common divisor of - * AEWB_PACKET_SIZE and AF_PAXEL_SIZE. - */ -#define MAGIC_SIZE 16 -#define MAGIC_NUM 0x55 - -/* HACK: AF module seems to be writing one more paxel data than it should. */ -#define AF_EXTRA_DATA OMAP3ISP_AF_PAXEL_SIZE - -/* - * HACK: H3A modules go to an invalid state after have a SBL overflow. It makes - * the next buffer to start to be written in the same point where the overflow - * occurred instead of the configured address. The only known way to make it to - * go back to a valid state is having a valid buffer processing. Of course it - * requires at least a doubled buffer size to avoid an access to invalid memory - * region. But it does not fix everything. It may happen more than one - * consecutive SBL overflows. In that case, it might be unpredictable how many - * buffers the allocated memory should fit. For that case, a recover - * configuration was created. It produces the minimum buffer size for each H3A - * module and decrease the change for more SBL overflows. This recover state - * will be enabled every time a SBL overflow occur. As the output buffer size - * isn't big, it's possible to have an extra size able to fit many recover - * buffers making it extreamily unlikely to have an access to invalid memory - * region. - */ -#define NUM_H3A_RECOVER_BUFS 10 - -/* - * HACK: Because of HW issues the generic layer sometimes need to have - * different behaviour for different statistic modules. - */ -#define IS_H3A_AF(stat) ((stat) == &(stat)->isp->isp_af) -#define IS_H3A_AEWB(stat) ((stat) == &(stat)->isp->isp_aewb) -#define IS_H3A(stat) (IS_H3A_AF(stat) || IS_H3A_AEWB(stat)) - -static void __isp_stat_buf_sync_magic(struct ispstat *stat, - struct ispstat_buffer *buf, - u32 buf_size, enum dma_data_direction dir, - void (*dma_sync)(struct device *, - dma_addr_t, unsigned long, size_t, - enum dma_data_direction)) -{ - struct device *dev = stat->isp->dev; - struct page *pg; - dma_addr_t dma_addr; - u32 offset; - - /* Initial magic words */ - pg = vmalloc_to_page(buf->virt_addr); - dma_addr = pfn_to_dma(dev, page_to_pfn(pg)); - dma_sync(dev, dma_addr, 0, MAGIC_SIZE, dir); - - /* Final magic words */ - pg = vmalloc_to_page(buf->virt_addr + buf_size); - dma_addr = pfn_to_dma(dev, page_to_pfn(pg)); - offset = ((u32)buf->virt_addr + buf_size) & ~PAGE_MASK; - dma_sync(dev, dma_addr, offset, MAGIC_SIZE, dir); -} - -static void isp_stat_buf_sync_magic_for_device(struct ispstat *stat, - struct ispstat_buffer *buf, - u32 buf_size, - enum dma_data_direction dir) -{ - if (IS_COHERENT_BUF(stat)) - return; - - __isp_stat_buf_sync_magic(stat, buf, buf_size, dir, - dma_sync_single_range_for_device); -} - -static void isp_stat_buf_sync_magic_for_cpu(struct ispstat *stat, - struct ispstat_buffer *buf, - u32 buf_size, - enum dma_data_direction dir) -{ - if (IS_COHERENT_BUF(stat)) - return; - - __isp_stat_buf_sync_magic(stat, buf, buf_size, dir, - dma_sync_single_range_for_cpu); -} - -static int isp_stat_buf_check_magic(struct ispstat *stat, - struct ispstat_buffer *buf) -{ - const u32 buf_size = IS_H3A_AF(stat) ? - buf->buf_size + AF_EXTRA_DATA : buf->buf_size; - u8 *w; - u8 *end; - int ret = -EINVAL; - - isp_stat_buf_sync_magic_for_cpu(stat, buf, buf_size, DMA_FROM_DEVICE); - - /* Checking initial magic numbers. They shouldn't be here anymore. */ - for (w = buf->virt_addr, end = w + MAGIC_SIZE; w < end; w++) - if (likely(*w != MAGIC_NUM)) - ret = 0; - - if (ret) { - dev_dbg(stat->isp->dev, "%s: beginning magic check does not " - "match.\n", stat->subdev.name); - return ret; - } - - /* Checking magic numbers at the end. They must be still here. */ - for (w = buf->virt_addr + buf_size, end = w + MAGIC_SIZE; - w < end; w++) { - if (unlikely(*w != MAGIC_NUM)) { - dev_dbg(stat->isp->dev, "%s: endding magic check does " - "not match.\n", stat->subdev.name); - return -EINVAL; - } - } - - isp_stat_buf_sync_magic_for_device(stat, buf, buf_size, - DMA_FROM_DEVICE); - - return 0; -} - -static void isp_stat_buf_insert_magic(struct ispstat *stat, - struct ispstat_buffer *buf) -{ - const u32 buf_size = IS_H3A_AF(stat) ? - stat->buf_size + AF_EXTRA_DATA : stat->buf_size; - - isp_stat_buf_sync_magic_for_cpu(stat, buf, buf_size, DMA_FROM_DEVICE); - - /* - * Inserting MAGIC_NUM at the beginning and end of the buffer. - * buf->buf_size is set only after the buffer is queued. For now the - * right buf_size for the current configuration is pointed by - * stat->buf_size. - */ - memset(buf->virt_addr, MAGIC_NUM, MAGIC_SIZE); - memset(buf->virt_addr + buf_size, MAGIC_NUM, MAGIC_SIZE); - - isp_stat_buf_sync_magic_for_device(stat, buf, buf_size, - DMA_BIDIRECTIONAL); -} - -static void isp_stat_buf_sync_for_device(struct ispstat *stat, - struct ispstat_buffer *buf) -{ - if (IS_COHERENT_BUF(stat)) - return; - - dma_sync_sg_for_device(stat->isp->dev, buf->iovm->sgt->sgl, - buf->iovm->sgt->nents, DMA_FROM_DEVICE); -} - -static void isp_stat_buf_sync_for_cpu(struct ispstat *stat, - struct ispstat_buffer *buf) -{ - if (IS_COHERENT_BUF(stat)) - return; - - dma_sync_sg_for_cpu(stat->isp->dev, buf->iovm->sgt->sgl, - buf->iovm->sgt->nents, DMA_FROM_DEVICE); -} - -static void isp_stat_buf_clear(struct ispstat *stat) -{ - int i; - - for (i = 0; i < STAT_MAX_BUFS; i++) - stat->buf[i].empty = 1; -} - -static struct ispstat_buffer * -__isp_stat_buf_find(struct ispstat *stat, int look_empty) -{ - struct ispstat_buffer *found = NULL; - int i; - - for (i = 0; i < STAT_MAX_BUFS; i++) { - struct ispstat_buffer *curr = &stat->buf[i]; - - /* - * Don't select the buffer which is being copied to - * userspace or used by the module. - */ - if (curr == stat->locked_buf || curr == stat->active_buf) - continue; - - /* Don't select uninitialised buffers if it's not required */ - if (!look_empty && curr->empty) - continue; - - /* Pick uninitialised buffer over anything else if look_empty */ - if (curr->empty) { - found = curr; - break; - } - - /* Choose the oldest buffer */ - if (!found || - (s32)curr->frame_number - (s32)found->frame_number < 0) - found = curr; - } - - return found; -} - -static inline struct ispstat_buffer * -isp_stat_buf_find_oldest(struct ispstat *stat) -{ - return __isp_stat_buf_find(stat, 0); -} - -static inline struct ispstat_buffer * -isp_stat_buf_find_oldest_or_empty(struct ispstat *stat) -{ - return __isp_stat_buf_find(stat, 1); -} - -static int isp_stat_buf_queue(struct ispstat *stat) -{ - if (!stat->active_buf) - return STAT_NO_BUF; - - do_gettimeofday(&stat->active_buf->ts); - - stat->active_buf->buf_size = stat->buf_size; - if (isp_stat_buf_check_magic(stat, stat->active_buf)) { - dev_dbg(stat->isp->dev, "%s: data wasn't properly written.\n", - stat->subdev.name); - return STAT_NO_BUF; - } - stat->active_buf->config_counter = stat->config_counter; - stat->active_buf->frame_number = stat->frame_number; - stat->active_buf->empty = 0; - stat->active_buf = NULL; - - return STAT_BUF_DONE; -} - -/* Get next free buffer to write the statistics to and mark it active. */ -static void isp_stat_buf_next(struct ispstat *stat) -{ - if (unlikely(stat->active_buf)) - /* Overwriting unused active buffer */ - dev_dbg(stat->isp->dev, "%s: new buffer requested without " - "queuing active one.\n", - stat->subdev.name); - else - stat->active_buf = isp_stat_buf_find_oldest_or_empty(stat); -} - -static void isp_stat_buf_release(struct ispstat *stat) -{ - unsigned long flags; - - isp_stat_buf_sync_for_device(stat, stat->locked_buf); - spin_lock_irqsave(&stat->isp->stat_lock, flags); - stat->locked_buf = NULL; - spin_unlock_irqrestore(&stat->isp->stat_lock, flags); -} - -/* Get buffer to userspace. */ -static struct ispstat_buffer *isp_stat_buf_get(struct ispstat *stat, - struct omap3isp_stat_data *data) -{ - int rval = 0; - unsigned long flags; - struct ispstat_buffer *buf; - - spin_lock_irqsave(&stat->isp->stat_lock, flags); - - while (1) { - buf = isp_stat_buf_find_oldest(stat); - if (!buf) { - spin_unlock_irqrestore(&stat->isp->stat_lock, flags); - dev_dbg(stat->isp->dev, "%s: cannot find a buffer.\n", - stat->subdev.name); - return ERR_PTR(-EBUSY); - } - if (isp_stat_buf_check_magic(stat, buf)) { - dev_dbg(stat->isp->dev, "%s: current buffer has " - "corrupted data\n.", stat->subdev.name); - /* Mark empty because it doesn't have valid data. */ - buf->empty = 1; - } else { - /* Buffer isn't corrupted. */ - break; - } - } - - stat->locked_buf = buf; - - spin_unlock_irqrestore(&stat->isp->stat_lock, flags); - - if (buf->buf_size > data->buf_size) { - dev_warn(stat->isp->dev, "%s: userspace's buffer size is " - "not enough.\n", stat->subdev.name); - isp_stat_buf_release(stat); - return ERR_PTR(-EINVAL); - } - - isp_stat_buf_sync_for_cpu(stat, buf); - - rval = copy_to_user(data->buf, - buf->virt_addr, - buf->buf_size); - - if (rval) { - dev_info(stat->isp->dev, - "%s: failed copying %d bytes of stat data\n", - stat->subdev.name, rval); - buf = ERR_PTR(-EFAULT); - isp_stat_buf_release(stat); - } - - return buf; -} - -static void isp_stat_bufs_free(struct ispstat *stat) -{ - struct isp_device *isp = stat->isp; - int i; - - for (i = 0; i < STAT_MAX_BUFS; i++) { - struct ispstat_buffer *buf = &stat->buf[i]; - - if (!IS_COHERENT_BUF(stat)) { - if (IS_ERR_OR_NULL((void *)buf->iommu_addr)) - continue; - if (buf->iovm) - dma_unmap_sg(isp->dev, buf->iovm->sgt->sgl, - buf->iovm->sgt->nents, - DMA_FROM_DEVICE); - omap_iommu_vfree(isp->domain, isp->dev, - buf->iommu_addr); - } else { - if (!buf->virt_addr) - continue; - dma_free_coherent(stat->isp->dev, stat->buf_alloc_size, - buf->virt_addr, buf->dma_addr); - } - buf->iommu_addr = 0; - buf->iovm = NULL; - buf->dma_addr = 0; - buf->virt_addr = NULL; - buf->empty = 1; - } - - dev_dbg(stat->isp->dev, "%s: all buffers were freed.\n", - stat->subdev.name); - - stat->buf_alloc_size = 0; - stat->active_buf = NULL; -} - -static int isp_stat_bufs_alloc_iommu(struct ispstat *stat, unsigned int size) -{ - struct isp_device *isp = stat->isp; - int i; - - stat->buf_alloc_size = size; - - for (i = 0; i < STAT_MAX_BUFS; i++) { - struct ispstat_buffer *buf = &stat->buf[i]; - struct iovm_struct *iovm; - - WARN_ON(buf->dma_addr); - buf->iommu_addr = omap_iommu_vmalloc(isp->domain, isp->dev, 0, - size, IOMMU_FLAG); - if (IS_ERR((void *)buf->iommu_addr)) { - dev_err(stat->isp->dev, - "%s: Can't acquire memory for " - "buffer %d\n", stat->subdev.name, i); - isp_stat_bufs_free(stat); - return -ENOMEM; - } - - iovm = omap_find_iovm_area(isp->dev, buf->iommu_addr); - if (!iovm || - !dma_map_sg(isp->dev, iovm->sgt->sgl, iovm->sgt->nents, - DMA_FROM_DEVICE)) { - isp_stat_bufs_free(stat); - return -ENOMEM; - } - buf->iovm = iovm; - - buf->virt_addr = omap_da_to_va(stat->isp->dev, - (u32)buf->iommu_addr); - buf->empty = 1; - dev_dbg(stat->isp->dev, "%s: buffer[%d] allocated." - "iommu_addr=0x%08lx virt_addr=0x%08lx", - stat->subdev.name, i, buf->iommu_addr, - (unsigned long)buf->virt_addr); - } - - return 0; -} - -static int isp_stat_bufs_alloc_dma(struct ispstat *stat, unsigned int size) -{ - int i; - - stat->buf_alloc_size = size; - - for (i = 0; i < STAT_MAX_BUFS; i++) { - struct ispstat_buffer *buf = &stat->buf[i]; - - WARN_ON(buf->iommu_addr); - buf->virt_addr = dma_alloc_coherent(stat->isp->dev, size, - &buf->dma_addr, GFP_KERNEL | GFP_DMA); - - if (!buf->virt_addr || !buf->dma_addr) { - dev_info(stat->isp->dev, - "%s: Can't acquire memory for " - "DMA buffer %d\n", stat->subdev.name, i); - isp_stat_bufs_free(stat); - return -ENOMEM; - } - buf->empty = 1; - - dev_dbg(stat->isp->dev, "%s: buffer[%d] allocated." - "dma_addr=0x%08lx virt_addr=0x%08lx\n", - stat->subdev.name, i, (unsigned long)buf->dma_addr, - (unsigned long)buf->virt_addr); - } - - return 0; -} - -static int isp_stat_bufs_alloc(struct ispstat *stat, u32 size) -{ - unsigned long flags; - - spin_lock_irqsave(&stat->isp->stat_lock, flags); - - BUG_ON(stat->locked_buf != NULL); - - /* Are the old buffers big enough? */ - if (stat->buf_alloc_size >= size) { - spin_unlock_irqrestore(&stat->isp->stat_lock, flags); - return 0; - } - - if (stat->state != ISPSTAT_DISABLED || stat->buf_processing) { - dev_info(stat->isp->dev, - "%s: trying to allocate memory when busy\n", - stat->subdev.name); - spin_unlock_irqrestore(&stat->isp->stat_lock, flags); - return -EBUSY; - } - - spin_unlock_irqrestore(&stat->isp->stat_lock, flags); - - isp_stat_bufs_free(stat); - - if (IS_COHERENT_BUF(stat)) - return isp_stat_bufs_alloc_dma(stat, size); - else - return isp_stat_bufs_alloc_iommu(stat, size); -} - -static void isp_stat_queue_event(struct ispstat *stat, int err) -{ - struct video_device *vdev = stat->subdev.devnode; - struct v4l2_event event; - struct omap3isp_stat_event_status *status = (void *)event.u.data; - - memset(&event, 0, sizeof(event)); - if (!err) { - status->frame_number = stat->frame_number; - status->config_counter = stat->config_counter; - } else { - status->buf_err = 1; - } - event.type = stat->event_type; - v4l2_event_queue(vdev, &event); -} - - -/* - * omap3isp_stat_request_statistics - Request statistics. - * @data: Pointer to return statistics data. - * - * Returns 0 if successful. - */ -int omap3isp_stat_request_statistics(struct ispstat *stat, - struct omap3isp_stat_data *data) -{ - struct ispstat_buffer *buf; - - if (stat->state != ISPSTAT_ENABLED) { - dev_dbg(stat->isp->dev, "%s: engine not enabled.\n", - stat->subdev.name); - return -EINVAL; - } - - mutex_lock(&stat->ioctl_lock); - buf = isp_stat_buf_get(stat, data); - if (IS_ERR(buf)) { - mutex_unlock(&stat->ioctl_lock); - return PTR_ERR(buf); - } - - data->ts = buf->ts; - data->config_counter = buf->config_counter; - data->frame_number = buf->frame_number; - data->buf_size = buf->buf_size; - - buf->empty = 1; - isp_stat_buf_release(stat); - mutex_unlock(&stat->ioctl_lock); - - return 0; -} - -/* - * omap3isp_stat_config - Receives new statistic engine configuration. - * @new_conf: Pointer to config structure. - * - * Returns 0 if successful, -EINVAL if new_conf pointer is NULL, -ENOMEM if - * was unable to allocate memory for the buffer, or other errors if parameters - * are invalid. - */ -int omap3isp_stat_config(struct ispstat *stat, void *new_conf) -{ - int ret; - unsigned long irqflags; - struct ispstat_generic_config *user_cfg = new_conf; - u32 buf_size = user_cfg->buf_size; - - if (!new_conf) { - dev_dbg(stat->isp->dev, "%s: configuration is NULL\n", - stat->subdev.name); - return -EINVAL; - } - - mutex_lock(&stat->ioctl_lock); - - dev_dbg(stat->isp->dev, "%s: configuring module with buffer " - "size=0x%08lx\n", stat->subdev.name, (unsigned long)buf_size); - - ret = stat->ops->validate_params(stat, new_conf); - if (ret) { - mutex_unlock(&stat->ioctl_lock); - dev_dbg(stat->isp->dev, "%s: configuration values are " - "invalid.\n", stat->subdev.name); - return ret; - } - - if (buf_size != user_cfg->buf_size) - dev_dbg(stat->isp->dev, "%s: driver has corrected buffer size " - "request to 0x%08lx\n", stat->subdev.name, - (unsigned long)user_cfg->buf_size); - - /* - * Hack: H3A modules may need a doubled buffer size to avoid access - * to a invalid memory address after a SBL overflow. - * The buffer size is always PAGE_ALIGNED. - * Hack 2: MAGIC_SIZE is added to buf_size so a magic word can be - * inserted at the end to data integrity check purpose. - * Hack 3: AF module writes one paxel data more than it should, so - * the buffer allocation must consider it to avoid invalid memory - * access. - * Hack 4: H3A need to allocate extra space for the recover state. - */ - if (IS_H3A(stat)) { - buf_size = user_cfg->buf_size * 2 + MAGIC_SIZE; - if (IS_H3A_AF(stat)) - /* - * Adding one extra paxel data size for each recover - * buffer + 2 regular ones. - */ - buf_size += AF_EXTRA_DATA * (NUM_H3A_RECOVER_BUFS + 2); - if (stat->recover_priv) { - struct ispstat_generic_config *recover_cfg = - stat->recover_priv; - buf_size += recover_cfg->buf_size * - NUM_H3A_RECOVER_BUFS; - } - buf_size = PAGE_ALIGN(buf_size); - } else { /* Histogram */ - buf_size = PAGE_ALIGN(user_cfg->buf_size + MAGIC_SIZE); - } - - ret = isp_stat_bufs_alloc(stat, buf_size); - if (ret) { - mutex_unlock(&stat->ioctl_lock); - return ret; - } - - spin_lock_irqsave(&stat->isp->stat_lock, irqflags); - stat->ops->set_params(stat, new_conf); - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - - /* - * Returning the right future config_counter for this setup, so - * userspace can *know* when it has been applied. - */ - user_cfg->config_counter = stat->config_counter + stat->inc_config; - - /* Module has a valid configuration. */ - stat->configured = 1; - dev_dbg(stat->isp->dev, "%s: module has been successfully " - "configured.\n", stat->subdev.name); - - mutex_unlock(&stat->ioctl_lock); - - return 0; -} - -/* - * isp_stat_buf_process - Process statistic buffers. - * @buf_state: points out if buffer is ready to be processed. It's necessary - * because histogram needs to copy the data from internal memory - * before be able to process the buffer. - */ -static int isp_stat_buf_process(struct ispstat *stat, int buf_state) -{ - int ret = STAT_NO_BUF; - - if (!atomic_add_unless(&stat->buf_err, -1, 0) && - buf_state == STAT_BUF_DONE && stat->state == ISPSTAT_ENABLED) { - ret = isp_stat_buf_queue(stat); - isp_stat_buf_next(stat); - } - - return ret; -} - -int omap3isp_stat_pcr_busy(struct ispstat *stat) -{ - return stat->ops->busy(stat); -} - -int omap3isp_stat_busy(struct ispstat *stat) -{ - return omap3isp_stat_pcr_busy(stat) | stat->buf_processing | - (stat->state != ISPSTAT_DISABLED); -} - -/* - * isp_stat_pcr_enable - Disables/Enables statistic engines. - * @pcr_enable: 0/1 - Disables/Enables the engine. - * - * Must be called from ISP driver when the module is idle and synchronized - * with CCDC. - */ -static void isp_stat_pcr_enable(struct ispstat *stat, u8 pcr_enable) -{ - if ((stat->state != ISPSTAT_ENABLING && - stat->state != ISPSTAT_ENABLED) && pcr_enable) - /* Userspace has disabled the module. Aborting. */ - return; - - stat->ops->enable(stat, pcr_enable); - if (stat->state == ISPSTAT_DISABLING && !pcr_enable) - stat->state = ISPSTAT_DISABLED; - else if (stat->state == ISPSTAT_ENABLING && pcr_enable) - stat->state = ISPSTAT_ENABLED; -} - -void omap3isp_stat_suspend(struct ispstat *stat) -{ - unsigned long flags; - - spin_lock_irqsave(&stat->isp->stat_lock, flags); - - if (stat->state != ISPSTAT_DISABLED) - stat->ops->enable(stat, 0); - if (stat->state == ISPSTAT_ENABLED) - stat->state = ISPSTAT_SUSPENDED; - - spin_unlock_irqrestore(&stat->isp->stat_lock, flags); -} - -void omap3isp_stat_resume(struct ispstat *stat) -{ - /* Module will be re-enabled with its pipeline */ - if (stat->state == ISPSTAT_SUSPENDED) - stat->state = ISPSTAT_ENABLING; -} - -static void isp_stat_try_enable(struct ispstat *stat) -{ - unsigned long irqflags; - - if (stat->priv == NULL) - /* driver wasn't initialised */ - return; - - spin_lock_irqsave(&stat->isp->stat_lock, irqflags); - if (stat->state == ISPSTAT_ENABLING && !stat->buf_processing && - stat->buf_alloc_size) { - /* - * Userspace's requested to enable the engine but it wasn't yet. - * Let's do that now. - */ - stat->update = 1; - isp_stat_buf_next(stat); - stat->ops->setup_regs(stat, stat->priv); - isp_stat_buf_insert_magic(stat, stat->active_buf); - - /* - * H3A module has some hw issues which forces the driver to - * ignore next buffers even if it was disabled in the meantime. - * On the other hand, Histogram shouldn't ignore buffers anymore - * if it's being enabled. - */ - if (!IS_H3A(stat)) - atomic_set(&stat->buf_err, 0); - - isp_stat_pcr_enable(stat, 1); - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - dev_dbg(stat->isp->dev, "%s: module is enabled.\n", - stat->subdev.name); - } else { - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - } -} - -void omap3isp_stat_isr_frame_sync(struct ispstat *stat) -{ - isp_stat_try_enable(stat); -} - -void omap3isp_stat_sbl_overflow(struct ispstat *stat) -{ - unsigned long irqflags; - - spin_lock_irqsave(&stat->isp->stat_lock, irqflags); - /* - * Due to a H3A hw issue which prevents the next buffer to start from - * the correct memory address, 2 buffers must be ignored. - */ - atomic_set(&stat->buf_err, 2); - - /* - * If more than one SBL overflow happen in a row, H3A module may access - * invalid memory region. - * stat->sbl_ovl_recover is set to tell to the driver to temporarily use - * a soft configuration which helps to avoid consecutive overflows. - */ - if (stat->recover_priv) - stat->sbl_ovl_recover = 1; - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); -} - -/* - * omap3isp_stat_enable - Disable/Enable statistic engine as soon as possible - * @enable: 0/1 - Disables/Enables the engine. - * - * Client should configure all the module registers before this. - * This function can be called from a userspace request. - */ -int omap3isp_stat_enable(struct ispstat *stat, u8 enable) -{ - unsigned long irqflags; - - dev_dbg(stat->isp->dev, "%s: user wants to %s module.\n", - stat->subdev.name, enable ? "enable" : "disable"); - - /* Prevent enabling while configuring */ - mutex_lock(&stat->ioctl_lock); - - spin_lock_irqsave(&stat->isp->stat_lock, irqflags); - - if (!stat->configured && enable) { - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - mutex_unlock(&stat->ioctl_lock); - dev_dbg(stat->isp->dev, "%s: cannot enable module as it's " - "never been successfully configured so far.\n", - stat->subdev.name); - return -EINVAL; - } - - if (enable) { - if (stat->state == ISPSTAT_DISABLING) - /* Previous disabling request wasn't done yet */ - stat->state = ISPSTAT_ENABLED; - else if (stat->state == ISPSTAT_DISABLED) - /* Module is now being enabled */ - stat->state = ISPSTAT_ENABLING; - } else { - if (stat->state == ISPSTAT_ENABLING) { - /* Previous enabling request wasn't done yet */ - stat->state = ISPSTAT_DISABLED; - } else if (stat->state == ISPSTAT_ENABLED) { - /* Module is now being disabled */ - stat->state = ISPSTAT_DISABLING; - isp_stat_buf_clear(stat); - } - } - - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - mutex_unlock(&stat->ioctl_lock); - - return 0; -} - -int omap3isp_stat_s_stream(struct v4l2_subdev *subdev, int enable) -{ - struct ispstat *stat = v4l2_get_subdevdata(subdev); - - if (enable) { - /* - * Only set enable PCR bit if the module was previously - * enabled through ioct. - */ - isp_stat_try_enable(stat); - } else { - unsigned long flags; - /* Disable PCR bit and config enable field */ - omap3isp_stat_enable(stat, 0); - spin_lock_irqsave(&stat->isp->stat_lock, flags); - stat->ops->enable(stat, 0); - spin_unlock_irqrestore(&stat->isp->stat_lock, flags); - - /* - * If module isn't busy, a new interrupt may come or not to - * set the state to DISABLED. As Histogram needs to read its - * internal memory to clear it, let interrupt handler - * responsible of changing state to DISABLED. If the last - * interrupt is coming, it's still safe as the handler will - * ignore the second time when state is already set to DISABLED. - * It's necessary to synchronize Histogram with streamoff, once - * the module may be considered idle before last SDMA transfer - * starts if we return here. - */ - if (!omap3isp_stat_pcr_busy(stat)) - omap3isp_stat_isr(stat); - - dev_dbg(stat->isp->dev, "%s: module is being disabled\n", - stat->subdev.name); - } - - return 0; -} - -/* - * __stat_isr - Interrupt handler for statistic drivers - */ -static void __stat_isr(struct ispstat *stat, int from_dma) -{ - int ret = STAT_BUF_DONE; - int buf_processing; - unsigned long irqflags; - struct isp_pipeline *pipe; - - /* - * stat->buf_processing must be set before disable module. It's - * necessary to not inform too early the buffers aren't busy in case - * of SDMA is going to be used. - */ - spin_lock_irqsave(&stat->isp->stat_lock, irqflags); - if (stat->state == ISPSTAT_DISABLED) { - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - return; - } - buf_processing = stat->buf_processing; - stat->buf_processing = 1; - stat->ops->enable(stat, 0); - - if (buf_processing && !from_dma) { - if (stat->state == ISPSTAT_ENABLED) { - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - dev_err(stat->isp->dev, - "%s: interrupt occurred when module was still " - "processing a buffer.\n", stat->subdev.name); - ret = STAT_NO_BUF; - goto out; - } else { - /* - * Interrupt handler was called from streamoff when - * the module wasn't busy anymore to ensure it is being - * disabled after process last buffer. If such buffer - * processing has already started, no need to do - * anything else. - */ - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - return; - } - } - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - - /* If it's busy we can't process this buffer anymore */ - if (!omap3isp_stat_pcr_busy(stat)) { - if (!from_dma && stat->ops->buf_process) - /* Module still need to copy data to buffer. */ - ret = stat->ops->buf_process(stat); - if (ret == STAT_BUF_WAITING_DMA) - /* Buffer is not ready yet */ - return; - - spin_lock_irqsave(&stat->isp->stat_lock, irqflags); - - /* - * Histogram needs to read its internal memory to clear it - * before be disabled. For that reason, common statistic layer - * can return only after call stat's buf_process() operator. - */ - if (stat->state == ISPSTAT_DISABLING) { - stat->state = ISPSTAT_DISABLED; - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - stat->buf_processing = 0; - return; - } - pipe = to_isp_pipeline(&stat->subdev.entity); - stat->frame_number = atomic_read(&pipe->frame_number); - - /* - * Before this point, 'ret' stores the buffer's status if it's - * ready to be processed. Afterwards, it holds the status if - * it was processed successfully. - */ - ret = isp_stat_buf_process(stat, ret); - - if (likely(!stat->sbl_ovl_recover)) { - stat->ops->setup_regs(stat, stat->priv); - } else { - /* - * Using recover config to increase the chance to have - * a good buffer processing and make the H3A module to - * go back to a valid state. - */ - stat->update = 1; - stat->ops->setup_regs(stat, stat->recover_priv); - stat->sbl_ovl_recover = 0; - - /* - * Set 'update' in case of the module needs to use - * regular configuration after next buffer. - */ - stat->update = 1; - } - - isp_stat_buf_insert_magic(stat, stat->active_buf); - - /* - * Hack: H3A modules may access invalid memory address or send - * corrupted data to userspace if more than 1 SBL overflow - * happens in a row without re-writing its buffer's start memory - * address in the meantime. Such situation is avoided if the - * module is not immediately re-enabled when the ISR misses the - * timing to process the buffer and to setup the registers. - * Because of that, pcr_enable(1) was moved to inside this 'if' - * block. But the next interruption will still happen as during - * pcr_enable(0) the module was busy. - */ - isp_stat_pcr_enable(stat, 1); - spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); - } else { - /* - * If a SBL overflow occurs and the H3A driver misses the timing - * to process the buffer, stat->buf_err is set and won't be - * cleared now. So the next buffer will be correctly ignored. - * It's necessary due to a hw issue which makes the next H3A - * buffer to start from the memory address where the previous - * one stopped, instead of start where it was configured to. - * Do not "stat->buf_err = 0" here. - */ - - if (stat->ops->buf_process) - /* - * Driver may need to erase current data prior to - * process a new buffer. If it misses the timing, the - * next buffer might be wrong. So should be ignored. - * It happens only for Histogram. - */ - atomic_set(&stat->buf_err, 1); - - ret = STAT_NO_BUF; - dev_dbg(stat->isp->dev, "%s: cannot process buffer, " - "device is busy.\n", stat->subdev.name); - } - -out: - stat->buf_processing = 0; - isp_stat_queue_event(stat, ret != STAT_BUF_DONE); -} - -void omap3isp_stat_isr(struct ispstat *stat) -{ - __stat_isr(stat, 0); -} - -void omap3isp_stat_dma_isr(struct ispstat *stat) -{ - __stat_isr(stat, 1); -} - -int omap3isp_stat_subscribe_event(struct v4l2_subdev *subdev, - struct v4l2_fh *fh, - struct v4l2_event_subscription *sub) -{ - struct ispstat *stat = v4l2_get_subdevdata(subdev); - - if (sub->type != stat->event_type) - return -EINVAL; - - return v4l2_event_subscribe(fh, sub, STAT_NEVENTS, NULL); -} - -int omap3isp_stat_unsubscribe_event(struct v4l2_subdev *subdev, - struct v4l2_fh *fh, - struct v4l2_event_subscription *sub) -{ - return v4l2_event_unsubscribe(fh, sub); -} - -void omap3isp_stat_unregister_entities(struct ispstat *stat) -{ - v4l2_device_unregister_subdev(&stat->subdev); -} - -int omap3isp_stat_register_entities(struct ispstat *stat, - struct v4l2_device *vdev) -{ - return v4l2_device_register_subdev(vdev, &stat->subdev); -} - -static int isp_stat_init_entities(struct ispstat *stat, const char *name, - const struct v4l2_subdev_ops *sd_ops) -{ - struct v4l2_subdev *subdev = &stat->subdev; - struct media_entity *me = &subdev->entity; - - v4l2_subdev_init(subdev, sd_ops); - snprintf(subdev->name, V4L2_SUBDEV_NAME_SIZE, "OMAP3 ISP %s", name); - subdev->grp_id = 1 << 16; /* group ID for isp subdevs */ - subdev->flags |= V4L2_SUBDEV_FL_HAS_EVENTS | V4L2_SUBDEV_FL_HAS_DEVNODE; - v4l2_set_subdevdata(subdev, stat); - - stat->pad.flags = MEDIA_PAD_FL_SINK; - me->ops = NULL; - - return media_entity_init(me, 1, &stat->pad, 0); -} - -int omap3isp_stat_init(struct ispstat *stat, const char *name, - const struct v4l2_subdev_ops *sd_ops) -{ - int ret; - - stat->buf = kcalloc(STAT_MAX_BUFS, sizeof(*stat->buf), GFP_KERNEL); - if (!stat->buf) - return -ENOMEM; - - isp_stat_buf_clear(stat); - mutex_init(&stat->ioctl_lock); - atomic_set(&stat->buf_err, 0); - - ret = isp_stat_init_entities(stat, name, sd_ops); - if (ret < 0) { - mutex_destroy(&stat->ioctl_lock); - kfree(stat->buf); - } - - return ret; -} - -void omap3isp_stat_cleanup(struct ispstat *stat) -{ - media_entity_cleanup(&stat->subdev.entity); - mutex_destroy(&stat->ioctl_lock); - isp_stat_bufs_free(stat); - kfree(stat->buf); -} |
