1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * isp.c 4 * 5 * TI OMAP3 ISP - Core 6 * 7 * Copyright (C) 2006-2010 Nokia Corporation 8 * Copyright (C) 2007-2009 Texas Instruments, Inc. 9 * 10 * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com> 11 * Sakari Ailus <sakari.ailus@iki.fi> 12 * 13 * Contributors: 14 * Laurent Pinchart <laurent.pinchart@ideasonboard.com> 15 * Sakari Ailus <sakari.ailus@iki.fi> 16 * David Cohen <dacohen@gmail.com> 17 * Stanimir Varbanov <svarbanov@mm-sol.com> 18 * Vimarsh Zutshi <vimarsh.zutshi@gmail.com> 19 * Tuukka Toivonen <tuukkat76@gmail.com> 20 * Sergio Aguirre <saaguirre@ti.com> 21 * Antti Koskipaa <akoskipa@gmail.com> 22 * Ivan T. Ivanov <iivanov@mm-sol.com> 23 * RaniSuneela <r-m@ti.com> 24 * Atanas Filipov <afilipov@mm-sol.com> 25 * Gjorgji Rosikopulos <grosikopulos@mm-sol.com> 26 * Hiroshi DOYU <hiroshi.doyu@nokia.com> 27 * Nayden Kanchev <nkanchev@mm-sol.com> 28 * Phil Carmody <ext-phil.2.carmody@nokia.com> 29 * Artem Bityutskiy <artem.bityutskiy@nokia.com> 30 * Dominic Curran <dcurran@ti.com> 31 * Ilkka Myllyperkio <ilkka.myllyperkio@sofica.fi> 32 * Pallavi Kulkarni <p-kulkarni@ti.com> 33 * Vaibhav Hiremath <hvaibhav@ti.com> 34 * Mohit Jalori <mjalori@ti.com> 35 * Sameer Venkatraman <sameerv@ti.com> 36 * Senthilvadivu Guruswamy <svadivu@ti.com> 37 * Thara Gopinath <thara@ti.com> 38 * Toni Leinonen <toni.leinonen@nokia.com> 39 * Troy Laramy <t-laramy@ti.com> 40 */ 41 42 #include <linux/clk.h> 43 #include <linux/clkdev.h> 44 #include <linux/delay.h> 45 #include <linux/device.h> 46 #include <linux/dma-mapping.h> 47 #include <linux/i2c.h> 48 #include <linux/interrupt.h> 49 #include <linux/mfd/syscon.h> 50 #include <linux/module.h> 51 #include <linux/omap-iommu.h> 52 #include <linux/platform_device.h> 53 #include <linux/property.h> 54 #include <linux/regulator/consumer.h> 55 #include <linux/slab.h> 56 #include <linux/sched.h> 57 #include <linux/vmalloc.h> 58 59 #ifdef CONFIG_ARM_DMA_USE_IOMMU 60 #include <asm/dma-iommu.h> 61 #endif 62 63 #include <media/v4l2-common.h> 64 #include <media/v4l2-fwnode.h> 65 #include <media/v4l2-device.h> 66 #include <media/v4l2-mc.h> 67 68 #include "isp.h" 69 #include "ispreg.h" 70 #include "ispccdc.h" 71 #include "isppreview.h" 72 #include "ispresizer.h" 73 #include "ispcsi2.h" 74 #include "ispccp2.h" 75 #include "isph3a.h" 76 #include "isphist.h" 77 78 static unsigned int autoidle; 79 module_param(autoidle, int, 0444); 80 MODULE_PARM_DESC(autoidle, "Enable OMAP3ISP AUTOIDLE support"); 81 82 static void isp_save_ctx(struct isp_device *isp); 83 84 static void isp_restore_ctx(struct isp_device *isp); 85 86 static const struct isp_res_mapping isp_res_maps[] = { 87 { 88 .isp_rev = ISP_REVISION_2_0, 89 .offset = { 90 /* first MMIO area */ 91 0x0000, /* base, len 0x0070 */ 92 0x0400, /* ccp2, len 0x01f0 */ 93 0x0600, /* ccdc, len 0x00a8 */ 94 0x0a00, /* hist, len 0x0048 */ 95 0x0c00, /* h3a, len 0x0060 */ 96 0x0e00, /* preview, len 0x00a0 */ 97 0x1000, /* resizer, len 0x00ac */ 98 0x1200, /* sbl, len 0x00fc */ 99 /* second MMIO area */ 100 0x0000, /* csi2a, len 0x0170 */ 101 0x0170, /* csiphy2, len 0x000c */ 102 }, 103 .phy_type = ISP_PHY_TYPE_3430, 104 }, 105 { 106 .isp_rev = ISP_REVISION_15_0, 107 .offset = { 108 /* first MMIO area */ 109 0x0000, /* base, len 0x0070 */ 110 0x0400, /* ccp2, len 0x01f0 */ 111 0x0600, /* ccdc, len 0x00a8 */ 112 0x0a00, /* hist, len 0x0048 */ 113 0x0c00, /* h3a, len 0x0060 */ 114 0x0e00, /* preview, len 0x00a0 */ 115 0x1000, /* resizer, len 0x00ac */ 116 0x1200, /* sbl, len 0x00fc */ 117 /* second MMIO area */ 118 0x0000, /* csi2a, len 0x0170 (1st area) */ 119 0x0170, /* csiphy2, len 0x000c */ 120 0x01c0, /* csi2a, len 0x0040 (2nd area) */ 121 0x0400, /* csi2c, len 0x0170 (1st area) */ 122 0x0570, /* csiphy1, len 0x000c */ 123 0x05c0, /* csi2c, len 0x0040 (2nd area) */ 124 }, 125 .phy_type = ISP_PHY_TYPE_3630, 126 }, 127 }; 128 129 /* Structure for saving/restoring ISP module registers */ 130 static struct isp_reg isp_reg_list[] = { 131 {OMAP3_ISP_IOMEM_MAIN, ISP_SYSCONFIG, 0}, 132 {OMAP3_ISP_IOMEM_MAIN, ISP_CTRL, 0}, 133 {OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL, 0}, 134 {0, ISP_TOK_TERM, 0} 135 }; 136 137 /* 138 * omap3isp_flush - Post pending L3 bus writes by doing a register readback 139 * @isp: OMAP3 ISP device 140 * 141 * In order to force posting of pending writes, we need to write and 142 * readback the same register, in this case the revision register. 143 * 144 * See this link for reference: 145 * https://www.mail-archive.com/linux-omap@vger.kernel.org/msg08149.html 146 */ 147 void omap3isp_flush(struct isp_device *isp) 148 { 149 isp_reg_writel(isp, 0, OMAP3_ISP_IOMEM_MAIN, ISP_REVISION); 150 isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, ISP_REVISION); 151 } 152 153 /* ----------------------------------------------------------------------------- 154 * XCLK 155 */ 156 157 #define to_isp_xclk(_hw) container_of(_hw, struct isp_xclk, hw) 158 159 static void isp_xclk_update(struct isp_xclk *xclk, u32 divider) 160 { 161 switch (xclk->id) { 162 case ISP_XCLK_A: 163 isp_reg_clr_set(xclk->isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL, 164 ISPTCTRL_CTRL_DIVA_MASK, 165 divider << ISPTCTRL_CTRL_DIVA_SHIFT); 166 break; 167 case ISP_XCLK_B: 168 isp_reg_clr_set(xclk->isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL, 169 ISPTCTRL_CTRL_DIVB_MASK, 170 divider << ISPTCTRL_CTRL_DIVB_SHIFT); 171 break; 172 } 173 } 174 175 static int isp_xclk_prepare(struct clk_hw *hw) 176 { 177 struct isp_xclk *xclk = to_isp_xclk(hw); 178 179 omap3isp_get(xclk->isp); 180 181 return 0; 182 } 183 184 static void isp_xclk_unprepare(struct clk_hw *hw) 185 { 186 struct isp_xclk *xclk = to_isp_xclk(hw); 187 188 omap3isp_put(xclk->isp); 189 } 190 191 static int isp_xclk_enable(struct clk_hw *hw) 192 { 193 struct isp_xclk *xclk = to_isp_xclk(hw); 194 unsigned long flags; 195 196 spin_lock_irqsave(&xclk->lock, flags); 197 isp_xclk_update(xclk, xclk->divider); 198 xclk->enabled = true; 199 spin_unlock_irqrestore(&xclk->lock, flags); 200 201 return 0; 202 } 203 204 static void isp_xclk_disable(struct clk_hw *hw) 205 { 206 struct isp_xclk *xclk = to_isp_xclk(hw); 207 unsigned long flags; 208 209 spin_lock_irqsave(&xclk->lock, flags); 210 isp_xclk_update(xclk, 0); 211 xclk->enabled = false; 212 spin_unlock_irqrestore(&xclk->lock, flags); 213 } 214 215 static unsigned long isp_xclk_recalc_rate(struct clk_hw *hw, 216 unsigned long parent_rate) 217 { 218 struct isp_xclk *xclk = to_isp_xclk(hw); 219 220 return parent_rate / xclk->divider; 221 } 222 223 static u32 isp_xclk_calc_divider(unsigned long *rate, unsigned long parent_rate) 224 { 225 u32 divider; 226 227 if (*rate >= parent_rate) { 228 *rate = parent_rate; 229 return ISPTCTRL_CTRL_DIV_BYPASS; 230 } 231 232 if (*rate == 0) 233 *rate = 1; 234 235 divider = DIV_ROUND_CLOSEST(parent_rate, *rate); 236 if (divider >= ISPTCTRL_CTRL_DIV_BYPASS) 237 divider = ISPTCTRL_CTRL_DIV_BYPASS - 1; 238 239 *rate = parent_rate / divider; 240 return divider; 241 } 242 243 static long isp_xclk_round_rate(struct clk_hw *hw, unsigned long rate, 244 unsigned long *parent_rate) 245 { 246 isp_xclk_calc_divider(&rate, *parent_rate); 247 return rate; 248 } 249 250 static int isp_xclk_set_rate(struct clk_hw *hw, unsigned long rate, 251 unsigned long parent_rate) 252 { 253 struct isp_xclk *xclk = to_isp_xclk(hw); 254 unsigned long flags; 255 u32 divider; 256 257 divider = isp_xclk_calc_divider(&rate, parent_rate); 258 259 spin_lock_irqsave(&xclk->lock, flags); 260 261 xclk->divider = divider; 262 if (xclk->enabled) 263 isp_xclk_update(xclk, divider); 264 265 spin_unlock_irqrestore(&xclk->lock, flags); 266 267 dev_dbg(xclk->isp->dev, "%s: cam_xclk%c set to %lu Hz (div %u)\n", 268 __func__, xclk->id == ISP_XCLK_A ? 'a' : 'b', rate, divider); 269 return 0; 270 } 271 272 static const struct clk_ops isp_xclk_ops = { 273 .prepare = isp_xclk_prepare, 274 .unprepare = isp_xclk_unprepare, 275 .enable = isp_xclk_enable, 276 .disable = isp_xclk_disable, 277 .recalc_rate = isp_xclk_recalc_rate, 278 .round_rate = isp_xclk_round_rate, 279 .set_rate = isp_xclk_set_rate, 280 }; 281 282 static const char *isp_xclk_parent_name = "cam_mclk"; 283 284 static struct clk *isp_xclk_src_get(struct of_phandle_args *clkspec, void *data) 285 { 286 unsigned int idx = clkspec->args[0]; 287 struct isp_device *isp = data; 288 289 if (idx >= ARRAY_SIZE(isp->xclks)) 290 return ERR_PTR(-ENOENT); 291 292 return isp->xclks[idx].clk; 293 } 294 295 static int isp_xclk_init(struct isp_device *isp) 296 { 297 struct device_node *np = isp->dev->of_node; 298 struct clk_init_data init = {}; 299 unsigned int i; 300 301 for (i = 0; i < ARRAY_SIZE(isp->xclks); ++i) 302 isp->xclks[i].clk = ERR_PTR(-EINVAL); 303 304 for (i = 0; i < ARRAY_SIZE(isp->xclks); ++i) { 305 struct isp_xclk *xclk = &isp->xclks[i]; 306 307 xclk->isp = isp; 308 xclk->id = i == 0 ? ISP_XCLK_A : ISP_XCLK_B; 309 xclk->divider = 1; 310 spin_lock_init(&xclk->lock); 311 312 init.name = i == 0 ? "cam_xclka" : "cam_xclkb"; 313 init.ops = &isp_xclk_ops; 314 init.parent_names = &isp_xclk_parent_name; 315 init.num_parents = 1; 316 317 xclk->hw.init = &init; 318 /* 319 * The first argument is NULL in order to avoid circular 320 * reference, as this driver takes reference on the 321 * sensor subdevice modules and the sensors would take 322 * reference on this module through clk_get(). 323 */ 324 xclk->clk = clk_register(NULL, &xclk->hw); 325 if (IS_ERR(xclk->clk)) 326 return PTR_ERR(xclk->clk); 327 } 328 329 if (np) 330 of_clk_add_provider(np, isp_xclk_src_get, isp); 331 332 return 0; 333 } 334 335 static void isp_xclk_cleanup(struct isp_device *isp) 336 { 337 struct device_node *np = isp->dev->of_node; 338 unsigned int i; 339 340 if (np) 341 of_clk_del_provider(np); 342 343 for (i = 0; i < ARRAY_SIZE(isp->xclks); ++i) { 344 struct isp_xclk *xclk = &isp->xclks[i]; 345 346 if (!IS_ERR(xclk->clk)) 347 clk_unregister(xclk->clk); 348 } 349 } 350 351 /* ----------------------------------------------------------------------------- 352 * Interrupts 353 */ 354 355 /* 356 * isp_enable_interrupts - Enable ISP interrupts. 357 * @isp: OMAP3 ISP device 358 */ 359 static void isp_enable_interrupts(struct isp_device *isp) 360 { 361 static const u32 irq = IRQ0ENABLE_CSIA_IRQ 362 | IRQ0ENABLE_CSIB_IRQ 363 | IRQ0ENABLE_CCDC_LSC_PREF_ERR_IRQ 364 | IRQ0ENABLE_CCDC_LSC_DONE_IRQ 365 | IRQ0ENABLE_CCDC_VD0_IRQ 366 | IRQ0ENABLE_CCDC_VD1_IRQ 367 | IRQ0ENABLE_HS_VS_IRQ 368 | IRQ0ENABLE_HIST_DONE_IRQ 369 | IRQ0ENABLE_H3A_AWB_DONE_IRQ 370 | IRQ0ENABLE_H3A_AF_DONE_IRQ 371 | IRQ0ENABLE_PRV_DONE_IRQ 372 | IRQ0ENABLE_RSZ_DONE_IRQ; 373 374 isp_reg_writel(isp, irq, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS); 375 isp_reg_writel(isp, irq, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0ENABLE); 376 } 377 378 /* 379 * isp_disable_interrupts - Disable ISP interrupts. 380 * @isp: OMAP3 ISP device 381 */ 382 static void isp_disable_interrupts(struct isp_device *isp) 383 { 384 isp_reg_writel(isp, 0, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0ENABLE); 385 } 386 387 /* 388 * isp_core_init - ISP core settings 389 * @isp: OMAP3 ISP device 390 * @idle: Consider idle state. 391 * 392 * Set the power settings for the ISP and SBL bus and configure the HS/VS 393 * interrupt source. 394 * 395 * We need to configure the HS/VS interrupt source before interrupts get 396 * enabled, as the sensor might be free-running and the ISP default setting 397 * (HS edge) would put an unnecessary burden on the CPU. 398 */ 399 static void isp_core_init(struct isp_device *isp, int idle) 400 { 401 isp_reg_writel(isp, 402 ((idle ? ISP_SYSCONFIG_MIDLEMODE_SMARTSTANDBY : 403 ISP_SYSCONFIG_MIDLEMODE_FORCESTANDBY) << 404 ISP_SYSCONFIG_MIDLEMODE_SHIFT) | 405 ((isp->revision == ISP_REVISION_15_0) ? 406 ISP_SYSCONFIG_AUTOIDLE : 0), 407 OMAP3_ISP_IOMEM_MAIN, ISP_SYSCONFIG); 408 409 isp_reg_writel(isp, 410 (isp->autoidle ? ISPCTRL_SBL_AUTOIDLE : 0) | 411 ISPCTRL_SYNC_DETECT_VSRISE, 412 OMAP3_ISP_IOMEM_MAIN, ISP_CTRL); 413 } 414 415 /* 416 * Configure the bridge and lane shifter. Valid inputs are 417 * 418 * CCDC_INPUT_PARALLEL: Parallel interface 419 * CCDC_INPUT_CSI2A: CSI2a receiver 420 * CCDC_INPUT_CCP2B: CCP2b receiver 421 * CCDC_INPUT_CSI2C: CSI2c receiver 422 * 423 * The bridge and lane shifter are configured according to the selected input 424 * and the ISP platform data. 425 */ 426 void omap3isp_configure_bridge(struct isp_device *isp, 427 enum ccdc_input_entity input, 428 const struct isp_parallel_cfg *parcfg, 429 unsigned int shift, unsigned int bridge) 430 { 431 u32 ispctrl_val; 432 433 ispctrl_val = isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, ISP_CTRL); 434 ispctrl_val &= ~ISPCTRL_SHIFT_MASK; 435 ispctrl_val &= ~ISPCTRL_PAR_CLK_POL_INV; 436 ispctrl_val &= ~ISPCTRL_PAR_SER_CLK_SEL_MASK; 437 ispctrl_val &= ~ISPCTRL_PAR_BRIDGE_MASK; 438 ispctrl_val |= bridge; 439 440 switch (input) { 441 case CCDC_INPUT_PARALLEL: 442 ispctrl_val |= ISPCTRL_PAR_SER_CLK_SEL_PARALLEL; 443 ispctrl_val |= parcfg->clk_pol << ISPCTRL_PAR_CLK_POL_SHIFT; 444 shift += parcfg->data_lane_shift; 445 break; 446 447 case CCDC_INPUT_CSI2A: 448 ispctrl_val |= ISPCTRL_PAR_SER_CLK_SEL_CSIA; 449 break; 450 451 case CCDC_INPUT_CCP2B: 452 ispctrl_val |= ISPCTRL_PAR_SER_CLK_SEL_CSIB; 453 break; 454 455 case CCDC_INPUT_CSI2C: 456 ispctrl_val |= ISPCTRL_PAR_SER_CLK_SEL_CSIC; 457 break; 458 459 default: 460 return; 461 } 462 463 ispctrl_val |= ((shift/2) << ISPCTRL_SHIFT_SHIFT) & ISPCTRL_SHIFT_MASK; 464 465 isp_reg_writel(isp, ispctrl_val, OMAP3_ISP_IOMEM_MAIN, ISP_CTRL); 466 } 467 468 void omap3isp_hist_dma_done(struct isp_device *isp) 469 { 470 if (omap3isp_ccdc_busy(&isp->isp_ccdc) || 471 omap3isp_stat_pcr_busy(&isp->isp_hist)) { 472 /* Histogram cannot be enabled in this frame anymore */ 473 atomic_set(&isp->isp_hist.buf_err, 1); 474 dev_dbg(isp->dev, 475 "hist: Out of synchronization with CCDC. Ignoring next buffer.\n"); 476 } 477 } 478 479 static inline void __maybe_unused isp_isr_dbg(struct isp_device *isp, 480 u32 irqstatus) 481 { 482 static const char *name[] = { 483 "CSIA_IRQ", 484 "res1", 485 "res2", 486 "CSIB_LCM_IRQ", 487 "CSIB_IRQ", 488 "res5", 489 "res6", 490 "res7", 491 "CCDC_VD0_IRQ", 492 "CCDC_VD1_IRQ", 493 "CCDC_VD2_IRQ", 494 "CCDC_ERR_IRQ", 495 "H3A_AF_DONE_IRQ", 496 "H3A_AWB_DONE_IRQ", 497 "res14", 498 "res15", 499 "HIST_DONE_IRQ", 500 "CCDC_LSC_DONE", 501 "CCDC_LSC_PREFETCH_COMPLETED", 502 "CCDC_LSC_PREFETCH_ERROR", 503 "PRV_DONE_IRQ", 504 "CBUFF_IRQ", 505 "res22", 506 "res23", 507 "RSZ_DONE_IRQ", 508 "OVF_IRQ", 509 "res26", 510 "res27", 511 "MMU_ERR_IRQ", 512 "OCP_ERR_IRQ", 513 "SEC_ERR_IRQ", 514 "HS_VS_IRQ", 515 }; 516 int i; 517 518 dev_dbg(isp->dev, "ISP IRQ: "); 519 520 for (i = 0; i < ARRAY_SIZE(name); i++) { 521 if ((1 << i) & irqstatus) 522 printk(KERN_CONT "%s ", name[i]); 523 } 524 printk(KERN_CONT "\n"); 525 } 526 527 static void isp_isr_sbl(struct isp_device *isp) 528 { 529 struct device *dev = isp->dev; 530 struct isp_pipeline *pipe; 531 u32 sbl_pcr; 532 533 /* 534 * Handle shared buffer logic overflows for video buffers. 535 * ISPSBL_PCR_CCDCPRV_2_RSZ_OVF can be safely ignored. 536 */ 537 sbl_pcr = isp_reg_readl(isp, OMAP3_ISP_IOMEM_SBL, ISPSBL_PCR); 538 isp_reg_writel(isp, sbl_pcr, OMAP3_ISP_IOMEM_SBL, ISPSBL_PCR); 539 sbl_pcr &= ~ISPSBL_PCR_CCDCPRV_2_RSZ_OVF; 540 541 if (sbl_pcr) 542 dev_dbg(dev, "SBL overflow (PCR = 0x%08x)\n", sbl_pcr); 543 544 if (sbl_pcr & ISPSBL_PCR_CSIB_WBL_OVF) { 545 pipe = to_isp_pipeline(&isp->isp_ccp2.subdev.entity); 546 if (pipe != NULL) 547 pipe->error = true; 548 } 549 550 if (sbl_pcr & ISPSBL_PCR_CSIA_WBL_OVF) { 551 pipe = to_isp_pipeline(&isp->isp_csi2a.subdev.entity); 552 if (pipe != NULL) 553 pipe->error = true; 554 } 555 556 if (sbl_pcr & ISPSBL_PCR_CCDC_WBL_OVF) { 557 pipe = to_isp_pipeline(&isp->isp_ccdc.subdev.entity); 558 if (pipe != NULL) 559 pipe->error = true; 560 } 561 562 if (sbl_pcr & ISPSBL_PCR_PRV_WBL_OVF) { 563 pipe = to_isp_pipeline(&isp->isp_prev.subdev.entity); 564 if (pipe != NULL) 565 pipe->error = true; 566 } 567 568 if (sbl_pcr & (ISPSBL_PCR_RSZ1_WBL_OVF 569 | ISPSBL_PCR_RSZ2_WBL_OVF 570 | ISPSBL_PCR_RSZ3_WBL_OVF 571 | ISPSBL_PCR_RSZ4_WBL_OVF)) { 572 pipe = to_isp_pipeline(&isp->isp_res.subdev.entity); 573 if (pipe != NULL) 574 pipe->error = true; 575 } 576 577 if (sbl_pcr & ISPSBL_PCR_H3A_AF_WBL_OVF) 578 omap3isp_stat_sbl_overflow(&isp->isp_af); 579 580 if (sbl_pcr & ISPSBL_PCR_H3A_AEAWB_WBL_OVF) 581 omap3isp_stat_sbl_overflow(&isp->isp_aewb); 582 } 583 584 /* 585 * isp_isr - Interrupt Service Routine for Camera ISP module. 586 * @irq: Not used currently. 587 * @_isp: Pointer to the OMAP3 ISP device 588 * 589 * Handles the corresponding callback if plugged in. 590 */ 591 static irqreturn_t isp_isr(int irq, void *_isp) 592 { 593 static const u32 ccdc_events = IRQ0STATUS_CCDC_LSC_PREF_ERR_IRQ | 594 IRQ0STATUS_CCDC_LSC_DONE_IRQ | 595 IRQ0STATUS_CCDC_VD0_IRQ | 596 IRQ0STATUS_CCDC_VD1_IRQ | 597 IRQ0STATUS_HS_VS_IRQ; 598 struct isp_device *isp = _isp; 599 u32 irqstatus; 600 601 irqstatus = isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS); 602 isp_reg_writel(isp, irqstatus, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS); 603 604 isp_isr_sbl(isp); 605 606 if (irqstatus & IRQ0STATUS_CSIA_IRQ) 607 omap3isp_csi2_isr(&isp->isp_csi2a); 608 609 if (irqstatus & IRQ0STATUS_CSIB_IRQ) 610 omap3isp_ccp2_isr(&isp->isp_ccp2); 611 612 if (irqstatus & IRQ0STATUS_CCDC_VD0_IRQ) { 613 if (isp->isp_ccdc.output & CCDC_OUTPUT_PREVIEW) 614 omap3isp_preview_isr_frame_sync(&isp->isp_prev); 615 if (isp->isp_ccdc.output & CCDC_OUTPUT_RESIZER) 616 omap3isp_resizer_isr_frame_sync(&isp->isp_res); 617 omap3isp_stat_isr_frame_sync(&isp->isp_aewb); 618 omap3isp_stat_isr_frame_sync(&isp->isp_af); 619 omap3isp_stat_isr_frame_sync(&isp->isp_hist); 620 } 621 622 if (irqstatus & ccdc_events) 623 omap3isp_ccdc_isr(&isp->isp_ccdc, irqstatus & ccdc_events); 624 625 if (irqstatus & IRQ0STATUS_PRV_DONE_IRQ) { 626 if (isp->isp_prev.output & PREVIEW_OUTPUT_RESIZER) 627 omap3isp_resizer_isr_frame_sync(&isp->isp_res); 628 omap3isp_preview_isr(&isp->isp_prev); 629 } 630 631 if (irqstatus & IRQ0STATUS_RSZ_DONE_IRQ) 632 omap3isp_resizer_isr(&isp->isp_res); 633 634 if (irqstatus & IRQ0STATUS_H3A_AWB_DONE_IRQ) 635 omap3isp_stat_isr(&isp->isp_aewb); 636 637 if (irqstatus & IRQ0STATUS_H3A_AF_DONE_IRQ) 638 omap3isp_stat_isr(&isp->isp_af); 639 640 if (irqstatus & IRQ0STATUS_HIST_DONE_IRQ) 641 omap3isp_stat_isr(&isp->isp_hist); 642 643 omap3isp_flush(isp); 644 645 #if defined(DEBUG) && defined(ISP_ISR_DEBUG) 646 isp_isr_dbg(isp, irqstatus); 647 #endif 648 649 return IRQ_HANDLED; 650 } 651 652 static const struct media_device_ops isp_media_ops = { 653 .link_notify = v4l2_pipeline_link_notify, 654 }; 655 656 /* ----------------------------------------------------------------------------- 657 * Pipeline stream management 658 */ 659 660 /* 661 * isp_pipeline_enable - Enable streaming on a pipeline 662 * @pipe: ISP pipeline 663 * @mode: Stream mode (single shot or continuous) 664 * 665 * Walk the entities chain starting at the pipeline output video node and start 666 * all modules in the chain in the given mode. 667 * 668 * Return 0 if successful, or the return value of the failed video::s_stream 669 * operation otherwise. 670 */ 671 static int isp_pipeline_enable(struct isp_pipeline *pipe, 672 enum isp_pipeline_stream_state mode) 673 { 674 struct isp_device *isp = pipe->output->isp; 675 struct media_entity *entity; 676 struct media_pad *pad; 677 struct v4l2_subdev *subdev; 678 unsigned long flags; 679 int ret; 680 681 /* Refuse to start streaming if an entity included in the pipeline has 682 * crashed. This check must be performed before the loop below to avoid 683 * starting entities if the pipeline won't start anyway (those entities 684 * would then likely fail to stop, making the problem worse). 685 */ 686 if (media_entity_enum_intersects(&pipe->ent_enum, &isp->crashed)) 687 return -EIO; 688 689 spin_lock_irqsave(&pipe->lock, flags); 690 pipe->state &= ~(ISP_PIPELINE_IDLE_INPUT | ISP_PIPELINE_IDLE_OUTPUT); 691 spin_unlock_irqrestore(&pipe->lock, flags); 692 693 pipe->do_propagation = false; 694 695 mutex_lock(&isp->media_dev.graph_mutex); 696 697 entity = &pipe->output->video.entity; 698 while (1) { 699 pad = &entity->pads[0]; 700 if (!(pad->flags & MEDIA_PAD_FL_SINK)) 701 break; 702 703 pad = media_pad_remote_pad_first(pad); 704 if (!pad || !is_media_entity_v4l2_subdev(pad->entity)) 705 break; 706 707 entity = pad->entity; 708 subdev = media_entity_to_v4l2_subdev(entity); 709 710 ret = v4l2_subdev_call(subdev, video, s_stream, mode); 711 if (ret < 0 && ret != -ENOIOCTLCMD) { 712 mutex_unlock(&isp->media_dev.graph_mutex); 713 return ret; 714 } 715 716 if (subdev == &isp->isp_ccdc.subdev) { 717 v4l2_subdev_call(&isp->isp_aewb.subdev, video, 718 s_stream, mode); 719 v4l2_subdev_call(&isp->isp_af.subdev, video, 720 s_stream, mode); 721 v4l2_subdev_call(&isp->isp_hist.subdev, video, 722 s_stream, mode); 723 pipe->do_propagation = true; 724 } 725 726 /* Stop at the first external sub-device. */ 727 if (subdev->dev != isp->dev) 728 break; 729 } 730 731 mutex_unlock(&isp->media_dev.graph_mutex); 732 733 return 0; 734 } 735 736 static int isp_pipeline_wait_resizer(struct isp_device *isp) 737 { 738 return omap3isp_resizer_busy(&isp->isp_res); 739 } 740 741 static int isp_pipeline_wait_preview(struct isp_device *isp) 742 { 743 return omap3isp_preview_busy(&isp->isp_prev); 744 } 745 746 static int isp_pipeline_wait_ccdc(struct isp_device *isp) 747 { 748 return omap3isp_stat_busy(&isp->isp_af) 749 || omap3isp_stat_busy(&isp->isp_aewb) 750 || omap3isp_stat_busy(&isp->isp_hist) 751 || omap3isp_ccdc_busy(&isp->isp_ccdc); 752 } 753 754 #define ISP_STOP_TIMEOUT msecs_to_jiffies(1000) 755 756 static int isp_pipeline_wait(struct isp_device *isp, 757 int(*busy)(struct isp_device *isp)) 758 { 759 unsigned long timeout = jiffies + ISP_STOP_TIMEOUT; 760 761 while (!time_after(jiffies, timeout)) { 762 if (!busy(isp)) 763 return 0; 764 } 765 766 return 1; 767 } 768 769 /* 770 * isp_pipeline_disable - Disable streaming on a pipeline 771 * @pipe: ISP pipeline 772 * 773 * Walk the entities chain starting at the pipeline output video node and stop 774 * all modules in the chain. Wait synchronously for the modules to be stopped if 775 * necessary. 776 * 777 * Return 0 if all modules have been properly stopped, or -ETIMEDOUT if a module 778 * can't be stopped (in which case a software reset of the ISP is probably 779 * necessary). 780 */ 781 static int isp_pipeline_disable(struct isp_pipeline *pipe) 782 { 783 struct isp_device *isp = pipe->output->isp; 784 struct media_entity *entity; 785 struct media_pad *pad; 786 struct v4l2_subdev *subdev; 787 int failure = 0; 788 int ret; 789 790 /* 791 * We need to stop all the modules after CCDC first or they'll 792 * never stop since they may not get a full frame from CCDC. 793 */ 794 entity = &pipe->output->video.entity; 795 while (1) { 796 pad = &entity->pads[0]; 797 if (!(pad->flags & MEDIA_PAD_FL_SINK)) 798 break; 799 800 pad = media_pad_remote_pad_first(pad); 801 if (!pad || !is_media_entity_v4l2_subdev(pad->entity)) 802 break; 803 804 entity = pad->entity; 805 subdev = media_entity_to_v4l2_subdev(entity); 806 807 if (subdev == &isp->isp_ccdc.subdev) { 808 v4l2_subdev_call(&isp->isp_aewb.subdev, 809 video, s_stream, 0); 810 v4l2_subdev_call(&isp->isp_af.subdev, 811 video, s_stream, 0); 812 v4l2_subdev_call(&isp->isp_hist.subdev, 813 video, s_stream, 0); 814 } 815 816 ret = v4l2_subdev_call(subdev, video, s_stream, 0); 817 818 /* Stop at the first external sub-device. */ 819 if (subdev->dev != isp->dev) 820 break; 821 822 if (subdev == &isp->isp_res.subdev) 823 ret |= isp_pipeline_wait(isp, isp_pipeline_wait_resizer); 824 else if (subdev == &isp->isp_prev.subdev) 825 ret |= isp_pipeline_wait(isp, isp_pipeline_wait_preview); 826 else if (subdev == &isp->isp_ccdc.subdev) 827 ret |= isp_pipeline_wait(isp, isp_pipeline_wait_ccdc); 828 829 /* Handle stop failures. An entity that fails to stop can 830 * usually just be restarted. Flag the stop failure nonetheless 831 * to trigger an ISP reset the next time the device is released, 832 * just in case. 833 * 834 * The preview engine is a special case. A failure to stop can 835 * mean a hardware crash. When that happens the preview engine 836 * won't respond to read/write operations on the L4 bus anymore, 837 * resulting in a bus fault and a kernel oops next time it gets 838 * accessed. Mark it as crashed to prevent pipelines including 839 * it from being started. 840 */ 841 if (ret) { 842 dev_info(isp->dev, "Unable to stop %s\n", subdev->name); 843 isp->stop_failure = true; 844 if (subdev == &isp->isp_prev.subdev) 845 media_entity_enum_set(&isp->crashed, 846 &subdev->entity); 847 failure = -ETIMEDOUT; 848 } 849 } 850 851 return failure; 852 } 853 854 /* 855 * omap3isp_pipeline_set_stream - Enable/disable streaming on a pipeline 856 * @pipe: ISP pipeline 857 * @state: Stream state (stopped, single shot or continuous) 858 * 859 * Set the pipeline to the given stream state. Pipelines can be started in 860 * single-shot or continuous mode. 861 * 862 * Return 0 if successful, or the return value of the failed video::s_stream 863 * operation otherwise. The pipeline state is not updated when the operation 864 * fails, except when stopping the pipeline. 865 */ 866 int omap3isp_pipeline_set_stream(struct isp_pipeline *pipe, 867 enum isp_pipeline_stream_state state) 868 { 869 int ret; 870 871 if (state == ISP_PIPELINE_STREAM_STOPPED) 872 ret = isp_pipeline_disable(pipe); 873 else 874 ret = isp_pipeline_enable(pipe, state); 875 876 if (ret == 0 || state == ISP_PIPELINE_STREAM_STOPPED) 877 pipe->stream_state = state; 878 879 return ret; 880 } 881 882 /* 883 * omap3isp_pipeline_cancel_stream - Cancel stream on a pipeline 884 * @pipe: ISP pipeline 885 * 886 * Cancelling a stream mark all buffers on all video nodes in the pipeline as 887 * erroneous and makes sure no new buffer can be queued. This function is called 888 * when a fatal error that prevents any further operation on the pipeline 889 * occurs. 890 */ 891 void omap3isp_pipeline_cancel_stream(struct isp_pipeline *pipe) 892 { 893 if (pipe->input) 894 omap3isp_video_cancel_stream(pipe->input); 895 if (pipe->output) 896 omap3isp_video_cancel_stream(pipe->output); 897 } 898 899 /* 900 * isp_pipeline_resume - Resume streaming on a pipeline 901 * @pipe: ISP pipeline 902 * 903 * Resume video output and input and re-enable pipeline. 904 */ 905 static void isp_pipeline_resume(struct isp_pipeline *pipe) 906 { 907 int singleshot = pipe->stream_state == ISP_PIPELINE_STREAM_SINGLESHOT; 908 909 omap3isp_video_resume(pipe->output, !singleshot); 910 if (singleshot) 911 omap3isp_video_resume(pipe->input, 0); 912 isp_pipeline_enable(pipe, pipe->stream_state); 913 } 914 915 /* 916 * isp_pipeline_suspend - Suspend streaming on a pipeline 917 * @pipe: ISP pipeline 918 * 919 * Suspend pipeline. 920 */ 921 static void isp_pipeline_suspend(struct isp_pipeline *pipe) 922 { 923 isp_pipeline_disable(pipe); 924 } 925 926 /* 927 * isp_pipeline_is_last - Verify if entity has an enabled link to the output 928 * video node 929 * @me: ISP module's media entity 930 * 931 * Returns 1 if the entity has an enabled link to the output video node or 0 932 * otherwise. It's true only while pipeline can have no more than one output 933 * node. 934 */ 935 static int isp_pipeline_is_last(struct media_entity *me) 936 { 937 struct isp_pipeline *pipe; 938 struct media_pad *pad; 939 940 if (!me->pipe) 941 return 0; 942 pipe = to_isp_pipeline(me); 943 if (pipe->stream_state == ISP_PIPELINE_STREAM_STOPPED) 944 return 0; 945 pad = media_pad_remote_pad_first(&pipe->output->pad); 946 return pad->entity == me; 947 } 948 949 /* 950 * isp_suspend_module_pipeline - Suspend pipeline to which belongs the module 951 * @me: ISP module's media entity 952 * 953 * Suspend the whole pipeline if module's entity has an enabled link to the 954 * output video node. It works only while pipeline can have no more than one 955 * output node. 956 */ 957 static void isp_suspend_module_pipeline(struct media_entity *me) 958 { 959 if (isp_pipeline_is_last(me)) 960 isp_pipeline_suspend(to_isp_pipeline(me)); 961 } 962 963 /* 964 * isp_resume_module_pipeline - Resume pipeline to which belongs the module 965 * @me: ISP module's media entity 966 * 967 * Resume the whole pipeline if module's entity has an enabled link to the 968 * output video node. It works only while pipeline can have no more than one 969 * output node. 970 */ 971 static void isp_resume_module_pipeline(struct media_entity *me) 972 { 973 if (isp_pipeline_is_last(me)) 974 isp_pipeline_resume(to_isp_pipeline(me)); 975 } 976 977 /* 978 * isp_suspend_modules - Suspend ISP submodules. 979 * @isp: OMAP3 ISP device 980 * 981 * Returns 0 if suspend left in idle state all the submodules properly, 982 * or returns 1 if a general Reset is required to suspend the submodules. 983 */ 984 static int __maybe_unused isp_suspend_modules(struct isp_device *isp) 985 { 986 unsigned long timeout; 987 988 omap3isp_stat_suspend(&isp->isp_aewb); 989 omap3isp_stat_suspend(&isp->isp_af); 990 omap3isp_stat_suspend(&isp->isp_hist); 991 isp_suspend_module_pipeline(&isp->isp_res.subdev.entity); 992 isp_suspend_module_pipeline(&isp->isp_prev.subdev.entity); 993 isp_suspend_module_pipeline(&isp->isp_ccdc.subdev.entity); 994 isp_suspend_module_pipeline(&isp->isp_csi2a.subdev.entity); 995 isp_suspend_module_pipeline(&isp->isp_ccp2.subdev.entity); 996 997 timeout = jiffies + ISP_STOP_TIMEOUT; 998 while (omap3isp_stat_busy(&isp->isp_af) 999 || omap3isp_stat_busy(&isp->isp_aewb) 1000 || omap3isp_stat_busy(&isp->isp_hist) 1001 || omap3isp_preview_busy(&isp->isp_prev) 1002 || omap3isp_resizer_busy(&isp->isp_res) 1003 || omap3isp_ccdc_busy(&isp->isp_ccdc)) { 1004 if (time_after(jiffies, timeout)) { 1005 dev_info(isp->dev, "can't stop modules.\n"); 1006 return 1; 1007 } 1008 msleep(1); 1009 } 1010 1011 return 0; 1012 } 1013 1014 /* 1015 * isp_resume_modules - Resume ISP submodules. 1016 * @isp: OMAP3 ISP device 1017 */ 1018 static void __maybe_unused isp_resume_modules(struct isp_device *isp) 1019 { 1020 omap3isp_stat_resume(&isp->isp_aewb); 1021 omap3isp_stat_resume(&isp->isp_af); 1022 omap3isp_stat_resume(&isp->isp_hist); 1023 isp_resume_module_pipeline(&isp->isp_res.subdev.entity); 1024 isp_resume_module_pipeline(&isp->isp_prev.subdev.entity); 1025 isp_resume_module_pipeline(&isp->isp_ccdc.subdev.entity); 1026 isp_resume_module_pipeline(&isp->isp_csi2a.subdev.entity); 1027 isp_resume_module_pipeline(&isp->isp_ccp2.subdev.entity); 1028 } 1029 1030 /* 1031 * isp_reset - Reset ISP with a timeout wait for idle. 1032 * @isp: OMAP3 ISP device 1033 */ 1034 static int isp_reset(struct isp_device *isp) 1035 { 1036 unsigned long timeout = 0; 1037 1038 isp_reg_writel(isp, 1039 isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, ISP_SYSCONFIG) 1040 | ISP_SYSCONFIG_SOFTRESET, 1041 OMAP3_ISP_IOMEM_MAIN, ISP_SYSCONFIG); 1042 while (!(isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, 1043 ISP_SYSSTATUS) & 0x1)) { 1044 if (timeout++ > 10000) { 1045 dev_alert(isp->dev, "cannot reset ISP\n"); 1046 return -ETIMEDOUT; 1047 } 1048 udelay(1); 1049 } 1050 1051 isp->stop_failure = false; 1052 media_entity_enum_zero(&isp->crashed); 1053 return 0; 1054 } 1055 1056 /* 1057 * isp_save_context - Saves the values of the ISP module registers. 1058 * @isp: OMAP3 ISP device 1059 * @reg_list: Structure containing pairs of register address and value to 1060 * modify on OMAP. 1061 */ 1062 static void 1063 isp_save_context(struct isp_device *isp, struct isp_reg *reg_list) 1064 { 1065 struct isp_reg *next = reg_list; 1066 1067 for (; next->reg != ISP_TOK_TERM; next++) 1068 next->val = isp_reg_readl(isp, next->mmio_range, next->reg); 1069 } 1070 1071 /* 1072 * isp_restore_context - Restores the values of the ISP module registers. 1073 * @isp: OMAP3 ISP device 1074 * @reg_list: Structure containing pairs of register address and value to 1075 * modify on OMAP. 1076 */ 1077 static void 1078 isp_restore_context(struct isp_device *isp, struct isp_reg *reg_list) 1079 { 1080 struct isp_reg *next = reg_list; 1081 1082 for (; next->reg != ISP_TOK_TERM; next++) 1083 isp_reg_writel(isp, next->val, next->mmio_range, next->reg); 1084 } 1085 1086 /* 1087 * isp_save_ctx - Saves ISP, CCDC, HIST, H3A, PREV, RESZ & MMU context. 1088 * @isp: OMAP3 ISP device 1089 * 1090 * Routine for saving the context of each module in the ISP. 1091 * CCDC, HIST, H3A, PREV, RESZ and MMU. 1092 */ 1093 static void isp_save_ctx(struct isp_device *isp) 1094 { 1095 isp_save_context(isp, isp_reg_list); 1096 omap_iommu_save_ctx(isp->dev); 1097 } 1098 1099 /* 1100 * isp_restore_ctx - Restores ISP, CCDC, HIST, H3A, PREV, RESZ & MMU context. 1101 * @isp: OMAP3 ISP device 1102 * 1103 * Routine for restoring the context of each module in the ISP. 1104 * CCDC, HIST, H3A, PREV, RESZ and MMU. 1105 */ 1106 static void isp_restore_ctx(struct isp_device *isp) 1107 { 1108 isp_restore_context(isp, isp_reg_list); 1109 omap_iommu_restore_ctx(isp->dev); 1110 omap3isp_ccdc_restore_context(isp); 1111 omap3isp_preview_restore_context(isp); 1112 } 1113 1114 /* ----------------------------------------------------------------------------- 1115 * SBL resources management 1116 */ 1117 #define OMAP3_ISP_SBL_READ (OMAP3_ISP_SBL_CSI1_READ | \ 1118 OMAP3_ISP_SBL_CCDC_LSC_READ | \ 1119 OMAP3_ISP_SBL_PREVIEW_READ | \ 1120 OMAP3_ISP_SBL_RESIZER_READ) 1121 #define OMAP3_ISP_SBL_WRITE (OMAP3_ISP_SBL_CSI1_WRITE | \ 1122 OMAP3_ISP_SBL_CSI2A_WRITE | \ 1123 OMAP3_ISP_SBL_CSI2C_WRITE | \ 1124 OMAP3_ISP_SBL_CCDC_WRITE | \ 1125 OMAP3_ISP_SBL_PREVIEW_WRITE) 1126 1127 void omap3isp_sbl_enable(struct isp_device *isp, enum isp_sbl_resource res) 1128 { 1129 u32 sbl = 0; 1130 1131 isp->sbl_resources |= res; 1132 1133 if (isp->sbl_resources & OMAP3_ISP_SBL_CSI1_READ) 1134 sbl |= ISPCTRL_SBL_SHARED_RPORTA; 1135 1136 if (isp->sbl_resources & OMAP3_ISP_SBL_CCDC_LSC_READ) 1137 sbl |= ISPCTRL_SBL_SHARED_RPORTB; 1138 1139 if (isp->sbl_resources & OMAP3_ISP_SBL_CSI2C_WRITE) 1140 sbl |= ISPCTRL_SBL_SHARED_WPORTC; 1141 1142 if (isp->sbl_resources & OMAP3_ISP_SBL_RESIZER_WRITE) 1143 sbl |= ISPCTRL_SBL_WR0_RAM_EN; 1144 1145 if (isp->sbl_resources & OMAP3_ISP_SBL_WRITE) 1146 sbl |= ISPCTRL_SBL_WR1_RAM_EN; 1147 1148 if (isp->sbl_resources & OMAP3_ISP_SBL_READ) 1149 sbl |= ISPCTRL_SBL_RD_RAM_EN; 1150 1151 isp_reg_set(isp, OMAP3_ISP_IOMEM_MAIN, ISP_CTRL, sbl); 1152 } 1153 1154 void omap3isp_sbl_disable(struct isp_device *isp, enum isp_sbl_resource res) 1155 { 1156 u32 sbl = 0; 1157 1158 isp->sbl_resources &= ~res; 1159 1160 if (!(isp->sbl_resources & OMAP3_ISP_SBL_CSI1_READ)) 1161 sbl |= ISPCTRL_SBL_SHARED_RPORTA; 1162 1163 if (!(isp->sbl_resources & OMAP3_ISP_SBL_CCDC_LSC_READ)) 1164 sbl |= ISPCTRL_SBL_SHARED_RPORTB; 1165 1166 if (!(isp->sbl_resources & OMAP3_ISP_SBL_CSI2C_WRITE)) 1167 sbl |= ISPCTRL_SBL_SHARED_WPORTC; 1168 1169 if (!(isp->sbl_resources & OMAP3_ISP_SBL_RESIZER_WRITE)) 1170 sbl |= ISPCTRL_SBL_WR0_RAM_EN; 1171 1172 if (!(isp->sbl_resources & OMAP3_ISP_SBL_WRITE)) 1173 sbl |= ISPCTRL_SBL_WR1_RAM_EN; 1174 1175 if (!(isp->sbl_resources & OMAP3_ISP_SBL_READ)) 1176 sbl |= ISPCTRL_SBL_RD_RAM_EN; 1177 1178 isp_reg_clr(isp, OMAP3_ISP_IOMEM_MAIN, ISP_CTRL, sbl); 1179 } 1180 1181 /* 1182 * isp_module_sync_idle - Helper to sync module with its idle state 1183 * @me: ISP submodule's media entity 1184 * @wait: ISP submodule's wait queue for streamoff/interrupt synchronization 1185 * @stopping: flag which tells module wants to stop 1186 * 1187 * This function checks if ISP submodule needs to wait for next interrupt. If 1188 * yes, makes the caller to sleep while waiting for such event. 1189 */ 1190 int omap3isp_module_sync_idle(struct media_entity *me, wait_queue_head_t *wait, 1191 atomic_t *stopping) 1192 { 1193 struct isp_pipeline *pipe = to_isp_pipeline(me); 1194 1195 if (pipe->stream_state == ISP_PIPELINE_STREAM_STOPPED || 1196 (pipe->stream_state == ISP_PIPELINE_STREAM_SINGLESHOT && 1197 !isp_pipeline_ready(pipe))) 1198 return 0; 1199 1200 /* 1201 * atomic_set() doesn't include memory barrier on ARM platform for SMP 1202 * scenario. We'll call it here to avoid race conditions. 1203 */ 1204 atomic_set(stopping, 1); 1205 smp_mb(); 1206 1207 /* 1208 * If module is the last one, it's writing to memory. In this case, 1209 * it's necessary to check if the module is already paused due to 1210 * DMA queue underrun or if it has to wait for next interrupt to be 1211 * idle. 1212 * If it isn't the last one, the function won't sleep but *stopping 1213 * will still be set to warn next submodule caller's interrupt the 1214 * module wants to be idle. 1215 */ 1216 if (isp_pipeline_is_last(me)) { 1217 struct isp_video *video = pipe->output; 1218 unsigned long flags; 1219 spin_lock_irqsave(&video->irqlock, flags); 1220 if (video->dmaqueue_flags & ISP_VIDEO_DMAQUEUE_UNDERRUN) { 1221 spin_unlock_irqrestore(&video->irqlock, flags); 1222 atomic_set(stopping, 0); 1223 smp_mb(); 1224 return 0; 1225 } 1226 spin_unlock_irqrestore(&video->irqlock, flags); 1227 if (!wait_event_timeout(*wait, !atomic_read(stopping), 1228 msecs_to_jiffies(1000))) { 1229 atomic_set(stopping, 0); 1230 smp_mb(); 1231 return -ETIMEDOUT; 1232 } 1233 } 1234 1235 return 0; 1236 } 1237 1238 /* 1239 * omap3isp_module_sync_is_stopping - Helper to verify if module was stopping 1240 * @wait: ISP submodule's wait queue for streamoff/interrupt synchronization 1241 * @stopping: flag which tells module wants to stop 1242 * 1243 * This function checks if ISP submodule was stopping. In case of yes, it 1244 * notices the caller by setting stopping to 0 and waking up the wait queue. 1245 * Returns 1 if it was stopping or 0 otherwise. 1246 */ 1247 int omap3isp_module_sync_is_stopping(wait_queue_head_t *wait, 1248 atomic_t *stopping) 1249 { 1250 if (atomic_cmpxchg(stopping, 1, 0)) { 1251 wake_up(wait); 1252 return 1; 1253 } 1254 1255 return 0; 1256 } 1257 1258 /* -------------------------------------------------------------------------- 1259 * Clock management 1260 */ 1261 1262 #define ISPCTRL_CLKS_MASK (ISPCTRL_H3A_CLK_EN | \ 1263 ISPCTRL_HIST_CLK_EN | \ 1264 ISPCTRL_RSZ_CLK_EN | \ 1265 (ISPCTRL_CCDC_CLK_EN | ISPCTRL_CCDC_RAM_EN) | \ 1266 (ISPCTRL_PREV_CLK_EN | ISPCTRL_PREV_RAM_EN)) 1267 1268 static void __isp_subclk_update(struct isp_device *isp) 1269 { 1270 u32 clk = 0; 1271 1272 /* AEWB and AF share the same clock. */ 1273 if (isp->subclk_resources & 1274 (OMAP3_ISP_SUBCLK_AEWB | OMAP3_ISP_SUBCLK_AF)) 1275 clk |= ISPCTRL_H3A_CLK_EN; 1276 1277 if (isp->subclk_resources & OMAP3_ISP_SUBCLK_HIST) 1278 clk |= ISPCTRL_HIST_CLK_EN; 1279 1280 if (isp->subclk_resources & OMAP3_ISP_SUBCLK_RESIZER) 1281 clk |= ISPCTRL_RSZ_CLK_EN; 1282 1283 /* NOTE: For CCDC & Preview submodules, we need to affect internal 1284 * RAM as well. 1285 */ 1286 if (isp->subclk_resources & OMAP3_ISP_SUBCLK_CCDC) 1287 clk |= ISPCTRL_CCDC_CLK_EN | ISPCTRL_CCDC_RAM_EN; 1288 1289 if (isp->subclk_resources & OMAP3_ISP_SUBCLK_PREVIEW) 1290 clk |= ISPCTRL_PREV_CLK_EN | ISPCTRL_PREV_RAM_EN; 1291 1292 isp_reg_clr_set(isp, OMAP3_ISP_IOMEM_MAIN, ISP_CTRL, 1293 ISPCTRL_CLKS_MASK, clk); 1294 } 1295 1296 void omap3isp_subclk_enable(struct isp_device *isp, 1297 enum isp_subclk_resource res) 1298 { 1299 isp->subclk_resources |= res; 1300 1301 __isp_subclk_update(isp); 1302 } 1303 1304 void omap3isp_subclk_disable(struct isp_device *isp, 1305 enum isp_subclk_resource res) 1306 { 1307 isp->subclk_resources &= ~res; 1308 1309 __isp_subclk_update(isp); 1310 } 1311 1312 /* 1313 * isp_enable_clocks - Enable ISP clocks 1314 * @isp: OMAP3 ISP device 1315 * 1316 * Return 0 if successful, or clk_prepare_enable return value if any of them 1317 * fails. 1318 */ 1319 static int isp_enable_clocks(struct isp_device *isp) 1320 { 1321 int r; 1322 unsigned long rate; 1323 1324 r = clk_prepare_enable(isp->clock[ISP_CLK_CAM_ICK]); 1325 if (r) { 1326 dev_err(isp->dev, "failed to enable cam_ick clock\n"); 1327 goto out_clk_enable_ick; 1328 } 1329 r = clk_set_rate(isp->clock[ISP_CLK_CAM_MCLK], CM_CAM_MCLK_HZ); 1330 if (r) { 1331 dev_err(isp->dev, "clk_set_rate for cam_mclk failed\n"); 1332 goto out_clk_enable_mclk; 1333 } 1334 r = clk_prepare_enable(isp->clock[ISP_CLK_CAM_MCLK]); 1335 if (r) { 1336 dev_err(isp->dev, "failed to enable cam_mclk clock\n"); 1337 goto out_clk_enable_mclk; 1338 } 1339 rate = clk_get_rate(isp->clock[ISP_CLK_CAM_MCLK]); 1340 if (rate != CM_CAM_MCLK_HZ) 1341 dev_warn(isp->dev, "unexpected cam_mclk rate:\n" 1342 " expected : %d\n" 1343 " actual : %ld\n", CM_CAM_MCLK_HZ, rate); 1344 r = clk_prepare_enable(isp->clock[ISP_CLK_CSI2_FCK]); 1345 if (r) { 1346 dev_err(isp->dev, "failed to enable csi2_fck clock\n"); 1347 goto out_clk_enable_csi2_fclk; 1348 } 1349 return 0; 1350 1351 out_clk_enable_csi2_fclk: 1352 clk_disable_unprepare(isp->clock[ISP_CLK_CAM_MCLK]); 1353 out_clk_enable_mclk: 1354 clk_disable_unprepare(isp->clock[ISP_CLK_CAM_ICK]); 1355 out_clk_enable_ick: 1356 return r; 1357 } 1358 1359 /* 1360 * isp_disable_clocks - Disable ISP clocks 1361 * @isp: OMAP3 ISP device 1362 */ 1363 static void isp_disable_clocks(struct isp_device *isp) 1364 { 1365 clk_disable_unprepare(isp->clock[ISP_CLK_CAM_ICK]); 1366 clk_disable_unprepare(isp->clock[ISP_CLK_CAM_MCLK]); 1367 clk_disable_unprepare(isp->clock[ISP_CLK_CSI2_FCK]); 1368 } 1369 1370 static const char *isp_clocks[] = { 1371 "cam_ick", 1372 "cam_mclk", 1373 "csi2_96m_fck", 1374 "l3_ick", 1375 }; 1376 1377 static int isp_get_clocks(struct isp_device *isp) 1378 { 1379 struct clk *clk; 1380 unsigned int i; 1381 1382 for (i = 0; i < ARRAY_SIZE(isp_clocks); ++i) { 1383 clk = devm_clk_get(isp->dev, isp_clocks[i]); 1384 if (IS_ERR(clk)) { 1385 dev_err(isp->dev, "clk_get %s failed\n", isp_clocks[i]); 1386 return PTR_ERR(clk); 1387 } 1388 1389 isp->clock[i] = clk; 1390 } 1391 1392 return 0; 1393 } 1394 1395 /* 1396 * omap3isp_get - Acquire the ISP resource. 1397 * 1398 * Initializes the clocks for the first acquire. 1399 * 1400 * Increment the reference count on the ISP. If the first reference is taken, 1401 * enable clocks and power-up all submodules. 1402 * 1403 * Return a pointer to the ISP device structure, or NULL if an error occurred. 1404 */ 1405 static struct isp_device *__omap3isp_get(struct isp_device *isp, bool irq) 1406 { 1407 struct isp_device *__isp = isp; 1408 1409 if (isp == NULL) 1410 return NULL; 1411 1412 mutex_lock(&isp->isp_mutex); 1413 if (isp->ref_count > 0) 1414 goto out; 1415 1416 if (isp_enable_clocks(isp) < 0) { 1417 __isp = NULL; 1418 goto out; 1419 } 1420 1421 /* We don't want to restore context before saving it! */ 1422 if (isp->has_context) 1423 isp_restore_ctx(isp); 1424 1425 if (irq) 1426 isp_enable_interrupts(isp); 1427 1428 out: 1429 if (__isp != NULL) 1430 isp->ref_count++; 1431 mutex_unlock(&isp->isp_mutex); 1432 1433 return __isp; 1434 } 1435 1436 struct isp_device *omap3isp_get(struct isp_device *isp) 1437 { 1438 return __omap3isp_get(isp, true); 1439 } 1440 1441 /* 1442 * omap3isp_put - Release the ISP 1443 * 1444 * Decrement the reference count on the ISP. If the last reference is released, 1445 * power-down all submodules, disable clocks and free temporary buffers. 1446 */ 1447 static void __omap3isp_put(struct isp_device *isp, bool save_ctx) 1448 { 1449 if (isp == NULL) 1450 return; 1451 1452 mutex_lock(&isp->isp_mutex); 1453 BUG_ON(isp->ref_count == 0); 1454 if (--isp->ref_count == 0) { 1455 isp_disable_interrupts(isp); 1456 if (save_ctx) { 1457 isp_save_ctx(isp); 1458 isp->has_context = 1; 1459 } 1460 /* Reset the ISP if an entity has failed to stop. This is the 1461 * only way to recover from such conditions. 1462 */ 1463 if (!media_entity_enum_empty(&isp->crashed) || 1464 isp->stop_failure) 1465 isp_reset(isp); 1466 isp_disable_clocks(isp); 1467 } 1468 mutex_unlock(&isp->isp_mutex); 1469 } 1470 1471 void omap3isp_put(struct isp_device *isp) 1472 { 1473 __omap3isp_put(isp, true); 1474 } 1475 1476 /* -------------------------------------------------------------------------- 1477 * Platform device driver 1478 */ 1479 1480 /* 1481 * omap3isp_print_status - Prints the values of the ISP Control Module registers 1482 * @isp: OMAP3 ISP device 1483 */ 1484 #define ISP_PRINT_REGISTER(isp, name)\ 1485 dev_dbg(isp->dev, "###ISP " #name "=0x%08x\n", \ 1486 isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, ISP_##name)) 1487 #define SBL_PRINT_REGISTER(isp, name)\ 1488 dev_dbg(isp->dev, "###SBL " #name "=0x%08x\n", \ 1489 isp_reg_readl(isp, OMAP3_ISP_IOMEM_SBL, ISPSBL_##name)) 1490 1491 void omap3isp_print_status(struct isp_device *isp) 1492 { 1493 dev_dbg(isp->dev, "-------------ISP Register dump--------------\n"); 1494 1495 ISP_PRINT_REGISTER(isp, SYSCONFIG); 1496 ISP_PRINT_REGISTER(isp, SYSSTATUS); 1497 ISP_PRINT_REGISTER(isp, IRQ0ENABLE); 1498 ISP_PRINT_REGISTER(isp, IRQ0STATUS); 1499 ISP_PRINT_REGISTER(isp, TCTRL_GRESET_LENGTH); 1500 ISP_PRINT_REGISTER(isp, TCTRL_PSTRB_REPLAY); 1501 ISP_PRINT_REGISTER(isp, CTRL); 1502 ISP_PRINT_REGISTER(isp, TCTRL_CTRL); 1503 ISP_PRINT_REGISTER(isp, TCTRL_FRAME); 1504 ISP_PRINT_REGISTER(isp, TCTRL_PSTRB_DELAY); 1505 ISP_PRINT_REGISTER(isp, TCTRL_STRB_DELAY); 1506 ISP_PRINT_REGISTER(isp, TCTRL_SHUT_DELAY); 1507 ISP_PRINT_REGISTER(isp, TCTRL_PSTRB_LENGTH); 1508 ISP_PRINT_REGISTER(isp, TCTRL_STRB_LENGTH); 1509 ISP_PRINT_REGISTER(isp, TCTRL_SHUT_LENGTH); 1510 1511 SBL_PRINT_REGISTER(isp, PCR); 1512 SBL_PRINT_REGISTER(isp, SDR_REQ_EXP); 1513 1514 dev_dbg(isp->dev, "--------------------------------------------\n"); 1515 } 1516 1517 #ifdef CONFIG_PM 1518 1519 /* 1520 * Power management support. 1521 * 1522 * As the ISP can't properly handle an input video stream interruption on a non 1523 * frame boundary, the ISP pipelines need to be stopped before sensors get 1524 * suspended. However, as suspending the sensors can require a running clock, 1525 * which can be provided by the ISP, the ISP can't be completely suspended 1526 * before the sensor. 1527 * 1528 * To solve this problem power management support is split into prepare/complete 1529 * and suspend/resume operations. The pipelines are stopped in prepare() and the 1530 * ISP clocks get disabled in suspend(). Similarly, the clocks are re-enabled in 1531 * resume(), and the the pipelines are restarted in complete(). 1532 * 1533 * TODO: PM dependencies between the ISP and sensors are not modelled explicitly 1534 * yet. 1535 */ 1536 static int isp_pm_prepare(struct device *dev) 1537 { 1538 struct isp_device *isp = dev_get_drvdata(dev); 1539 int reset; 1540 1541 WARN_ON(mutex_is_locked(&isp->isp_mutex)); 1542 1543 if (isp->ref_count == 0) 1544 return 0; 1545 1546 reset = isp_suspend_modules(isp); 1547 isp_disable_interrupts(isp); 1548 isp_save_ctx(isp); 1549 if (reset) 1550 isp_reset(isp); 1551 1552 return 0; 1553 } 1554 1555 static int isp_pm_suspend(struct device *dev) 1556 { 1557 struct isp_device *isp = dev_get_drvdata(dev); 1558 1559 WARN_ON(mutex_is_locked(&isp->isp_mutex)); 1560 1561 if (isp->ref_count) 1562 isp_disable_clocks(isp); 1563 1564 return 0; 1565 } 1566 1567 static int isp_pm_resume(struct device *dev) 1568 { 1569 struct isp_device *isp = dev_get_drvdata(dev); 1570 1571 if (isp->ref_count == 0) 1572 return 0; 1573 1574 return isp_enable_clocks(isp); 1575 } 1576 1577 static void isp_pm_complete(struct device *dev) 1578 { 1579 struct isp_device *isp = dev_get_drvdata(dev); 1580 1581 if (isp->ref_count == 0) 1582 return; 1583 1584 isp_restore_ctx(isp); 1585 isp_enable_interrupts(isp); 1586 isp_resume_modules(isp); 1587 } 1588 1589 #else 1590 1591 #define isp_pm_prepare NULL 1592 #define isp_pm_suspend NULL 1593 #define isp_pm_resume NULL 1594 #define isp_pm_complete NULL 1595 1596 #endif /* CONFIG_PM */ 1597 1598 static void isp_unregister_entities(struct isp_device *isp) 1599 { 1600 media_device_unregister(&isp->media_dev); 1601 1602 omap3isp_csi2_unregister_entities(&isp->isp_csi2a); 1603 omap3isp_ccp2_unregister_entities(&isp->isp_ccp2); 1604 omap3isp_ccdc_unregister_entities(&isp->isp_ccdc); 1605 omap3isp_preview_unregister_entities(&isp->isp_prev); 1606 omap3isp_resizer_unregister_entities(&isp->isp_res); 1607 omap3isp_stat_unregister_entities(&isp->isp_aewb); 1608 omap3isp_stat_unregister_entities(&isp->isp_af); 1609 omap3isp_stat_unregister_entities(&isp->isp_hist); 1610 1611 v4l2_device_unregister(&isp->v4l2_dev); 1612 media_device_cleanup(&isp->media_dev); 1613 } 1614 1615 static int isp_link_entity( 1616 struct isp_device *isp, struct media_entity *entity, 1617 enum isp_interface_type interface) 1618 { 1619 struct media_entity *input; 1620 unsigned int flags; 1621 unsigned int pad; 1622 unsigned int i; 1623 1624 /* Connect the sensor to the correct interface module. 1625 * Parallel sensors are connected directly to the CCDC, while 1626 * serial sensors are connected to the CSI2a, CCP2b or CSI2c 1627 * receiver through CSIPHY1 or CSIPHY2. 1628 */ 1629 switch (interface) { 1630 case ISP_INTERFACE_PARALLEL: 1631 input = &isp->isp_ccdc.subdev.entity; 1632 pad = CCDC_PAD_SINK; 1633 flags = 0; 1634 break; 1635 1636 case ISP_INTERFACE_CSI2A_PHY2: 1637 input = &isp->isp_csi2a.subdev.entity; 1638 pad = CSI2_PAD_SINK; 1639 flags = MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED; 1640 break; 1641 1642 case ISP_INTERFACE_CCP2B_PHY1: 1643 case ISP_INTERFACE_CCP2B_PHY2: 1644 input = &isp->isp_ccp2.subdev.entity; 1645 pad = CCP2_PAD_SINK; 1646 flags = 0; 1647 break; 1648 1649 case ISP_INTERFACE_CSI2C_PHY1: 1650 input = &isp->isp_csi2c.subdev.entity; 1651 pad = CSI2_PAD_SINK; 1652 flags = MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED; 1653 break; 1654 1655 default: 1656 dev_err(isp->dev, "%s: invalid interface type %u\n", __func__, 1657 interface); 1658 return -EINVAL; 1659 } 1660 1661 /* 1662 * Not all interfaces are available on all revisions of the 1663 * ISP. The sub-devices of those interfaces aren't initialised 1664 * in such a case. Check this by ensuring the num_pads is 1665 * non-zero. 1666 */ 1667 if (!input->num_pads) { 1668 dev_err(isp->dev, "%s: invalid input %u\n", entity->name, 1669 interface); 1670 return -EINVAL; 1671 } 1672 1673 for (i = 0; i < entity->num_pads; i++) { 1674 if (entity->pads[i].flags & MEDIA_PAD_FL_SOURCE) 1675 break; 1676 } 1677 if (i == entity->num_pads) { 1678 dev_err(isp->dev, "%s: no source pad in external entity %s\n", 1679 __func__, entity->name); 1680 return -EINVAL; 1681 } 1682 1683 return media_create_pad_link(entity, i, input, pad, flags); 1684 } 1685 1686 static int isp_register_entities(struct isp_device *isp) 1687 { 1688 int ret; 1689 1690 isp->media_dev.dev = isp->dev; 1691 strscpy(isp->media_dev.model, "TI OMAP3 ISP", 1692 sizeof(isp->media_dev.model)); 1693 isp->media_dev.hw_revision = isp->revision; 1694 isp->media_dev.ops = &isp_media_ops; 1695 media_device_init(&isp->media_dev); 1696 1697 isp->v4l2_dev.mdev = &isp->media_dev; 1698 ret = v4l2_device_register(isp->dev, &isp->v4l2_dev); 1699 if (ret < 0) { 1700 dev_err(isp->dev, "%s: V4L2 device registration failed (%d)\n", 1701 __func__, ret); 1702 goto done; 1703 } 1704 1705 /* Register internal entities */ 1706 ret = omap3isp_ccp2_register_entities(&isp->isp_ccp2, &isp->v4l2_dev); 1707 if (ret < 0) 1708 goto done; 1709 1710 ret = omap3isp_csi2_register_entities(&isp->isp_csi2a, &isp->v4l2_dev); 1711 if (ret < 0) 1712 goto done; 1713 1714 ret = omap3isp_ccdc_register_entities(&isp->isp_ccdc, &isp->v4l2_dev); 1715 if (ret < 0) 1716 goto done; 1717 1718 ret = omap3isp_preview_register_entities(&isp->isp_prev, 1719 &isp->v4l2_dev); 1720 if (ret < 0) 1721 goto done; 1722 1723 ret = omap3isp_resizer_register_entities(&isp->isp_res, &isp->v4l2_dev); 1724 if (ret < 0) 1725 goto done; 1726 1727 ret = omap3isp_stat_register_entities(&isp->isp_aewb, &isp->v4l2_dev); 1728 if (ret < 0) 1729 goto done; 1730 1731 ret = omap3isp_stat_register_entities(&isp->isp_af, &isp->v4l2_dev); 1732 if (ret < 0) 1733 goto done; 1734 1735 ret = omap3isp_stat_register_entities(&isp->isp_hist, &isp->v4l2_dev); 1736 if (ret < 0) 1737 goto done; 1738 1739 done: 1740 if (ret < 0) 1741 isp_unregister_entities(isp); 1742 1743 return ret; 1744 } 1745 1746 /* 1747 * isp_create_links() - Create links for internal and external ISP entities 1748 * @isp : Pointer to ISP device 1749 * 1750 * This function creates all links between ISP internal and external entities. 1751 * 1752 * Return: A negative error code on failure or zero on success. Possible error 1753 * codes are those returned by media_create_pad_link(). 1754 */ 1755 static int isp_create_links(struct isp_device *isp) 1756 { 1757 int ret; 1758 1759 /* Create links between entities and video nodes. */ 1760 ret = media_create_pad_link( 1761 &isp->isp_csi2a.subdev.entity, CSI2_PAD_SOURCE, 1762 &isp->isp_csi2a.video_out.video.entity, 0, 0); 1763 if (ret < 0) 1764 return ret; 1765 1766 ret = media_create_pad_link( 1767 &isp->isp_ccp2.video_in.video.entity, 0, 1768 &isp->isp_ccp2.subdev.entity, CCP2_PAD_SINK, 0); 1769 if (ret < 0) 1770 return ret; 1771 1772 ret = media_create_pad_link( 1773 &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_OF, 1774 &isp->isp_ccdc.video_out.video.entity, 0, 0); 1775 if (ret < 0) 1776 return ret; 1777 1778 ret = media_create_pad_link( 1779 &isp->isp_prev.video_in.video.entity, 0, 1780 &isp->isp_prev.subdev.entity, PREV_PAD_SINK, 0); 1781 if (ret < 0) 1782 return ret; 1783 1784 ret = media_create_pad_link( 1785 &isp->isp_prev.subdev.entity, PREV_PAD_SOURCE, 1786 &isp->isp_prev.video_out.video.entity, 0, 0); 1787 if (ret < 0) 1788 return ret; 1789 1790 ret = media_create_pad_link( 1791 &isp->isp_res.video_in.video.entity, 0, 1792 &isp->isp_res.subdev.entity, RESZ_PAD_SINK, 0); 1793 if (ret < 0) 1794 return ret; 1795 1796 ret = media_create_pad_link( 1797 &isp->isp_res.subdev.entity, RESZ_PAD_SOURCE, 1798 &isp->isp_res.video_out.video.entity, 0, 0); 1799 1800 if (ret < 0) 1801 return ret; 1802 1803 /* Create links between entities. */ 1804 ret = media_create_pad_link( 1805 &isp->isp_csi2a.subdev.entity, CSI2_PAD_SOURCE, 1806 &isp->isp_ccdc.subdev.entity, CCDC_PAD_SINK, 0); 1807 if (ret < 0) 1808 return ret; 1809 1810 ret = media_create_pad_link( 1811 &isp->isp_ccp2.subdev.entity, CCP2_PAD_SOURCE, 1812 &isp->isp_ccdc.subdev.entity, CCDC_PAD_SINK, 0); 1813 if (ret < 0) 1814 return ret; 1815 1816 ret = media_create_pad_link( 1817 &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP, 1818 &isp->isp_prev.subdev.entity, PREV_PAD_SINK, 0); 1819 if (ret < 0) 1820 return ret; 1821 1822 ret = media_create_pad_link( 1823 &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_OF, 1824 &isp->isp_res.subdev.entity, RESZ_PAD_SINK, 0); 1825 if (ret < 0) 1826 return ret; 1827 1828 ret = media_create_pad_link( 1829 &isp->isp_prev.subdev.entity, PREV_PAD_SOURCE, 1830 &isp->isp_res.subdev.entity, RESZ_PAD_SINK, 0); 1831 if (ret < 0) 1832 return ret; 1833 1834 ret = media_create_pad_link( 1835 &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP, 1836 &isp->isp_aewb.subdev.entity, 0, 1837 MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE); 1838 if (ret < 0) 1839 return ret; 1840 1841 ret = media_create_pad_link( 1842 &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP, 1843 &isp->isp_af.subdev.entity, 0, 1844 MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE); 1845 if (ret < 0) 1846 return ret; 1847 1848 ret = media_create_pad_link( 1849 &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP, 1850 &isp->isp_hist.subdev.entity, 0, 1851 MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE); 1852 if (ret < 0) 1853 return ret; 1854 1855 return 0; 1856 } 1857 1858 static void isp_cleanup_modules(struct isp_device *isp) 1859 { 1860 omap3isp_h3a_aewb_cleanup(isp); 1861 omap3isp_h3a_af_cleanup(isp); 1862 omap3isp_hist_cleanup(isp); 1863 omap3isp_resizer_cleanup(isp); 1864 omap3isp_preview_cleanup(isp); 1865 omap3isp_ccdc_cleanup(isp); 1866 omap3isp_ccp2_cleanup(isp); 1867 omap3isp_csi2_cleanup(isp); 1868 omap3isp_csiphy_cleanup(isp); 1869 } 1870 1871 static int isp_initialize_modules(struct isp_device *isp) 1872 { 1873 int ret; 1874 1875 ret = omap3isp_csiphy_init(isp); 1876 if (ret < 0) { 1877 dev_err(isp->dev, "CSI PHY initialization failed\n"); 1878 return ret; 1879 } 1880 1881 ret = omap3isp_csi2_init(isp); 1882 if (ret < 0) { 1883 dev_err(isp->dev, "CSI2 initialization failed\n"); 1884 goto error_csi2; 1885 } 1886 1887 ret = omap3isp_ccp2_init(isp); 1888 if (ret < 0) { 1889 if (ret != -EPROBE_DEFER) 1890 dev_err(isp->dev, "CCP2 initialization failed\n"); 1891 goto error_ccp2; 1892 } 1893 1894 ret = omap3isp_ccdc_init(isp); 1895 if (ret < 0) { 1896 dev_err(isp->dev, "CCDC initialization failed\n"); 1897 goto error_ccdc; 1898 } 1899 1900 ret = omap3isp_preview_init(isp); 1901 if (ret < 0) { 1902 dev_err(isp->dev, "Preview initialization failed\n"); 1903 goto error_preview; 1904 } 1905 1906 ret = omap3isp_resizer_init(isp); 1907 if (ret < 0) { 1908 dev_err(isp->dev, "Resizer initialization failed\n"); 1909 goto error_resizer; 1910 } 1911 1912 ret = omap3isp_hist_init(isp); 1913 if (ret < 0) { 1914 dev_err(isp->dev, "Histogram initialization failed\n"); 1915 goto error_hist; 1916 } 1917 1918 ret = omap3isp_h3a_aewb_init(isp); 1919 if (ret < 0) { 1920 dev_err(isp->dev, "H3A AEWB initialization failed\n"); 1921 goto error_h3a_aewb; 1922 } 1923 1924 ret = omap3isp_h3a_af_init(isp); 1925 if (ret < 0) { 1926 dev_err(isp->dev, "H3A AF initialization failed\n"); 1927 goto error_h3a_af; 1928 } 1929 1930 return 0; 1931 1932 error_h3a_af: 1933 omap3isp_h3a_aewb_cleanup(isp); 1934 error_h3a_aewb: 1935 omap3isp_hist_cleanup(isp); 1936 error_hist: 1937 omap3isp_resizer_cleanup(isp); 1938 error_resizer: 1939 omap3isp_preview_cleanup(isp); 1940 error_preview: 1941 omap3isp_ccdc_cleanup(isp); 1942 error_ccdc: 1943 omap3isp_ccp2_cleanup(isp); 1944 error_ccp2: 1945 omap3isp_csi2_cleanup(isp); 1946 error_csi2: 1947 omap3isp_csiphy_cleanup(isp); 1948 1949 return ret; 1950 } 1951 1952 static void isp_detach_iommu(struct isp_device *isp) 1953 { 1954 #ifdef CONFIG_ARM_DMA_USE_IOMMU 1955 arm_iommu_detach_device(isp->dev); 1956 arm_iommu_release_mapping(isp->mapping); 1957 isp->mapping = NULL; 1958 #endif 1959 } 1960 1961 static int isp_attach_iommu(struct isp_device *isp) 1962 { 1963 #ifdef CONFIG_ARM_DMA_USE_IOMMU 1964 struct dma_iommu_mapping *mapping; 1965 int ret; 1966 1967 /* 1968 * Create the ARM mapping, used by the ARM DMA mapping core to allocate 1969 * VAs. This will allocate a corresponding IOMMU domain. 1970 */ 1971 mapping = arm_iommu_create_mapping(&platform_bus_type, SZ_1G, SZ_2G); 1972 if (IS_ERR(mapping)) { 1973 dev_err(isp->dev, "failed to create ARM IOMMU mapping\n"); 1974 return PTR_ERR(mapping); 1975 } 1976 1977 isp->mapping = mapping; 1978 1979 /* Attach the ARM VA mapping to the device. */ 1980 ret = arm_iommu_attach_device(isp->dev, mapping); 1981 if (ret < 0) { 1982 dev_err(isp->dev, "failed to attach device to VA mapping\n"); 1983 goto error; 1984 } 1985 1986 return 0; 1987 1988 error: 1989 arm_iommu_release_mapping(isp->mapping); 1990 isp->mapping = NULL; 1991 return ret; 1992 #else 1993 return -ENODEV; 1994 #endif 1995 } 1996 1997 /* 1998 * isp_remove - Remove ISP platform device 1999 * @pdev: Pointer to ISP platform device 2000 * 2001 * Always returns 0. 2002 */ 2003 static int isp_remove(struct platform_device *pdev) 2004 { 2005 struct isp_device *isp = platform_get_drvdata(pdev); 2006 2007 v4l2_async_nf_unregister(&isp->notifier); 2008 isp_unregister_entities(isp); 2009 isp_cleanup_modules(isp); 2010 isp_xclk_cleanup(isp); 2011 2012 __omap3isp_get(isp, false); 2013 isp_detach_iommu(isp); 2014 __omap3isp_put(isp, false); 2015 2016 media_entity_enum_cleanup(&isp->crashed); 2017 v4l2_async_nf_cleanup(&isp->notifier); 2018 2019 kfree(isp); 2020 2021 return 0; 2022 } 2023 2024 enum isp_of_phy { 2025 ISP_OF_PHY_PARALLEL = 0, 2026 ISP_OF_PHY_CSIPHY1, 2027 ISP_OF_PHY_CSIPHY2, 2028 }; 2029 2030 static int isp_subdev_notifier_complete(struct v4l2_async_notifier *async) 2031 { 2032 struct isp_device *isp = container_of(async, struct isp_device, 2033 notifier); 2034 struct v4l2_device *v4l2_dev = &isp->v4l2_dev; 2035 struct v4l2_subdev *sd; 2036 int ret; 2037 2038 mutex_lock(&isp->media_dev.graph_mutex); 2039 2040 ret = media_entity_enum_init(&isp->crashed, &isp->media_dev); 2041 if (ret) { 2042 mutex_unlock(&isp->media_dev.graph_mutex); 2043 return ret; 2044 } 2045 2046 list_for_each_entry(sd, &v4l2_dev->subdevs, list) { 2047 if (sd->notifier != &isp->notifier) 2048 continue; 2049 2050 ret = isp_link_entity(isp, &sd->entity, 2051 v4l2_subdev_to_bus_cfg(sd)->interface); 2052 if (ret < 0) { 2053 mutex_unlock(&isp->media_dev.graph_mutex); 2054 return ret; 2055 } 2056 } 2057 2058 mutex_unlock(&isp->media_dev.graph_mutex); 2059 2060 ret = v4l2_device_register_subdev_nodes(&isp->v4l2_dev); 2061 if (ret < 0) 2062 return ret; 2063 2064 return media_device_register(&isp->media_dev); 2065 } 2066 2067 static void isp_parse_of_parallel_endpoint(struct device *dev, 2068 struct v4l2_fwnode_endpoint *vep, 2069 struct isp_bus_cfg *buscfg) 2070 { 2071 buscfg->interface = ISP_INTERFACE_PARALLEL; 2072 buscfg->bus.parallel.data_lane_shift = vep->bus.parallel.data_shift; 2073 buscfg->bus.parallel.clk_pol = 2074 !!(vep->bus.parallel.flags & V4L2_MBUS_PCLK_SAMPLE_FALLING); 2075 buscfg->bus.parallel.hs_pol = 2076 !!(vep->bus.parallel.flags & V4L2_MBUS_VSYNC_ACTIVE_LOW); 2077 buscfg->bus.parallel.vs_pol = 2078 !!(vep->bus.parallel.flags & V4L2_MBUS_HSYNC_ACTIVE_LOW); 2079 buscfg->bus.parallel.fld_pol = 2080 !!(vep->bus.parallel.flags & V4L2_MBUS_FIELD_EVEN_LOW); 2081 buscfg->bus.parallel.data_pol = 2082 !!(vep->bus.parallel.flags & V4L2_MBUS_DATA_ACTIVE_LOW); 2083 buscfg->bus.parallel.bt656 = vep->bus_type == V4L2_MBUS_BT656; 2084 } 2085 2086 static void isp_parse_of_csi2_endpoint(struct device *dev, 2087 struct v4l2_fwnode_endpoint *vep, 2088 struct isp_bus_cfg *buscfg) 2089 { 2090 unsigned int i; 2091 2092 buscfg->bus.csi2.lanecfg.clk.pos = vep->bus.mipi_csi2.clock_lane; 2093 buscfg->bus.csi2.lanecfg.clk.pol = 2094 vep->bus.mipi_csi2.lane_polarities[0]; 2095 dev_dbg(dev, "clock lane polarity %u, pos %u\n", 2096 buscfg->bus.csi2.lanecfg.clk.pol, 2097 buscfg->bus.csi2.lanecfg.clk.pos); 2098 2099 buscfg->bus.csi2.num_data_lanes = vep->bus.mipi_csi2.num_data_lanes; 2100 2101 for (i = 0; i < buscfg->bus.csi2.num_data_lanes; i++) { 2102 buscfg->bus.csi2.lanecfg.data[i].pos = 2103 vep->bus.mipi_csi2.data_lanes[i]; 2104 buscfg->bus.csi2.lanecfg.data[i].pol = 2105 vep->bus.mipi_csi2.lane_polarities[i + 1]; 2106 dev_dbg(dev, 2107 "data lane %u polarity %u, pos %u\n", i, 2108 buscfg->bus.csi2.lanecfg.data[i].pol, 2109 buscfg->bus.csi2.lanecfg.data[i].pos); 2110 } 2111 /* 2112 * FIXME: now we assume the CRC is always there. Implement a way to 2113 * obtain this information from the sensor. Frame descriptors, perhaps? 2114 */ 2115 buscfg->bus.csi2.crc = 1; 2116 } 2117 2118 static void isp_parse_of_csi1_endpoint(struct device *dev, 2119 struct v4l2_fwnode_endpoint *vep, 2120 struct isp_bus_cfg *buscfg) 2121 { 2122 buscfg->bus.ccp2.lanecfg.clk.pos = vep->bus.mipi_csi1.clock_lane; 2123 buscfg->bus.ccp2.lanecfg.clk.pol = vep->bus.mipi_csi1.lane_polarity[0]; 2124 dev_dbg(dev, "clock lane polarity %u, pos %u\n", 2125 buscfg->bus.ccp2.lanecfg.clk.pol, 2126 buscfg->bus.ccp2.lanecfg.clk.pos); 2127 2128 buscfg->bus.ccp2.lanecfg.data[0].pos = vep->bus.mipi_csi1.data_lane; 2129 buscfg->bus.ccp2.lanecfg.data[0].pol = 2130 vep->bus.mipi_csi1.lane_polarity[1]; 2131 2132 dev_dbg(dev, "data lane polarity %u, pos %u\n", 2133 buscfg->bus.ccp2.lanecfg.data[0].pol, 2134 buscfg->bus.ccp2.lanecfg.data[0].pos); 2135 2136 buscfg->bus.ccp2.strobe_clk_pol = vep->bus.mipi_csi1.clock_inv; 2137 buscfg->bus.ccp2.phy_layer = vep->bus.mipi_csi1.strobe; 2138 buscfg->bus.ccp2.ccp2_mode = vep->bus_type == V4L2_MBUS_CCP2; 2139 buscfg->bus.ccp2.vp_clk_pol = 1; 2140 2141 buscfg->bus.ccp2.crc = 1; 2142 } 2143 2144 static struct { 2145 u32 phy; 2146 u32 csi2_if; 2147 u32 csi1_if; 2148 } isp_bus_interfaces[2] = { 2149 { ISP_OF_PHY_CSIPHY1, 2150 ISP_INTERFACE_CSI2C_PHY1, ISP_INTERFACE_CCP2B_PHY1 }, 2151 { ISP_OF_PHY_CSIPHY2, 2152 ISP_INTERFACE_CSI2A_PHY2, ISP_INTERFACE_CCP2B_PHY2 }, 2153 }; 2154 2155 static int isp_parse_of_endpoints(struct isp_device *isp) 2156 { 2157 struct fwnode_handle *ep; 2158 struct isp_async_subdev *isd = NULL; 2159 unsigned int i; 2160 2161 ep = fwnode_graph_get_endpoint_by_id( 2162 dev_fwnode(isp->dev), ISP_OF_PHY_PARALLEL, 0, 2163 FWNODE_GRAPH_ENDPOINT_NEXT); 2164 2165 if (ep) { 2166 struct v4l2_fwnode_endpoint vep = { 2167 .bus_type = V4L2_MBUS_PARALLEL 2168 }; 2169 int ret; 2170 2171 dev_dbg(isp->dev, "parsing parallel interface\n"); 2172 2173 ret = v4l2_fwnode_endpoint_parse(ep, &vep); 2174 2175 if (!ret) { 2176 isd = v4l2_async_nf_add_fwnode_remote(&isp->notifier, 2177 ep, struct 2178 isp_async_subdev); 2179 if (!IS_ERR(isd)) 2180 isp_parse_of_parallel_endpoint(isp->dev, &vep, &isd->bus); 2181 } 2182 2183 fwnode_handle_put(ep); 2184 } 2185 2186 for (i = 0; i < ARRAY_SIZE(isp_bus_interfaces); i++) { 2187 struct v4l2_fwnode_endpoint vep = { 2188 .bus_type = V4L2_MBUS_CSI2_DPHY 2189 }; 2190 int ret; 2191 2192 ep = fwnode_graph_get_endpoint_by_id( 2193 dev_fwnode(isp->dev), isp_bus_interfaces[i].phy, 0, 2194 FWNODE_GRAPH_ENDPOINT_NEXT); 2195 2196 if (!ep) 2197 continue; 2198 2199 dev_dbg(isp->dev, "parsing serial interface %u, node %pOF\n", i, 2200 to_of_node(ep)); 2201 2202 ret = v4l2_fwnode_endpoint_parse(ep, &vep); 2203 if (ret == -ENXIO) { 2204 vep = (struct v4l2_fwnode_endpoint) 2205 { .bus_type = V4L2_MBUS_CSI1 }; 2206 ret = v4l2_fwnode_endpoint_parse(ep, &vep); 2207 2208 if (ret == -ENXIO) { 2209 vep = (struct v4l2_fwnode_endpoint) 2210 { .bus_type = V4L2_MBUS_CCP2 }; 2211 ret = v4l2_fwnode_endpoint_parse(ep, &vep); 2212 } 2213 } 2214 2215 if (!ret) { 2216 isd = v4l2_async_nf_add_fwnode_remote(&isp->notifier, 2217 ep, 2218 struct 2219 isp_async_subdev); 2220 2221 if (!IS_ERR(isd)) { 2222 switch (vep.bus_type) { 2223 case V4L2_MBUS_CSI2_DPHY: 2224 isd->bus.interface = 2225 isp_bus_interfaces[i].csi2_if; 2226 isp_parse_of_csi2_endpoint(isp->dev, &vep, &isd->bus); 2227 break; 2228 case V4L2_MBUS_CSI1: 2229 case V4L2_MBUS_CCP2: 2230 isd->bus.interface = 2231 isp_bus_interfaces[i].csi1_if; 2232 isp_parse_of_csi1_endpoint(isp->dev, &vep, 2233 &isd->bus); 2234 break; 2235 default: 2236 break; 2237 } 2238 } 2239 } 2240 2241 fwnode_handle_put(ep); 2242 } 2243 2244 return 0; 2245 } 2246 2247 static const struct v4l2_async_notifier_operations isp_subdev_notifier_ops = { 2248 .complete = isp_subdev_notifier_complete, 2249 }; 2250 2251 /* 2252 * isp_probe - Probe ISP platform device 2253 * @pdev: Pointer to ISP platform device 2254 * 2255 * Returns 0 if successful, 2256 * -ENOMEM if no memory available, 2257 * -ENODEV if no platform device resources found 2258 * or no space for remapping registers, 2259 * -EINVAL if couldn't install ISR, 2260 * or clk_get return error value. 2261 */ 2262 static int isp_probe(struct platform_device *pdev) 2263 { 2264 struct isp_device *isp; 2265 struct resource *mem; 2266 int ret; 2267 int i, m; 2268 2269 isp = kzalloc(sizeof(*isp), GFP_KERNEL); 2270 if (!isp) { 2271 dev_err(&pdev->dev, "could not allocate memory\n"); 2272 return -ENOMEM; 2273 } 2274 2275 ret = fwnode_property_read_u32(of_fwnode_handle(pdev->dev.of_node), 2276 "ti,phy-type", &isp->phy_type); 2277 if (ret) 2278 goto error_release_isp; 2279 2280 isp->syscon = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, 2281 "syscon"); 2282 if (IS_ERR(isp->syscon)) { 2283 ret = PTR_ERR(isp->syscon); 2284 goto error_release_isp; 2285 } 2286 2287 ret = of_property_read_u32_index(pdev->dev.of_node, 2288 "syscon", 1, &isp->syscon_offset); 2289 if (ret) 2290 goto error_release_isp; 2291 2292 isp->autoidle = autoidle; 2293 2294 mutex_init(&isp->isp_mutex); 2295 spin_lock_init(&isp->stat_lock); 2296 v4l2_async_nf_init(&isp->notifier); 2297 isp->dev = &pdev->dev; 2298 2299 ret = isp_parse_of_endpoints(isp); 2300 if (ret < 0) 2301 goto error; 2302 2303 isp->ref_count = 0; 2304 2305 ret = dma_coerce_mask_and_coherent(isp->dev, DMA_BIT_MASK(32)); 2306 if (ret) 2307 goto error; 2308 2309 platform_set_drvdata(pdev, isp); 2310 2311 /* Regulators */ 2312 isp->isp_csiphy1.vdd = devm_regulator_get(&pdev->dev, "vdd-csiphy1"); 2313 isp->isp_csiphy2.vdd = devm_regulator_get(&pdev->dev, "vdd-csiphy2"); 2314 2315 /* Clocks 2316 * 2317 * The ISP clock tree is revision-dependent. We thus need to enable ICLK 2318 * manually to read the revision before calling __omap3isp_get(). 2319 * 2320 * Start by mapping the ISP MMIO area, which is in two pieces. 2321 * The ISP IOMMU is in between. Map both now, and fill in the 2322 * ISP revision specific portions a little later in the 2323 * function. 2324 */ 2325 for (i = 0; i < 2; i++) { 2326 unsigned int map_idx = i ? OMAP3_ISP_IOMEM_CSI2A_REGS1 : 0; 2327 2328 mem = platform_get_resource(pdev, IORESOURCE_MEM, i); 2329 isp->mmio_base[map_idx] = 2330 devm_ioremap_resource(isp->dev, mem); 2331 if (IS_ERR(isp->mmio_base[map_idx])) { 2332 ret = PTR_ERR(isp->mmio_base[map_idx]); 2333 goto error; 2334 } 2335 } 2336 2337 ret = isp_get_clocks(isp); 2338 if (ret < 0) 2339 goto error; 2340 2341 ret = clk_enable(isp->clock[ISP_CLK_CAM_ICK]); 2342 if (ret < 0) 2343 goto error; 2344 2345 isp->revision = isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, ISP_REVISION); 2346 dev_info(isp->dev, "Revision %d.%d found\n", 2347 (isp->revision & 0xf0) >> 4, isp->revision & 0x0f); 2348 2349 clk_disable(isp->clock[ISP_CLK_CAM_ICK]); 2350 2351 if (__omap3isp_get(isp, false) == NULL) { 2352 ret = -ENODEV; 2353 goto error; 2354 } 2355 2356 ret = isp_reset(isp); 2357 if (ret < 0) 2358 goto error_isp; 2359 2360 ret = isp_xclk_init(isp); 2361 if (ret < 0) 2362 goto error_isp; 2363 2364 /* Memory resources */ 2365 for (m = 0; m < ARRAY_SIZE(isp_res_maps); m++) 2366 if (isp->revision == isp_res_maps[m].isp_rev) 2367 break; 2368 2369 if (m == ARRAY_SIZE(isp_res_maps)) { 2370 dev_err(isp->dev, "No resource map found for ISP rev %d.%d\n", 2371 (isp->revision & 0xf0) >> 4, isp->revision & 0xf); 2372 ret = -ENODEV; 2373 goto error_isp; 2374 } 2375 2376 for (i = 1; i < OMAP3_ISP_IOMEM_CSI2A_REGS1; i++) 2377 isp->mmio_base[i] = 2378 isp->mmio_base[0] + isp_res_maps[m].offset[i]; 2379 2380 for (i = OMAP3_ISP_IOMEM_CSIPHY2; i < OMAP3_ISP_IOMEM_LAST; i++) 2381 isp->mmio_base[i] = 2382 isp->mmio_base[OMAP3_ISP_IOMEM_CSI2A_REGS1] 2383 + isp_res_maps[m].offset[i]; 2384 2385 isp->mmio_hist_base_phys = 2386 mem->start + isp_res_maps[m].offset[OMAP3_ISP_IOMEM_HIST]; 2387 2388 /* IOMMU */ 2389 ret = isp_attach_iommu(isp); 2390 if (ret < 0) { 2391 dev_err(&pdev->dev, "unable to attach to IOMMU\n"); 2392 goto error_isp; 2393 } 2394 2395 /* Interrupt */ 2396 ret = platform_get_irq(pdev, 0); 2397 if (ret <= 0) { 2398 ret = -ENODEV; 2399 goto error_iommu; 2400 } 2401 isp->irq_num = ret; 2402 2403 if (devm_request_irq(isp->dev, isp->irq_num, isp_isr, IRQF_SHARED, 2404 "OMAP3 ISP", isp)) { 2405 dev_err(isp->dev, "Unable to request IRQ\n"); 2406 ret = -EINVAL; 2407 goto error_iommu; 2408 } 2409 2410 /* Entities */ 2411 ret = isp_initialize_modules(isp); 2412 if (ret < 0) 2413 goto error_iommu; 2414 2415 ret = isp_register_entities(isp); 2416 if (ret < 0) 2417 goto error_modules; 2418 2419 ret = isp_create_links(isp); 2420 if (ret < 0) 2421 goto error_register_entities; 2422 2423 isp->notifier.ops = &isp_subdev_notifier_ops; 2424 2425 ret = v4l2_async_nf_register(&isp->v4l2_dev, &isp->notifier); 2426 if (ret) 2427 goto error_register_entities; 2428 2429 isp_core_init(isp, 1); 2430 omap3isp_put(isp); 2431 2432 return 0; 2433 2434 error_register_entities: 2435 isp_unregister_entities(isp); 2436 error_modules: 2437 isp_cleanup_modules(isp); 2438 error_iommu: 2439 isp_detach_iommu(isp); 2440 error_isp: 2441 isp_xclk_cleanup(isp); 2442 __omap3isp_put(isp, false); 2443 error: 2444 v4l2_async_nf_cleanup(&isp->notifier); 2445 mutex_destroy(&isp->isp_mutex); 2446 error_release_isp: 2447 kfree(isp); 2448 2449 return ret; 2450 } 2451 2452 static const struct dev_pm_ops omap3isp_pm_ops = { 2453 .prepare = isp_pm_prepare, 2454 .suspend = isp_pm_suspend, 2455 .resume = isp_pm_resume, 2456 .complete = isp_pm_complete, 2457 }; 2458 2459 static const struct platform_device_id omap3isp_id_table[] = { 2460 { "omap3isp", 0 }, 2461 { }, 2462 }; 2463 MODULE_DEVICE_TABLE(platform, omap3isp_id_table); 2464 2465 static const struct of_device_id omap3isp_of_table[] = { 2466 { .compatible = "ti,omap3-isp" }, 2467 { }, 2468 }; 2469 MODULE_DEVICE_TABLE(of, omap3isp_of_table); 2470 2471 static struct platform_driver omap3isp_driver = { 2472 .probe = isp_probe, 2473 .remove = isp_remove, 2474 .id_table = omap3isp_id_table, 2475 .driver = { 2476 .name = "omap3isp", 2477 .pm = &omap3isp_pm_ops, 2478 .of_match_table = omap3isp_of_table, 2479 }, 2480 }; 2481 2482 module_platform_driver(omap3isp_driver); 2483 2484 MODULE_AUTHOR("Nokia Corporation"); 2485 MODULE_DESCRIPTION("TI OMAP3 ISP driver"); 2486 MODULE_LICENSE("GPL"); 2487 MODULE_VERSION(ISP_VIDEO_DRIVER_VERSION); 2488