// SPDX-License-Identifier: GPL-2.0-only /* * isp . c * * TI OMAP3 ISP - Core * * Copyright ( C ) 2006 - 2010 Nokia Corporation * Copyright ( C ) 2007 - 2009 Texas Instruments , Inc . * * Contacts : Laurent Pinchart < laurent . pinchart @ ideasonboard . com > * Sakari Ailus < sakari . ailus @ iki . fi > * * Contributors : * Laurent Pinchart < laurent . pinchart @ ideasonboard . com > * Sakari Ailus < sakari . ailus @ iki . fi > * David Cohen < dacohen @ gmail . com > * Stanimir Varbanov < svarbanov @ mm - sol . com > * Vimarsh Zutshi < vimarsh . zutshi @ gmail . com > * Tuukka Toivonen < tuukkat76 @ gmail . com > * Sergio Aguirre < saaguirre @ ti . com > * Antti Koskipaa < akoskipa @ gmail . com > * Ivan T . Ivanov < iivanov @ mm - sol . com > * RaniSuneela < r - m @ ti . com > * Atanas Filipov < afilipov @ mm - sol . com > * Gjorgji Rosikopulos < grosikopulos @ mm - sol . com > * Hiroshi DOYU < hiroshi . doyu @ nokia . com > * Nayden Kanchev < nkanchev @ mm - sol . com > * Phil Carmody < ext - phil . 2 . carmody @ nokia . com > * Artem Bityutskiy < artem . bityutskiy @ nokia . com > * Dominic Curran < dcurran @ ti . com > * Ilkka Myllyperkio < ilkka . myllyperkio @ sofica . fi > * Pallavi Kulkarni < p - kulkarni @ ti . com > * Vaibhav Hiremath < hvaibhav @ ti . com > * Mohit Jalori < mjalori @ ti . com > * Sameer Venkatraman < sameerv @ ti . com > * Senthilvadivu Guruswamy < svadivu @ ti . com > * Thara Gopinath < thara @ ti . com > * Toni Leinonen < toni . leinonen @ nokia . com > * Troy Laramy < t - laramy @ ti . com > #include <linux/clk.h>#include <linux/clkdev.h>#include <linux/delay.h>#include <linux/device.h>#include <linux/dma-mapping.h>#include <linux/i2c.h>#include <linux/interrupt.h>#include <linux/mfd/syscon.h>#include <linux/module.h>#include <linux/omap-iommu.h>#include <linux/platform_device.h>#include <linux/property.h>#include <linux/regulator/consumer.h>#include <linux/slab.h>#include <linux/sched.h>#include <linux/vmalloc.h>#ifdef CONFIG_ARM_DMA_USE_IOMMU#include <asm /dma-iommu.h>#endif #include <media/v4l2-common.h>#include <media/v4l2-fwnode.h>#include <media/v4l2-device.h>#include <media/v4l2-mc.h>#include "isp.h" #include "ispreg.h" #include "ispccdc.h" #include "isppreview.h" #include "ispresizer.h" #include "ispcsi2.h" #include "ispccp2.h" #include "isph3a.h" #include "isphist.h" static unsigned int autoidle;int , 0444 );"Enable OMAP3ISP AUTOIDLE support" );static void isp_save_ctx(struct isp_device *isp);static void isp_restore_ctx(struct isp_device *isp);static const struct isp_res_mapping isp_res_maps[] = {/* first MMIO area */ 0 x0000, /* base, len 0x0070 */ 0 x0400, /* ccp2, len 0x01f0 */ 0 x0600, /* ccdc, len 0x00a8 */ 0 x0a00, /* hist, len 0x0048 */ 0 x0c00, /* h3a, len 0x0060 */ 0 x0e00, /* preview, len 0x00a0 */ 0 x1000, /* resizer, len 0x00ac */ 0 x1200, /* sbl, len 0x00fc */ /* second MMIO area */ 0 x0000, /* csi2a, len 0x0170 */ 0 x0170, /* csiphy2, len 0x000c */ /* first MMIO area */ 0 x0000, /* base, len 0x0070 */ 0 x0400, /* ccp2, len 0x01f0 */ 0 x0600, /* ccdc, len 0x00a8 */ 0 x0a00, /* hist, len 0x0048 */ 0 x0c00, /* h3a, len 0x0060 */ 0 x0e00, /* preview, len 0x00a0 */ 0 x1000, /* resizer, len 0x00ac */ 0 x1200, /* sbl, len 0x00fc */ /* second MMIO area */ 0 x0000, /* csi2a, len 0x0170 (1st area) */ 0 x0170, /* csiphy2, len 0x000c */ 0 x01c0, /* csi2a, len 0x0040 (2nd area) */ 0 x0400, /* csi2c, len 0x0170 (1st area) */ 0 x0570, /* csiphy1, len 0x000c */ 0 x05c0, /* csi2c, len 0x0040 (2nd area) */ /* Structure for saving/restoring ISP module registers */ static struct isp_reg isp_reg_list[] = {0 },0 },0 },0 , ISP_TOK_TERM, 0 }/* * omap3isp_flush - Post pending L3 bus writes by doing a register readback * @ isp : OMAP3 ISP device * * In order to force posting of pending writes , we need to write and * readback the same register , in this case the revision register . * * See this link for reference : * https : //www.mail-archive.com/linux-omap@vger.kernel.org/msg08149.html void omap3isp_flush(struct isp_device *isp)0 , OMAP3_ISP_IOMEM_MAIN, ISP_REVISION);/* ----------------------------------------------------------------------------- * XCLK #define to_isp_xclk(_hw) container_of(_hw, struct isp_xclk, hw)static void isp_xclk_update(struct isp_xclk *xclk, u32 divider)switch (xclk->id) {case ISP_XCLK_A:break ;case ISP_XCLK_B:break ;static int isp_xclk_prepare(struct clk_hw *hw)struct isp_xclk *xclk = to_isp_xclk(hw);return 0 ;static void isp_xclk_unprepare(struct clk_hw *hw)struct isp_xclk *xclk = to_isp_xclk(hw);static int isp_xclk_enable(struct clk_hw *hw)struct isp_xclk *xclk = to_isp_xclk(hw);unsigned long flags;true ;return 0 ;static void isp_xclk_disable(struct clk_hw *hw)struct isp_xclk *xclk = to_isp_xclk(hw);unsigned long flags;0 );false ;static unsigned long isp_xclk_recalc_rate(struct clk_hw *hw,unsigned long parent_rate)struct isp_xclk *xclk = to_isp_xclk(hw);return parent_rate / xclk->divider;static u32 isp_xclk_calc_divider(unsigned long *rate, unsigned long parent_rate)if (*rate >= parent_rate) {return ISPTCTRL_CTRL_DIV_BYPASS;if (*rate == 0 )1 ;if (divider >= ISPTCTRL_CTRL_DIV_BYPASS)1 ;return divider;static long isp_xclk_round_rate(struct clk_hw *hw, unsigned long rate,unsigned long *parent_rate)return rate;static int isp_xclk_set_rate(struct clk_hw *hw, unsigned long rate,unsigned long parent_rate)struct isp_xclk *xclk = to_isp_xclk(hw);unsigned long flags;if (xclk->enabled)"%s: cam_xclk%c set to %lu Hz (div %u)\n" ,'a' : 'b' , rate, divider);return 0 ;static const struct clk_ops isp_xclk_ops = {static const char *isp_xclk_parent_name = "cam_mclk" ;static struct clk *isp_xclk_src_get(struct of_phandle_args *clkspec, void *data)unsigned int idx = clkspec->args[0 ];struct isp_device *isp = data;if (idx >= ARRAY_SIZE(isp->xclks))return ERR_PTR(-ENOENT);return isp->xclks[idx].clk;static int isp_xclk_init(struct isp_device *isp)struct device_node *np = isp->dev->of_node;struct clk_init_data init = {};unsigned int i;for (i = 0 ; i < ARRAY_SIZE(isp->xclks); ++i)for (i = 0 ; i < ARRAY_SIZE(isp->xclks); ++i) {struct isp_xclk *xclk = &isp->xclks[i];0 ? ISP_XCLK_A : ISP_XCLK_B;1 ;0 ? "cam_xclka" : "cam_xclkb" ;1 ;/* * The first argument is NULL in order to avoid circular * reference , as this driver takes reference on the * sensor subdevice modules and the sensors would take * reference on this module through clk_get ( ) . if (IS_ERR(xclk->clk))return PTR_ERR(xclk->clk);if (np)return 0 ;static void isp_xclk_cleanup(struct isp_device *isp)struct device_node *np = isp->dev->of_node;unsigned int i;if (np)for (i = 0 ; i < ARRAY_SIZE(isp->xclks); ++i) {struct isp_xclk *xclk = &isp->xclks[i];if (!IS_ERR(xclk->clk))/* ----------------------------------------------------------------------------- * Interrupts /* * isp_enable_interrupts - Enable ISP interrupts . * @ isp : OMAP3 ISP device static void isp_enable_interrupts(struct isp_device *isp)static const u32 irq = IRQ0ENABLE_CSIA_IRQ/* * isp_disable_interrupts - Disable ISP interrupts . * @ isp : OMAP3 ISP device static void isp_disable_interrupts(struct isp_device *isp)0 , OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0ENABLE);/* * isp_core_init - ISP core settings * @ isp : OMAP3 ISP device * @ idle : Consider idle state . * * Set the power settings for the ISP and SBL bus and configure the HS / VS * interrupt source . * * We need to configure the HS / VS interrupt source before interrupts get * enabled , as the sensor might be free - running and the ISP default setting * ( HS edge ) would put an unnecessary burden on the CPU . static void isp_core_init(struct isp_device *isp, int idle)0 ),0 ) |/* * Configure the bridge and lane shifter . Valid inputs are * * CCDC_INPUT_PARALLEL : Parallel interface * CCDC_INPUT_CSI2A : CSI2a receiver * CCDC_INPUT_CCP2B : CCP2b receiver * CCDC_INPUT_CSI2C : CSI2c receiver * * The bridge and lane shifter are configured according to the selected input * and the ISP platform data . void omap3isp_configure_bridge(struct isp_device *isp,enum ccdc_input_entity input,const struct isp_parallel_cfg *parcfg,unsigned int shift, unsigned int bridge)switch (input) {case CCDC_INPUT_PARALLEL:break ;case CCDC_INPUT_CSI2A:break ;case CCDC_INPUT_CCP2B:break ;case CCDC_INPUT_CSI2C:break ;default :return ;2 ) << ISPCTRL_SHIFT_SHIFT) & ISPCTRL_SHIFT_MASK;void omap3isp_hist_dma_done(struct isp_device *isp)if (omap3isp_ccdc_busy(&isp->isp_ccdc) ||/* Histogram cannot be enabled in this frame anymore */ 1 );"hist: Out of synchronization with CCDC. Ignoring next buffer.\n" );static inline void __maybe_unused isp_isr_dbg(struct isp_device *isp,static const char *name[] = {"CSIA_IRQ" ,"res1" ,"res2" ,"CSIB_LCM_IRQ" ,"CSIB_IRQ" ,"res5" ,"res6" ,"res7" ,"CCDC_VD0_IRQ" ,"CCDC_VD1_IRQ" ,"CCDC_VD2_IRQ" ,"CCDC_ERR_IRQ" ,"H3A_AF_DONE_IRQ" ,"H3A_AWB_DONE_IRQ" ,"res14" ,"res15" ,"HIST_DONE_IRQ" ,"CCDC_LSC_DONE" ,"CCDC_LSC_PREFETCH_COMPLETED" ,"CCDC_LSC_PREFETCH_ERROR" ,"PRV_DONE_IRQ" ,"CBUFF_IRQ" ,"res22" ,"res23" ,"RSZ_DONE_IRQ" ,"OVF_IRQ" ,"res26" ,"res27" ,"MMU_ERR_IRQ" ,"OCP_ERR_IRQ" ,"SEC_ERR_IRQ" ,"HS_VS_IRQ" ,int i;"ISP IRQ: " );for (i = 0 ; i < ARRAY_SIZE(name); i++) {if ((1 << i) & irqstatus)"%s " , name[i]);"\n" );static void isp_isr_sbl(struct isp_device *isp)struct device *dev = isp->dev;struct isp_pipeline *pipe;/* * Handle shared buffer logic overflows for video buffers . * ISPSBL_PCR_CCDCPRV_2_RSZ_OVF can be safely ignored . if (sbl_pcr)"SBL overflow (PCR = 0x%08x)\n" , sbl_pcr);if (sbl_pcr & ISPSBL_PCR_CSIB_WBL_OVF) {if (pipe != NULL)true ;if (sbl_pcr & ISPSBL_PCR_CSIA_WBL_OVF) {if (pipe != NULL)true ;if (sbl_pcr & ISPSBL_PCR_CCDC_WBL_OVF) {if (pipe != NULL)true ;if (sbl_pcr & ISPSBL_PCR_PRV_WBL_OVF) {if (pipe != NULL)true ;if (sbl_pcr & (ISPSBL_PCR_RSZ1_WBL_OVFif (pipe != NULL)true ;if (sbl_pcr & ISPSBL_PCR_H3A_AF_WBL_OVF)if (sbl_pcr & ISPSBL_PCR_H3A_AEAWB_WBL_OVF)/* * isp_isr - Interrupt Service Routine for Camera ISP module . * @ irq : Not used currently . * @ _ isp : Pointer to the OMAP3 ISP device * * Handles the corresponding callback if plugged in . static irqreturn_t isp_isr(int irq, void *_isp)static const u32 ccdc_events = IRQ0STATUS_CCDC_LSC_PREF_ERR_IRQ |struct isp_device *isp = _isp;if (irqstatus & IRQ0STATUS_CSIA_IRQ)if (irqstatus & IRQ0STATUS_CSIB_IRQ)if (irqstatus & IRQ0STATUS_CCDC_VD0_IRQ) {if (isp->isp_ccdc.output & CCDC_OUTPUT_PREVIEW)if (isp->isp_ccdc.output & CCDC_OUTPUT_RESIZER)if (irqstatus & ccdc_events)if (irqstatus & IRQ0STATUS_PRV_DONE_IRQ) {if (isp->isp_prev.output & PREVIEW_OUTPUT_RESIZER)if (irqstatus & IRQ0STATUS_RSZ_DONE_IRQ)if (irqstatus & IRQ0STATUS_H3A_AWB_DONE_IRQ)if (irqstatus & IRQ0STATUS_H3A_AF_DONE_IRQ)if (irqstatus & IRQ0STATUS_HIST_DONE_IRQ)#if defined (DEBUG) && defined (ISP_ISR_DEBUG)#endif return IRQ_HANDLED;static const struct media_device_ops isp_media_ops = {/* ----------------------------------------------------------------------------- * Pipeline stream management /* * isp_pipeline_enable - Enable streaming on a pipeline * @ pipe : ISP pipeline * @ mode : Stream mode ( single shot or continuous ) * * Walk the entities chain starting at the pipeline output video node and start * all modules in the chain in the given mode . * * Return 0 if successful , or the return value of the failed video : : s_stream * operation otherwise . static int isp_pipeline_enable(struct isp_pipeline *pipe,enum isp_pipeline_stream_state mode)struct isp_device *isp = pipe->output->isp;struct media_entity *entity;struct media_pad *pad;struct v4l2_subdev *subdev;unsigned long flags;int ret;/* Refuse to start streaming if an entity included in the pipeline has * crashed . This check must be performed before the loop below to avoid * starting entities if the pipeline won ' t start anyway ( those entities * would then likely fail to stop , making the problem worse ) . if (media_entity_enum_intersects(&pipe->ent_enum, &isp->crashed))return -EIO;false ;while (1 ) {0 ];if (!(pad->flags & MEDIA_PAD_FL_SINK))break ;if (!pad || !is_media_entity_v4l2_subdev(pad->entity))break ;if (ret < 0 && ret != -ENOIOCTLCMD) {return ret;if (subdev == &isp->isp_ccdc.subdev) {true ;/* Stop at the first external sub-device. */ if (subdev->dev != isp->dev)break ;return 0 ;static int isp_pipeline_wait_resizer(struct isp_device *isp)return omap3isp_resizer_busy(&isp->isp_res);static int isp_pipeline_wait_preview(struct isp_device *isp)return omap3isp_preview_busy(&isp->isp_prev);static int isp_pipeline_wait_ccdc(struct isp_device *isp)return omap3isp_stat_busy(&isp->isp_af)#define ISP_STOP_TIMEOUT msecs_to_jiffies(1000 )static int isp_pipeline_wait(struct isp_device *isp,int (*busy)(struct isp_device *isp))unsigned long timeout = jiffies + ISP_STOP_TIMEOUT;while (!time_after(jiffies, timeout)) {if (!busy(isp))return 0 ;return 1 ;/* * isp_pipeline_disable - Disable streaming on a pipeline * @ pipe : ISP pipeline * * Walk the entities chain starting at the pipeline output video node and stop * all modules in the chain . Wait synchronously for the modules to be stopped if * necessary . * * Return 0 if all modules have been properly stopped , or - ETIMEDOUT if a module * can ' t be stopped ( in which case a software reset of the ISP is probably * necessary ) . static int isp_pipeline_disable(struct isp_pipeline *pipe)struct isp_device *isp = pipe->output->isp;struct media_entity *entity;struct media_pad *pad;struct v4l2_subdev *subdev;int failure = 0 ;int ret;/* * We need to stop all the modules after CCDC first or they ' ll * never stop since they may not get a full frame from CCDC . while (1 ) {0 ];if (!(pad->flags & MEDIA_PAD_FL_SINK))break ;if (!pad || !is_media_entity_v4l2_subdev(pad->entity))break ;if (subdev == &isp->isp_ccdc.subdev) {0 );0 );0 );0 );/* Stop at the first external sub-device. */ if (subdev->dev != isp->dev)break ;if (subdev == &isp->isp_res.subdev)else if (subdev == &isp->isp_prev.subdev)else if (subdev == &isp->isp_ccdc.subdev)/* Handle stop failures. An entity that fails to stop can * usually just be restarted . Flag the stop failure nonetheless * to trigger an ISP reset the next time the device is released , * just in case . * * The preview engine is a special case . A failure to stop can * mean a hardware crash . When that happens the preview engine * won ' t respond to read / write operations on the L4 bus anymore , * resulting in a bus fault and a kernel oops next time it gets * accessed . Mark it as crashed to prevent pipelines including * it from being started . if (ret) {"Unable to stop %s\n" , subdev->name);true ;if (subdev == &isp->isp_prev.subdev)return failure;/* * omap3isp_pipeline_set_stream - Enable / disable streaming on a pipeline * @ pipe : ISP pipeline * @ state : Stream state ( stopped , single shot or continuous ) * * Set the pipeline to the given stream state . Pipelines can be started in * single - shot or continuous mode . * * Return 0 if successful , or the return value of the failed video : : s_stream * operation otherwise . The pipeline state is not updated when the operation * fails , except when stopping the pipeline . int omap3isp_pipeline_set_stream(struct isp_pipeline *pipe,enum isp_pipeline_stream_state state)int ret;if (state == ISP_PIPELINE_STREAM_STOPPED)else if (ret == 0 || state == ISP_PIPELINE_STREAM_STOPPED)return ret;/* * omap3isp_pipeline_cancel_stream - Cancel stream on a pipeline * @ pipe : ISP pipeline * * Cancelling a stream mark all buffers on all video nodes in the pipeline as * erroneous and makes sure no new buffer can be queued . This function is called * when a fatal error that prevents any further operation on the pipeline * occurs . void omap3isp_pipeline_cancel_stream(struct isp_pipeline *pipe)if (pipe->input)if (pipe->output)/* * isp_pipeline_resume - Resume streaming on a pipeline * @ pipe : ISP pipeline * * Resume video output and input and re - enable pipeline . static void isp_pipeline_resume(struct isp_pipeline *pipe)int singleshot = pipe->stream_state == ISP_PIPELINE_STREAM_SINGLESHOT;if (singleshot)0 );/* * isp_pipeline_suspend - Suspend streaming on a pipeline * @ pipe : ISP pipeline * * Suspend pipeline . static void isp_pipeline_suspend(struct isp_pipeline *pipe)/* * isp_pipeline_is_last - Verify if entity has an enabled link to the output * video node * @ me : ISP module ' s media entity * * Returns 1 if the entity has an enabled link to the output video node or 0 * otherwise . It ' s true only while pipeline can have no more than one output * node . static int isp_pipeline_is_last(struct media_entity *me)struct isp_pipeline *pipe;struct media_pad *pad;if (!pipe || pipe->stream_state == ISP_PIPELINE_STREAM_STOPPED)return 0 ;return pad->entity == me;/* * isp_suspend_module_pipeline - Suspend pipeline to which belongs the module * @ me : ISP module ' s media entity * * Suspend the whole pipeline if module ' s entity has an enabled link to the * output video node . It works only while pipeline can have no more than one * output node . static void isp_suspend_module_pipeline(struct media_entity *me)if (isp_pipeline_is_last(me))/* * isp_resume_module_pipeline - Resume pipeline to which belongs the module * @ me : ISP module ' s media entity * * Resume the whole pipeline if module ' s entity has an enabled link to the * output video node . It works only while pipeline can have no more than one * output node . static void isp_resume_module_pipeline(struct media_entity *me)if (isp_pipeline_is_last(me))/* * isp_suspend_modules - Suspend ISP submodules . * @ isp : OMAP3 ISP device * * Returns 0 if suspend left in idle state all the submodules properly , * or returns 1 if a general Reset is required to suspend the submodules . static int __maybe_unused isp_suspend_modules(struct isp_device *isp)unsigned long timeout;while (omap3isp_stat_busy(&isp->isp_af)if (time_after(jiffies, timeout)) {"can't stop modules.\n" );return 1 ;1 );return 0 ;/* * isp_resume_modules - Resume ISP submodules . * @ isp : OMAP3 ISP device static void __maybe_unused isp_resume_modules(struct isp_device *isp)/* * isp_reset - Reset ISP with a timeout wait for idle . * @ isp : OMAP3 ISP device static int isp_reset(struct isp_device *isp)unsigned long timeout = 0 ;while (!(isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN,0 x1)) {if (timeout++ > 10000 ) {"cannot reset ISP\n" );return -ETIMEDOUT;1 );false ;return 0 ;/* * isp_save_context - Saves the values of the ISP module registers . * @ isp : OMAP3 ISP device * @ reg_list : Structure containing pairs of register address and value to * modify on OMAP . static void struct isp_device *isp, struct isp_reg *reg_list)struct isp_reg *next = reg_list;for (; next->reg != ISP_TOK_TERM; next++)/* * isp_restore_context - Restores the values of the ISP module registers . * @ isp : OMAP3 ISP device * @ reg_list : Structure containing pairs of register address and value to * modify on OMAP . static void struct isp_device *isp, struct isp_reg *reg_list)struct isp_reg *next = reg_list;for (; next->reg != ISP_TOK_TERM; next++)/* * isp_save_ctx - Saves ISP , CCDC , HIST , H3A , PREV , RESZ & MMU context . * @ isp : OMAP3 ISP device * * Routine for saving the context of each module in the ISP . * CCDC , HIST , H3A , PREV , RESZ and MMU . static void isp_save_ctx(struct isp_device *isp)/* * isp_restore_ctx - Restores ISP , CCDC , HIST , H3A , PREV , RESZ & MMU context . * @ isp : OMAP3 ISP device * * Routine for restoring the context of each module in the ISP . * CCDC , HIST , H3A , PREV , RESZ and MMU . static void isp_restore_ctx(struct isp_device *isp)/* ----------------------------------------------------------------------------- * SBL resources management #define OMAP3_ISP_SBL_READ (OMAP3_ISP_SBL_CSI1_READ | \#define OMAP3_ISP_SBL_WRITE (OMAP3_ISP_SBL_CSI1_WRITE | \void omap3isp_sbl_enable(struct isp_device *isp, enum isp_sbl_resource res)0 ;if (isp->sbl_resources & OMAP3_ISP_SBL_CSI1_READ)if (isp->sbl_resources & OMAP3_ISP_SBL_CCDC_LSC_READ)if (isp->sbl_resources & OMAP3_ISP_SBL_CSI2C_WRITE)if (isp->sbl_resources & OMAP3_ISP_SBL_RESIZER_WRITE)if (isp->sbl_resources & OMAP3_ISP_SBL_WRITE)if (isp->sbl_resources & OMAP3_ISP_SBL_READ)void omap3isp_sbl_disable(struct isp_device *isp, enum isp_sbl_resource res)0 ;if (!(isp->sbl_resources & OMAP3_ISP_SBL_CSI1_READ))if (!(isp->sbl_resources & OMAP3_ISP_SBL_CCDC_LSC_READ))if (!(isp->sbl_resources & OMAP3_ISP_SBL_CSI2C_WRITE))if (!(isp->sbl_resources & OMAP3_ISP_SBL_RESIZER_WRITE))if (!(isp->sbl_resources & OMAP3_ISP_SBL_WRITE))if (!(isp->sbl_resources & OMAP3_ISP_SBL_READ))/* * isp_module_sync_idle - Helper to sync module with its idle state * @ me : ISP submodule ' s media entity * @ wait : ISP submodule ' s wait queue for streamoff / interrupt synchronization * @ stopping : flag which tells module wants to stop * * This function checks if ISP submodule needs to wait for next interrupt . If * yes , makes the caller to sleep while waiting for such event . int omap3isp_module_sync_idle(struct media_entity *me, wait_queue_head_t *wait,struct isp_pipeline *pipe = to_isp_pipeline(me);if (pipe->stream_state == ISP_PIPELINE_STREAM_STOPPED ||return 0 ;/* * atomic_set ( ) doesn ' t include memory barrier on ARM platform for SMP * scenario . We ' ll call it here to avoid race conditions . 1 );/* * If module is the last one , it ' s writing to memory . In this case , * it ' s necessary to check if the module is already paused due to * DMA queue underrun or if it has to wait for next interrupt to be * idle . * If it isn ' t the last one , the function won ' t sleep but * stopping * will still be set to warn next submodule caller ' s interrupt the * module wants to be idle . if (isp_pipeline_is_last(me)) {struct isp_video *video = pipe->output;unsigned long flags;if (video->dmaqueue_flags & ISP_VIDEO_DMAQUEUE_UNDERRUN) {0 );return 0 ;if (!wait_event_timeout(*wait, !atomic_read(stopping),1000 ))) {0 );return -ETIMEDOUT;return 0 ;/* * omap3isp_module_sync_is_stopping - Helper to verify if module was stopping * @ wait : ISP submodule ' s wait queue for streamoff / interrupt synchronization * @ stopping : flag which tells module wants to stop * * This function checks if ISP submodule was stopping . In case of yes , it * notices the caller by setting stopping to 0 and waking up the wait queue . * Returns 1 if it was stopping or 0 otherwise . int omap3isp_module_sync_is_stopping(wait_queue_head_t *wait,if (atomic_cmpxchg(stopping, 1 , 0 )) {return 1 ;return 0 ;/* -------------------------------------------------------------------------- * Clock management #define ISPCTRL_CLKS_MASK (ISPCTRL_H3A_CLK_EN | \static void __isp_subclk_update(struct isp_device *isp)0 ;/* AEWB and AF share the same clock. */ if (isp->subclk_resources &if (isp->subclk_resources & OMAP3_ISP_SUBCLK_HIST)if (isp->subclk_resources & OMAP3_ISP_SUBCLK_RESIZER)/* NOTE: For CCDC & Preview submodules, we need to affect internal * RAM as well . if (isp->subclk_resources & OMAP3_ISP_SUBCLK_CCDC)if (isp->subclk_resources & OMAP3_ISP_SUBCLK_PREVIEW)void omap3isp_subclk_enable(struct isp_device *isp,enum isp_subclk_resource res)void omap3isp_subclk_disable(struct isp_device *isp,enum isp_subclk_resource res)/* * isp_enable_clocks - Enable ISP clocks * @ isp : OMAP3 ISP device * * Return 0 if successful , or clk_prepare_enable return value if any of them * fails . static int isp_enable_clocks(struct isp_device *isp)int r;unsigned long rate;if (r) {"failed to enable cam_ick clock\n" );goto out_clk_enable_ick;if (r) {"clk_set_rate for cam_mclk failed\n" );goto out_clk_enable_mclk;if (r) {"failed to enable cam_mclk clock\n" );goto out_clk_enable_mclk;if (rate != CM_CAM_MCLK_HZ)"unexpected cam_mclk rate:\n" " expected : %d\n" " actual : %ld\n" , CM_CAM_MCLK_HZ, rate);if (r) {"failed to enable csi2_fck clock\n" );goto out_clk_enable_csi2_fclk;return 0 ;return r;/* * isp_disable_clocks - Disable ISP clocks * @ isp : OMAP3 ISP device static void isp_disable_clocks(struct isp_device *isp)static const char *isp_clocks[] = {"cam_ick" ,"cam_mclk" ,"csi2_96m_fck" ,"l3_ick" ,static int isp_get_clocks(struct isp_device *isp)struct clk *clk;unsigned int i;for (i = 0 ; i < ARRAY_SIZE(isp_clocks); ++i) {if (IS_ERR(clk)) {"clk_get %s failed\n" , isp_clocks[i]);return PTR_ERR(clk);return 0 ;/* * omap3isp_get - Acquire the ISP resource . * * Initializes the clocks for the first acquire . * * Increment the reference count on the ISP . If the first reference is taken , * enable clocks and power - up all submodules . * * Return a pointer to the ISP device structure , or NULL if an error occurred . static struct isp_device *__omap3isp_get(struct isp_device *isp, bool irq)struct isp_device *__isp = isp;if (isp == NULL)return NULL;if (isp->ref_count > 0 )goto out;if (isp_enable_clocks(isp) < 0 ) {goto out;/* We don't want to restore context before saving it! */ if (isp->has_context)if (irq)if (__isp != NULL)return __isp;struct isp_device *omap3isp_get(struct isp_device *isp)return __omap3isp_get(isp, true );/* * omap3isp_put - Release the ISP * * Decrement the reference count on the ISP . If the last reference is released , * power - down all submodules , disable clocks and free temporary buffers . static void __omap3isp_put(struct isp_device *isp, bool save_ctx)if (isp == NULL)return ;0 );if (--isp->ref_count == 0 ) {if (save_ctx) {1 ;/* Reset the ISP if an entity has failed to stop. This is the * only way to recover from such conditions . if (!media_entity_enum_empty(&isp->crashed) ||void omap3isp_put(struct isp_device *isp)true );/* -------------------------------------------------------------------------- * Platform device driver #ifdef CONFIG_PM/* * Power management support . * * As the ISP can ' t properly handle an input video stream interruption on a non * frame boundary , the ISP pipelines need to be stopped before sensors get * suspended . However , as suspending the sensors can require a running clock , * which can be provided by the ISP , the ISP can ' t be completely suspended * before the sensor . * * To solve this problem power management support is split into prepare / complete * and suspend / resume operations . The pipelines are stopped in prepare ( ) and the * ISP clocks get disabled in suspend ( ) . Similarly , the clocks are re - enabled in * resume ( ) , and the pipelines are restarted in complete ( ) . * * TODO : PM dependencies between the ISP and sensors are not modelled explicitly * yet . static int isp_pm_prepare(struct device *dev)struct isp_device *isp = dev_get_drvdata(dev);int reset;if (isp->ref_count == 0 )return 0 ;if (reset)return 0 ;static int isp_pm_suspend(struct device *dev)struct isp_device *isp = dev_get_drvdata(dev);if (isp->ref_count)return 0 ;static int isp_pm_resume(struct device *dev)struct isp_device *isp = dev_get_drvdata(dev);if (isp->ref_count == 0 )return 0 ;return isp_enable_clocks(isp);static void isp_pm_complete(struct device *dev)struct isp_device *isp = dev_get_drvdata(dev);if (isp->ref_count == 0 )return ;#else #define isp_pm_prepare NULL#define isp_pm_suspend NULL#define isp_pm_resume NULL#define isp_pm_complete NULL#endif /* CONFIG_PM */ static void isp_unregister_entities(struct isp_device *isp)static int isp_link_entity(struct isp_device *isp, struct media_entity *entity,enum isp_interface_type interface)struct media_entity *input;unsigned int flags;unsigned int pad;unsigned int i;/* Connect the sensor to the correct interface module. * Parallel sensors are connected directly to the CCDC , while * serial sensors are connected to the CSI2a , CCP2b or CSI2c * receiver through CSIPHY1 or CSIPHY2 . switch (interface) {case ISP_INTERFACE_PARALLEL:0 ;break ;case ISP_INTERFACE_CSI2A_PHY2:break ;case ISP_INTERFACE_CCP2B_PHY1:case ISP_INTERFACE_CCP2B_PHY2:0 ;break ;case ISP_INTERFACE_CSI2C_PHY1:break ;default :"%s: invalid interface type %u\n" , __func__,return -EINVAL;/* * Not all interfaces are available on all revisions of the * ISP . The sub - devices of those interfaces aren ' t initialised * in such a case . Check this by ensuring the num_pads is * non - zero . if (!input->num_pads) {"%s: invalid input %u\n" , entity->name,return -EINVAL;for (i = 0 ; i < entity->num_pads; i++) {if (entity->pads[i].flags & MEDIA_PAD_FL_SOURCE)break ;if (i == entity->num_pads) {"%s: no source pad in external entity %s\n" ,return -EINVAL;return media_create_pad_link(entity, i, input, pad, flags);static int isp_register_entities(struct isp_device *isp)int ret;"TI OMAP3 ISP" ,sizeof (isp->media_dev.model));if (ret < 0 ) {"%s: V4L2 device registration failed (%d)\n" ,goto done;/* Register internal entities */ if (ret < 0 )goto done;if (ret < 0 )goto done;if (ret < 0 )goto done;if (ret < 0 )goto done;if (ret < 0 )goto done;if (ret < 0 )goto done;if (ret < 0 )goto done;if (ret < 0 )goto done;if (ret < 0 )return ret;/* * isp_create_links ( ) - Create links for internal and external ISP entities * @ isp : Pointer to ISP device * * This function creates all links between ISP internal and external entities . * * Return : A negative error code on failure or zero on success . Possible error * codes are those returned by media_create_pad_link ( ) . static int isp_create_links(struct isp_device *isp)int ret;/* Create links between entities and video nodes. */ 0 , 0 );if (ret < 0 )return ret;0 ,0 );if (ret < 0 )return ret;0 , 0 );if (ret < 0 )return ret;0 ,0 );if (ret < 0 )return ret;0 , 0 );if (ret < 0 )return ret;0 ,0 );if (ret < 0 )return ret;0 , 0 );if (ret < 0 )return ret;/* Create links between entities. */ 0 );if (ret < 0 )return ret;0 );if (ret < 0 )return ret;0 );if (ret < 0 )return ret;0 );if (ret < 0 )return ret;0 );if (ret < 0 )return ret;0 ,if (ret < 0 )return ret;0 ,if (ret < 0 )return ret;0 ,if (ret < 0 )return ret;return 0 ;static void isp_cleanup_modules(struct isp_device *isp)static int isp_initialize_modules(struct isp_device *isp)int ret;if (ret < 0 ) {"CSI PHY initialization failed\n" );return ret;if (ret < 0 ) {"CSI2 initialization failed\n" );goto error_csi2;if (ret < 0 ) {"CCP2 initialization failed\n" );goto error_ccp2;if (ret < 0 ) {"CCDC initialization failed\n" );goto error_ccdc;if (ret < 0 ) {"Preview initialization failed\n" );goto error_preview;if (ret < 0 ) {"Resizer initialization failed\n" );goto error_resizer;if (ret < 0 ) {"Histogram initialization failed\n" );goto error_hist;if (ret < 0 ) {"H3A AEWB initialization failed\n" );goto error_h3a_aewb;if (ret < 0 ) {"H3A AF initialization failed\n" );goto error_h3a_af;return 0 ;return ret;static void isp_detach_iommu(struct isp_device *isp)#ifdef CONFIG_ARM_DMA_USE_IOMMU#endif static int isp_attach_iommu(struct isp_device *isp)#ifdef CONFIG_ARM_DMA_USE_IOMMUstruct dma_iommu_mapping *mapping;int ret;/* We always want to replace any default mapping from the arch code */ if (mapping) {/* * Create the ARM mapping , used by the ARM DMA mapping core to allocate * VAs . This will allocate a corresponding IOMMU domain . if (IS_ERR(mapping)) {"failed to create ARM IOMMU mapping\n" );return PTR_ERR(mapping);/* Attach the ARM VA mapping to the device. */ if (ret < 0 ) {"failed to attach device to VA mapping\n" );goto error;return 0 ;return ret;#else return -ENODEV;#endif /* * isp_remove - Remove ISP platform device * @ pdev : Pointer to ISP platform device * * Always returns 0 . static void isp_remove(struct platform_device *pdev)struct isp_device *isp = platform_get_drvdata(pdev);false );false );enum isp_of_phy {0 ,static int isp_subdev_notifier_bound(struct v4l2_async_notifier *async,struct v4l2_subdev *sd,struct v4l2_async_connection *asc)struct isp_device *isp = container_of(async, struct isp_device,struct isp_bus_cfg *bus_cfg =struct isp_async_subdev, asd)->bus;int ret;return ret;static int isp_subdev_notifier_complete(struct v4l2_async_notifier *async)struct isp_device *isp = container_of(async, struct isp_device,int ret;if (ret)return ret;if (ret < 0 )return ret;return media_device_register(&isp->media_dev);static void isp_parse_of_parallel_endpoint(struct device *dev,struct v4l2_fwnode_endpoint *vep,struct isp_bus_cfg *buscfg)static void isp_parse_of_csi2_endpoint(struct device *dev,struct v4l2_fwnode_endpoint *vep,struct isp_bus_cfg *buscfg)unsigned int i;0 ];"clock lane polarity %u, pos %u\n" ,for (i = 0 ; i < buscfg->bus.csi2.num_data_lanes; i++) {1 ];"data lane %u polarity %u, pos %u\n" , i,/* * FIXME : now we assume the CRC is always there . Implement a way to * obtain this information from the sensor . Frame descriptors , perhaps ? 1 ;static void isp_parse_of_csi1_endpoint(struct device *dev,struct v4l2_fwnode_endpoint *vep,struct isp_bus_cfg *buscfg)0 ];"clock lane polarity %u, pos %u\n" ,0 ].pos = vep->bus.mipi_csi1.data_lane;0 ].pol =1 ];"data lane polarity %u, pos %u\n" ,0 ].pol,0 ].pos);1 ;1 ;static struct {2 ] = {static int isp_parse_of_endpoints(struct isp_device *isp)struct fwnode_handle *ep;struct isp_async_subdev *isd = NULL;unsigned int i;0 ,if (ep) {struct v4l2_fwnode_endpoint vep = {int ret;"parsing parallel interface\n" );if (!ret) {struct if (!IS_ERR(isd))for (i = 0 ; i < ARRAY_SIZE(isp_bus_interfaces); i++) {struct v4l2_fwnode_endpoint vep = {int ret;0 ,if (!ep)continue ;"parsing serial interface %u, node %pOF\n" , i,if (ret == -ENXIO) {struct v4l2_fwnode_endpoint)if (ret == -ENXIO) {struct v4l2_fwnode_endpoint)if (!ret) {struct if (!IS_ERR(isd)) {switch (vep.bus_type) {case V4L2_MBUS_CSI2_DPHY:break ;case V4L2_MBUS_CSI1:case V4L2_MBUS_CCP2:break ;default :break ;return 0 ;static const struct v4l2_async_notifier_operations isp_subdev_notifier_ops = {/* * isp_probe - Probe ISP platform device * @ pdev : Pointer to ISP platform device * * Returns 0 if successful , * - ENOMEM if no memory available , * - ENODEV if no platform device resources found * or no space for remapping registers , * - EINVAL if couldn ' t install ISR , * or clk_get return error value . static int isp_probe(struct platform_device *pdev)struct isp_device *isp;struct resource *mem;int ret;int i, m;sizeof (*isp), GFP_KERNEL);if (!isp) {"could not allocate memory\n" );return -ENOMEM;"ti,phy-type" , &isp->phy_type);if (ret)goto error_release_isp;"syscon" , 1 ,if (IS_ERR(isp->syscon)) {goto error_release_isp;0 ;32 ));if (ret)goto error;/* Regulators */ "vdd-csiphy1" );if (IS_ERR(isp->isp_csiphy1.vdd)) {goto error;"vdd-csiphy2" );if (IS_ERR(isp->isp_csiphy2.vdd)) {goto error;/* Clocks * * The ISP clock tree is revision - dependent . We thus need to enable ICLK * manually to read the revision before calling _ _ omap3isp_get ( ) . * * Start by mapping the ISP MMIO area , which is in two pieces . * The ISP IOMMU is in between . Map both now , and fill in the * ISP revision specific portions a little later in the * function . for (i = 0 ; i < 2 ; i++) {unsigned int map_idx = i ? OMAP3_ISP_IOMEM_CSI2A_REGS1 : 0 ;if (IS_ERR(isp->mmio_base[map_idx])) {goto error;if (ret < 0 )goto error;if (ret < 0 )goto error;"Revision %d.%d found\n" ,0 xf0) >> 4 , isp->revision & 0 x0f);if (__omap3isp_get(isp, false ) == NULL) {goto error;if (ret < 0 )goto error_isp;if (ret < 0 )goto error_isp;/* Memory resources */ for (m = 0 ; m < ARRAY_SIZE(isp_res_maps); m++)if (isp->revision == isp_res_maps[m].isp_rev)break ;if (m == ARRAY_SIZE(isp_res_maps)) {"No resource map found for ISP rev %d.%d\n" ,0 xf0) >> 4 , isp->revision & 0 xf);goto error_isp;for (i = 1 ; i < OMAP3_ISP_IOMEM_CSI2A_REGS1; i++)0 ] + isp_res_maps[m].offset[i];for (i = OMAP3_ISP_IOMEM_CSIPHY2; i < OMAP3_ISP_IOMEM_LAST; i++)/* IOMMU */ if (ret < 0 ) {"unable to attach to IOMMU\n" );goto error_isp;/* Interrupt */ 0 );if (ret < 0 )goto error_iommu;if (devm_request_irq(isp->dev, isp->irq_num, isp_isr, IRQF_SHARED,"OMAP3 ISP" , isp)) {"Unable to request IRQ\n" );goto error_iommu;/* Entities */ if (ret < 0 )goto error_iommu;if (ret < 0 )goto error_modules;if (ret < 0 )goto error_register_entities;if (ret < 0 )goto error_register_entities;if (ret)goto error_register_entities;1 );return 0 ;false );return ret;static const struct dev_pm_ops omap3isp_pm_ops = {static const struct platform_device_id omap3isp_id_table[] = {"omap3isp" , 0 },static const struct of_device_id omap3isp_of_table[] = {"ti,omap3-isp" },static struct platform_driver omap3isp_driver = {"omap3isp" ,"Nokia Corporation" );"TI OMAP3 ISP driver" );"GPL" );
Messung V0.5 in Prozent C=96 H=85 G=90
¤ Dauer der Verarbeitung: 0.86 Sekunden
¤ *© Formatika GbR, Deutschland
