Merge branch 'topic/omap3isp' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

+3 -1

drivers/media/platform/Kconfig

··· 93 93 94 94 config VIDEO_OMAP3 95 95 tristate "OMAP 3 Camera support" 96 - depends on OMAP_IOVMM && VIDEO_V4L2 && I2C && VIDEO_V4L2_SUBDEV_API && ARCH_OMAP3 96 + depends on VIDEO_V4L2 && I2C && VIDEO_V4L2_SUBDEV_API && ARCH_OMAP3 97 + select ARM_DMA_USE_IOMMU 98 + select OMAP_IOMMU 97 99 ---help--- 98 100 Driver for an OMAP 3 camera controller. 99 101

+1 -1

drivers/media/platform/omap3isp/Makefile

··· 3 3 ccflags-$(CONFIG_VIDEO_OMAP3_DEBUG) += -DDEBUG 4 4 5 5 omap3-isp-objs += \ 6 - isp.o ispqueue.o ispvideo.o \ 6 + isp.o ispvideo.o \ 7 7 ispcsiphy.o ispccp2.o ispcsi2.o \ 8 8 ispccdc.o isppreview.o ispresizer.o \ 9 9 ispstat.o isph3a_aewb.o isph3a_af.o isphist.o

+79 -29

drivers/media/platform/omap3isp/isp.c

··· 69 69 #include <linux/sched.h> 70 70 #include <linux/vmalloc.h> 71 71 72 + #include <asm/dma-iommu.h> 73 + 72 74 #include <media/v4l2-common.h> 73 75 #include <media/v4l2-device.h> 74 76 ··· 1399 1397 if (isp_pipeline_is_last(me)) { 1400 1398 struct isp_video *video = pipe->output; 1401 1399 unsigned long flags; 1402 - spin_lock_irqsave(&video->queue->irqlock, flags); 1400 + spin_lock_irqsave(&video->irqlock, flags); 1403 1401 if (video->dmaqueue_flags & ISP_VIDEO_DMAQUEUE_UNDERRUN) { 1404 - spin_unlock_irqrestore(&video->queue->irqlock, flags); 1402 + spin_unlock_irqrestore(&video->irqlock, flags); 1405 1403 atomic_set(stopping, 0); 1406 1404 smp_mb(); 1407 1405 return 0; 1408 1406 } 1409 - spin_unlock_irqrestore(&video->queue->irqlock, flags); 1407 + spin_unlock_irqrestore(&video->irqlock, flags); 1410 1408 if (!wait_event_timeout(*wait, !atomic_read(stopping), 1411 1409 msecs_to_jiffies(1000))) { 1412 1410 atomic_set(stopping, 0); ··· 1627 1625 * Decrement the reference count on the ISP. If the last reference is released, 1628 1626 * power-down all submodules, disable clocks and free temporary buffers. 1629 1627 */ 1630 - void omap3isp_put(struct isp_device *isp) 1628 + static void __omap3isp_put(struct isp_device *isp, bool save_ctx) 1631 1629 { 1632 1630 if (isp == NULL) 1633 1631 return; ··· 1636 1634 BUG_ON(isp->ref_count == 0); 1637 1635 if (--isp->ref_count == 0) { 1638 1636 isp_disable_interrupts(isp); 1639 - if (isp->domain) { 1637 + if (save_ctx) { 1640 1638 isp_save_ctx(isp); 1641 1639 isp->has_context = 1; 1642 1640 } ··· 1648 1646 isp_disable_clocks(isp); 1649 1647 } 1650 1648 mutex_unlock(&isp->isp_mutex); 1649 + } 1650 + 1651 + void omap3isp_put(struct isp_device *isp) 1652 + { 1653 + __omap3isp_put(isp, true); 1651 1654 } 1652 1655 1653 1656 /* -------------------------------------------------------------------------- ··· 2127 2120 return ret; 2128 2121 } 2129 2122 2123 + static void isp_detach_iommu(struct isp_device *isp) 2124 + { 2125 + arm_iommu_release_mapping(isp->mapping); 2126 + isp->mapping = NULL; 2127 + iommu_group_remove_device(isp->dev); 2128 + } 2129 + 2130 + static int isp_attach_iommu(struct isp_device *isp) 2131 + { 2132 + struct dma_iommu_mapping *mapping; 2133 + struct iommu_group *group; 2134 + int ret; 2135 + 2136 + /* Create a device group and add the device to it. */ 2137 + group = iommu_group_alloc(); 2138 + if (IS_ERR(group)) { 2139 + dev_err(isp->dev, "failed to allocate IOMMU group\n"); 2140 + return PTR_ERR(group); 2141 + } 2142 + 2143 + ret = iommu_group_add_device(group, isp->dev); 2144 + iommu_group_put(group); 2145 + 2146 + if (ret < 0) { 2147 + dev_err(isp->dev, "failed to add device to IPMMU group\n"); 2148 + return ret; 2149 + } 2150 + 2151 + /* 2152 + * Create the ARM mapping, used by the ARM DMA mapping core to allocate 2153 + * VAs. This will allocate a corresponding IOMMU domain. 2154 + */ 2155 + mapping = arm_iommu_create_mapping(&platform_bus_type, SZ_1G, SZ_2G); 2156 + if (IS_ERR(mapping)) { 2157 + dev_err(isp->dev, "failed to create ARM IOMMU mapping\n"); 2158 + ret = PTR_ERR(mapping); 2159 + goto error; 2160 + } 2161 + 2162 + isp->mapping = mapping; 2163 + 2164 + /* Attach the ARM VA mapping to the device. */ 2165 + ret = arm_iommu_attach_device(isp->dev, mapping); 2166 + if (ret < 0) { 2167 + dev_err(isp->dev, "failed to attach device to VA mapping\n"); 2168 + goto error; 2169 + } 2170 + 2171 + return 0; 2172 + 2173 + error: 2174 + isp_detach_iommu(isp); 2175 + return ret; 2176 + } 2177 + 2130 2178 /* 2131 2179 * isp_remove - Remove ISP platform device 2132 2180 * @pdev: Pointer to ISP platform device ··· 2197 2135 isp_xclk_cleanup(isp); 2198 2136 2199 2137 __omap3isp_get(isp, false); 2200 - iommu_detach_device(isp->domain, &pdev->dev); 2201 - iommu_domain_free(isp->domain); 2202 - isp->domain = NULL; 2203 - omap3isp_put(isp); 2138 + isp_detach_iommu(isp); 2139 + __omap3isp_put(isp, false); 2204 2140 2205 2141 return 0; 2206 2142 } ··· 2325 2265 } 2326 2266 } 2327 2267 2328 - isp->domain = iommu_domain_alloc(pdev->dev.bus); 2329 - if (!isp->domain) { 2330 - dev_err(isp->dev, "can't alloc iommu domain\n"); 2331 - ret = -ENOMEM; 2268 + /* IOMMU */ 2269 + ret = isp_attach_iommu(isp); 2270 + if (ret < 0) { 2271 + dev_err(&pdev->dev, "unable to attach to IOMMU\n"); 2332 2272 goto error_isp; 2333 - } 2334 - 2335 - ret = iommu_attach_device(isp->domain, &pdev->dev); 2336 - if (ret) { 2337 - dev_err(&pdev->dev, "can't attach iommu device: %d\n", ret); 2338 - ret = -EPROBE_DEFER; 2339 - goto free_domain; 2340 2273 } 2341 2274 2342 2275 /* Interrupt */ ··· 2337 2284 if (isp->irq_num <= 0) { 2338 2285 dev_err(isp->dev, "No IRQ resource\n"); 2339 2286 ret = -ENODEV; 2340 - goto detach_dev; 2287 + goto error_iommu; 2341 2288 } 2342 2289 2343 2290 if (devm_request_irq(isp->dev, isp->irq_num, isp_isr, IRQF_SHARED, 2344 2291 "OMAP3 ISP", isp)) { 2345 2292 dev_err(isp->dev, "Unable to request IRQ\n"); 2346 2293 ret = -EINVAL; 2347 - goto detach_dev; 2294 + goto error_iommu; 2348 2295 } 2349 2296 2350 2297 /* Entities */ 2351 2298 ret = isp_initialize_modules(isp); 2352 2299 if (ret < 0) 2353 - goto detach_dev; 2300 + goto error_iommu; 2354 2301 2355 2302 ret = isp_register_entities(isp); 2356 2303 if (ret < 0) ··· 2363 2310 2364 2311 error_modules: 2365 2312 isp_cleanup_modules(isp); 2366 - detach_dev: 2367 - iommu_detach_device(isp->domain, &pdev->dev); 2368 - free_domain: 2369 - iommu_domain_free(isp->domain); 2370 - isp->domain = NULL; 2313 + error_iommu: 2314 + isp_detach_iommu(isp); 2371 2315 error_isp: 2372 2316 isp_xclk_cleanup(isp); 2373 - omap3isp_put(isp); 2317 + __omap3isp_put(isp, false); 2374 2318 error: 2375 2319 mutex_destroy(&isp->isp_mutex); 2376 2320

+3 -5

drivers/media/platform/omap3isp/isp.h

··· 45 45 #include "ispcsi2.h" 46 46 #include "ispccp2.h" 47 47 48 - #define IOMMU_FLAG (IOVMF_ENDIAN_LITTLE | IOVMF_ELSZ_8) 49 - 50 48 #define ISP_TOK_TERM 0xFFFFFFFF /* 51 49 * terminating token for ISP 52 50 * modules reg list ··· 150 152 * regions. 151 153 * @mmio_base_phys: Array with physical L4 bus addresses for ISP register 152 154 * regions. 155 + * @mapping: IOMMU mapping 153 156 * @stat_lock: Spinlock for handling statistics 154 157 * @isp_mutex: Mutex for serializing requests to ISP. 155 158 * @stop_failure: Indicates that an entity failed to stop. ··· 170 171 * @isp_res: Pointer to current settings for ISP Resizer. 171 172 * @isp_prev: Pointer to current settings for ISP Preview. 172 173 * @isp_ccdc: Pointer to current settings for ISP CCDC. 173 - * @iommu: Pointer to requested IOMMU instance for ISP. 174 174 * @platform_cb: ISP driver callback function pointers for platform code 175 175 * 176 176 * This structure is used to store the OMAP ISP Information. ··· 186 188 187 189 void __iomem *mmio_base[OMAP3_ISP_IOMEM_LAST]; 188 190 unsigned long mmio_base_phys[OMAP3_ISP_IOMEM_LAST]; 191 + 192 + struct dma_iommu_mapping *mapping; 189 193 190 194 /* ISP Obj */ 191 195 spinlock_t stat_lock; /* common lock for statistic drivers */ ··· 219 219 220 220 unsigned int sbl_resources; 221 221 unsigned int subclk_resources; 222 - 223 - struct iommu_domain *domain; 224 222 }; 225 223 226 224 #define v4l2_dev_to_isp_device(dev) \

+53 -54

drivers/media/platform/omap3isp/ispccdc.c

··· 30 30 #include <linux/device.h> 31 31 #include <linux/dma-mapping.h> 32 32 #include <linux/mm.h> 33 - #include <linux/omap-iommu.h> 34 33 #include <linux/sched.h> 35 34 #include <linux/slab.h> 36 35 #include <media/v4l2-event.h> ··· 205 206 * ccdc_lsc_program_table - Program Lens Shading Compensation table address. 206 207 * @ccdc: Pointer to ISP CCDC device. 207 208 */ 208 - static void ccdc_lsc_program_table(struct isp_ccdc_device *ccdc, u32 addr) 209 + static void ccdc_lsc_program_table(struct isp_ccdc_device *ccdc, 210 + dma_addr_t addr) 209 211 { 210 212 isp_reg_writel(to_isp_device(ccdc), addr, 211 213 OMAP3_ISP_IOMEM_CCDC, ISPCCDC_LSC_TABLE_BASE); ··· 333 333 return -EBUSY; 334 334 335 335 ccdc_lsc_setup_regs(ccdc, &req->config); 336 - ccdc_lsc_program_table(ccdc, req->table); 336 + ccdc_lsc_program_table(ccdc, req->table.dma); 337 337 return 0; 338 338 } 339 339 ··· 368 368 if (req == NULL) 369 369 return; 370 370 371 - if (req->iovm) 372 - dma_unmap_sg(isp->dev, req->iovm->sgt->sgl, 373 - req->iovm->sgt->nents, DMA_TO_DEVICE); 374 - if (req->table) 375 - omap_iommu_vfree(isp->domain, isp->dev, req->table); 371 + if (req->table.addr) { 372 + sg_free_table(&req->table.sgt); 373 + dma_free_coherent(isp->dev, req->config.size, req->table.addr, 374 + req->table.dma); 375 + } 376 + 376 377 kfree(req); 377 378 } 378 379 ··· 417 416 struct isp_device *isp = to_isp_device(ccdc); 418 417 struct ispccdc_lsc_config_req *req; 419 418 unsigned long flags; 420 - void *table; 421 419 u16 update; 422 420 int ret; 423 421 ··· 444 444 445 445 req->enable = 1; 446 446 447 - req->table = omap_iommu_vmalloc(isp->domain, isp->dev, 0, 448 - req->config.size, IOMMU_FLAG); 449 - if (IS_ERR_VALUE(req->table)) { 450 - req->table = 0; 447 + req->table.addr = dma_alloc_coherent(isp->dev, req->config.size, 448 + &req->table.dma, 449 + GFP_KERNEL); 450 + if (req->table.addr == NULL) { 451 451 ret = -ENOMEM; 452 452 goto done; 453 453 } 454 454 455 - req->iovm = omap_find_iovm_area(isp->dev, req->table); 456 - if (req->iovm == NULL) { 457 - ret = -ENOMEM; 455 + ret = dma_get_sgtable(isp->dev, &req->table.sgt, 456 + req->table.addr, req->table.dma, 457 + req->config.size); 458 + if (ret < 0) 458 459 goto done; 459 - } 460 460 461 - if (!dma_map_sg(isp->dev, req->iovm->sgt->sgl, 462 - req->iovm->sgt->nents, DMA_TO_DEVICE)) { 463 - ret = -ENOMEM; 464 - req->iovm = NULL; 465 - goto done; 466 - } 461 + dma_sync_sg_for_cpu(isp->dev, req->table.sgt.sgl, 462 + req->table.sgt.nents, DMA_TO_DEVICE); 467 463 468 - dma_sync_sg_for_cpu(isp->dev, req->iovm->sgt->sgl, 469 - req->iovm->sgt->nents, DMA_TO_DEVICE); 470 - 471 - table = omap_da_to_va(isp->dev, req->table); 472 - if (copy_from_user(table, config->lsc, req->config.size)) { 464 + if (copy_from_user(req->table.addr, config->lsc, 465 + req->config.size)) { 473 466 ret = -EFAULT; 474 467 goto done; 475 468 } 476 469 477 - dma_sync_sg_for_device(isp->dev, req->iovm->sgt->sgl, 478 - req->iovm->sgt->nents, DMA_TO_DEVICE); 470 + dma_sync_sg_for_device(isp->dev, req->table.sgt.sgl, 471 + req->table.sgt.nents, DMA_TO_DEVICE); 479 472 } 480 473 481 474 spin_lock_irqsave(&ccdc->lsc.req_lock, flags); ··· 577 584 if (!ccdc->fpc_en) 578 585 return; 579 586 580 - isp_reg_writel(isp, ccdc->fpc.fpcaddr, OMAP3_ISP_IOMEM_CCDC, 587 + isp_reg_writel(isp, ccdc->fpc.dma, OMAP3_ISP_IOMEM_CCDC, 581 588 ISPCCDC_FPC_ADDR); 582 589 /* The FPNUM field must be set before enabling FPC. */ 583 590 isp_reg_writel(isp, (ccdc->fpc.fpnum << ISPCCDC_FPC_FPNUM_SHIFT), ··· 717 724 ccdc->shadow_update = 0; 718 725 719 726 if (OMAP3ISP_CCDC_FPC & ccdc_struct->update) { 720 - u32 table_old = 0; 721 - u32 table_new; 727 + struct omap3isp_ccdc_fpc fpc; 728 + struct ispccdc_fpc fpc_old = { .addr = NULL, }; 729 + struct ispccdc_fpc fpc_new; 722 730 u32 size; 723 731 724 732 if (ccdc->state != ISP_PIPELINE_STREAM_STOPPED) ··· 728 734 ccdc->fpc_en = !!(OMAP3ISP_CCDC_FPC & ccdc_struct->flag); 729 735 730 736 if (ccdc->fpc_en) { 731 - if (copy_from_user(&ccdc->fpc, ccdc_struct->fpc, 732 - sizeof(ccdc->fpc))) 737 + if (copy_from_user(&fpc, ccdc_struct->fpc, sizeof(fpc))) 733 738 return -EFAULT; 734 739 740 + size = fpc.fpnum * 4; 741 + 735 742 /* 736 - * table_new must be 64-bytes aligned, but it's 737 - * already done by omap_iommu_vmalloc(). 743 + * The table address must be 64-bytes aligned, which is 744 + * guaranteed by dma_alloc_coherent(). 738 745 */ 739 - size = ccdc->fpc.fpnum * 4; 740 - table_new = omap_iommu_vmalloc(isp->domain, isp->dev, 741 - 0, size, IOMMU_FLAG); 742 - if (IS_ERR_VALUE(table_new)) 746 + fpc_new.fpnum = fpc.fpnum; 747 + fpc_new.addr = dma_alloc_coherent(isp->dev, size, 748 + &fpc_new.dma, 749 + GFP_KERNEL); 750 + if (fpc_new.addr == NULL) 743 751 return -ENOMEM; 744 752 745 - if (copy_from_user(omap_da_to_va(isp->dev, table_new), 746 - (__force void __user *) 747 - ccdc->fpc.fpcaddr, size)) { 748 - omap_iommu_vfree(isp->domain, isp->dev, 749 - table_new); 753 + if (copy_from_user(fpc_new.addr, 754 + (__force void __user *)fpc.fpcaddr, 755 + size)) { 756 + dma_free_coherent(isp->dev, size, fpc_new.addr, 757 + fpc_new.dma); 750 758 return -EFAULT; 751 759 } 752 760 753 - table_old = ccdc->fpc.fpcaddr; 754 - ccdc->fpc.fpcaddr = table_new; 761 + fpc_old = ccdc->fpc; 762 + ccdc->fpc = fpc_new; 755 763 } 756 764 757 765 ccdc_configure_fpc(ccdc); 758 - if (table_old != 0) 759 - omap_iommu_vfree(isp->domain, isp->dev, table_old); 766 + 767 + if (fpc_old.addr != NULL) 768 + dma_free_coherent(isp->dev, fpc_old.fpnum * 4, 769 + fpc_old.addr, fpc_old.dma); 760 770 } 761 771 762 772 return ccdc_lsc_config(ccdc, ccdc_struct); ··· 1521 1523 1522 1524 buffer = omap3isp_video_buffer_next(&ccdc->video_out); 1523 1525 if (buffer != NULL) { 1524 - ccdc_set_outaddr(ccdc, buffer->isp_addr); 1526 + ccdc_set_outaddr(ccdc, buffer->dma); 1525 1527 restart = 1; 1526 1528 } 1527 1529 ··· 1660 1662 if (!(ccdc->output & CCDC_OUTPUT_MEMORY)) 1661 1663 return -ENODEV; 1662 1664 1663 - ccdc_set_outaddr(ccdc, buffer->isp_addr); 1665 + ccdc_set_outaddr(ccdc, buffer->dma); 1664 1666 1665 1667 /* We now have a buffer queued on the output, restart the pipeline 1666 1668 * on the next CCDC interrupt if running in continuous mode (or when ··· 2578 2580 cancel_work_sync(&ccdc->lsc.table_work); 2579 2581 ccdc_lsc_free_queue(ccdc, &ccdc->lsc.free_queue); 2580 2582 2581 - if (ccdc->fpc.fpcaddr != 0) 2582 - omap_iommu_vfree(isp->domain, isp->dev, ccdc->fpc.fpcaddr); 2583 + if (ccdc->fpc.addr != NULL) 2584 + dma_free_coherent(isp->dev, ccdc->fpc.fpnum * 4, ccdc->fpc.addr, 2585 + ccdc->fpc.dma); 2583 2586 2584 2587 mutex_destroy(&ccdc->ioctl_lock); 2585 2588 }

+13 -3

drivers/media/platform/omap3isp/ispccdc.h

··· 46 46 47 47 #define OMAP3ISP_CCDC_NEVENTS 16 48 48 49 + struct ispccdc_fpc { 50 + void *addr; 51 + dma_addr_t dma; 52 + unsigned int fpnum; 53 + }; 54 + 49 55 enum ispccdc_lsc_state { 50 56 LSC_STATE_STOPPED = 0, 51 57 LSC_STATE_STOPPING = 1, ··· 63 57 struct list_head list; 64 58 struct omap3isp_ccdc_lsc_config config; 65 59 unsigned char enable; 66 - u32 table; 67 - struct iovm_struct *iovm; 60 + 61 + struct { 62 + void *addr; 63 + dma_addr_t dma; 64 + struct sg_table sgt; 65 + } table; 68 66 }; 69 67 70 68 /* ··· 146 136 fpc_en:1; 147 137 struct omap3isp_ccdc_blcomp blcomp; 148 138 struct omap3isp_ccdc_bclamp clamp; 149 - struct omap3isp_ccdc_fpc fpc; 139 + struct ispccdc_fpc fpc; 150 140 struct ispccdc_lsc lsc; 151 141 unsigned int update; 152 142 unsigned int shadow_update;

+2 -2

drivers/media/platform/omap3isp/ispccp2.c

··· 549 549 550 550 buffer = omap3isp_video_buffer_next(&ccp2->video_in); 551 551 if (buffer != NULL) 552 - ccp2_set_inaddr(ccp2, buffer->isp_addr); 552 + ccp2_set_inaddr(ccp2, buffer->dma); 553 553 554 554 pipe->state |= ISP_PIPELINE_IDLE_INPUT; 555 555 ··· 940 940 { 941 941 struct isp_ccp2_device *ccp2 = &video->isp->isp_ccp2; 942 942 943 - ccp2_set_inaddr(ccp2, buffer->isp_addr); 943 + ccp2_set_inaddr(ccp2, buffer->dma); 944 944 return 0; 945 945 } 946 946

+2 -2

drivers/media/platform/omap3isp/ispcsi2.c

··· 695 695 if (buffer == NULL) 696 696 return; 697 697 698 - csi2_set_outaddr(csi2, buffer->isp_addr); 698 + csi2_set_outaddr(csi2, buffer->dma); 699 699 csi2_ctx_enable(isp, csi2, 0, 1); 700 700 } 701 701 ··· 812 812 struct isp_device *isp = video->isp; 813 813 struct isp_csi2_device *csi2 = &isp->isp_csi2a; 814 814 815 - csi2_set_outaddr(csi2, buffer->isp_addr); 815 + csi2_set_outaddr(csi2, buffer->dma); 816 816 817 817 /* 818 818 * If streaming was enabled before there was a buffer queued

+1 -1

drivers/media/platform/omap3isp/isph3a_aewb.c

··· 47 47 if (aewb->state == ISPSTAT_DISABLED) 48 48 return; 49 49 50 - isp_reg_writel(aewb->isp, aewb->active_buf->iommu_addr, 50 + isp_reg_writel(aewb->isp, aewb->active_buf->dma_addr, 51 51 OMAP3_ISP_IOMEM_H3A, ISPH3A_AEWBUFST); 52 52 53 53 if (!aewb->update)

+1 -1

drivers/media/platform/omap3isp/isph3a_af.c

··· 51 51 if (af->state == ISPSTAT_DISABLED) 52 52 return; 53 53 54 - isp_reg_writel(af->isp, af->active_buf->iommu_addr, OMAP3_ISP_IOMEM_H3A, 54 + isp_reg_writel(af->isp, af->active_buf->dma_addr, OMAP3_ISP_IOMEM_H3A, 55 55 ISPH3A_AFBUFST); 56 56 57 57 if (!af->update)

+4 -4

drivers/media/platform/omap3isp/isppreview.c

··· 1499 1499 if (prev->input == PREVIEW_INPUT_MEMORY) { 1500 1500 buffer = omap3isp_video_buffer_next(&prev->video_in); 1501 1501 if (buffer != NULL) 1502 - preview_set_inaddr(prev, buffer->isp_addr); 1502 + preview_set_inaddr(prev, buffer->dma); 1503 1503 pipe->state |= ISP_PIPELINE_IDLE_INPUT; 1504 1504 } 1505 1505 1506 1506 if (prev->output & PREVIEW_OUTPUT_MEMORY) { 1507 1507 buffer = omap3isp_video_buffer_next(&prev->video_out); 1508 1508 if (buffer != NULL) { 1509 - preview_set_outaddr(prev, buffer->isp_addr); 1509 + preview_set_outaddr(prev, buffer->dma); 1510 1510 restart = 1; 1511 1511 } 1512 1512 pipe->state |= ISP_PIPELINE_IDLE_OUTPUT; ··· 1577 1577 struct isp_prev_device *prev = &video->isp->isp_prev; 1578 1578 1579 1579 if (video->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 1580 - preview_set_inaddr(prev, buffer->isp_addr); 1580 + preview_set_inaddr(prev, buffer->dma); 1581 1581 1582 1582 if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 1583 - preview_set_outaddr(prev, buffer->isp_addr); 1583 + preview_set_outaddr(prev, buffer->dma); 1584 1584 1585 1585 return 0; 1586 1586 }

-1161

drivers/media/platform/omap3isp/ispqueue.c

··· 1 - /* 2 - * ispqueue.c 3 - * 4 - * TI OMAP3 ISP - Video buffers queue handling 5 - * 6 - * Copyright (C) 2010 Nokia Corporation 7 - * 8 - * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com> 9 - * Sakari Ailus <sakari.ailus@iki.fi> 10 - * 11 - * This program is free software; you can redistribute it and/or modify 12 - * it under the terms of the GNU General Public License version 2 as 13 - * published by the Free Software Foundation. 14 - * 15 - * This program is distributed in the hope that it will be useful, but 16 - * WITHOUT ANY WARRANTY; without even the implied warranty of 17 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 - * General Public License for more details. 19 - * 20 - * You should have received a copy of the GNU General Public License 21 - * along with this program; if not, write to the Free Software 22 - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 23 - * 02110-1301 USA 24 - */ 25 - 26 - #include <asm/cacheflush.h> 27 - #include <linux/dma-mapping.h> 28 - #include <linux/mm.h> 29 - #include <linux/pagemap.h> 30 - #include <linux/poll.h> 31 - #include <linux/scatterlist.h> 32 - #include <linux/sched.h> 33 - #include <linux/slab.h> 34 - #include <linux/vmalloc.h> 35 - 36 - #include "ispqueue.h" 37 - 38 - /* ----------------------------------------------------------------------------- 39 - * Video buffers management 40 - */ 41 - 42 - /* 43 - * isp_video_buffer_cache_sync - Keep the buffers coherent between CPU and ISP 44 - * 45 - * The typical operation required here is Cache Invalidation across 46 - * the (user space) buffer address range. And this _must_ be done 47 - * at QBUF stage (and *only* at QBUF). 48 - * 49 - * We try to use optimal cache invalidation function: 50 - * - dmac_map_area: 51 - * - used when the number of pages are _low_. 52 - * - it becomes quite slow as the number of pages increase. 53 - * - for 648x492 viewfinder (150 pages) it takes 1.3 ms. 54 - * - for 5 Mpix buffer (2491 pages) it takes between 25-50 ms. 55 - * 56 - * - flush_cache_all: 57 - * - used when the number of pages are _high_. 58 - * - time taken in the range of 500-900 us. 59 - * - has a higher penalty but, as whole dcache + icache is invalidated 60 - */ 61 - /* 62 - * FIXME: dmac_inv_range crashes randomly on the user space buffer 63 - * address. Fall back to flush_cache_all for now. 64 - */ 65 - #define ISP_CACHE_FLUSH_PAGES_MAX 0 66 - 67 - static void isp_video_buffer_cache_sync(struct isp_video_buffer *buf) 68 - { 69 - if (buf->skip_cache) 70 - return; 71 - 72 - if (buf->vbuf.m.userptr == 0 || buf->npages == 0 || 73 - buf->npages > ISP_CACHE_FLUSH_PAGES_MAX) 74 - flush_cache_all(); 75 - else { 76 - dmac_map_area((void *)buf->vbuf.m.userptr, buf->vbuf.length, 77 - DMA_FROM_DEVICE); 78 - outer_inv_range(buf->vbuf.m.userptr, 79 - buf->vbuf.m.userptr + buf->vbuf.length); 80 - } 81 - } 82 - 83 - /* 84 - * isp_video_buffer_lock_vma - Prevent VMAs from being unmapped 85 - * 86 - * Lock the VMAs underlying the given buffer into memory. This avoids the 87 - * userspace buffer mapping from being swapped out, making VIPT cache handling 88 - * easier. 89 - * 90 - * Note that the pages will not be freed as the buffers have been locked to 91 - * memory using by a call to get_user_pages(), but the userspace mapping could 92 - * still disappear if the VMAs are not locked. This is caused by the memory 93 - * management code trying to be as lock-less as possible, which results in the 94 - * userspace mapping manager not finding out that the pages are locked under 95 - * some conditions. 96 - */ 97 - static int isp_video_buffer_lock_vma(struct isp_video_buffer *buf, int lock) 98 - { 99 - struct vm_area_struct *vma; 100 - unsigned long start; 101 - unsigned long end; 102 - int ret = 0; 103 - 104 - if (buf->vbuf.memory == V4L2_MEMORY_MMAP) 105 - return 0; 106 - 107 - /* We can be called from workqueue context if the current task dies to 108 - * unlock the VMAs. In that case there's no current memory management 109 - * context so unlocking can't be performed, but the VMAs have been or 110 - * are getting destroyed anyway so it doesn't really matter. 111 - */ 112 - if (!current || !current->mm) 113 - return lock ? -EINVAL : 0; 114 - 115 - start = buf->vbuf.m.userptr; 116 - end = buf->vbuf.m.userptr + buf->vbuf.length - 1; 117 - 118 - down_write(&current->mm->mmap_sem); 119 - spin_lock(&current->mm->page_table_lock); 120 - 121 - do { 122 - vma = find_vma(current->mm, start); 123 - if (vma == NULL) { 124 - ret = -EFAULT; 125 - goto out; 126 - } 127 - 128 - if (lock) 129 - vma->vm_flags |= VM_LOCKED; 130 - else 131 - vma->vm_flags &= ~VM_LOCKED; 132 - 133 - start = vma->vm_end + 1; 134 - } while (vma->vm_end < end); 135 - 136 - if (lock) 137 - buf->vm_flags |= VM_LOCKED; 138 - else 139 - buf->vm_flags &= ~VM_LOCKED; 140 - 141 - out: 142 - spin_unlock(&current->mm->page_table_lock); 143 - up_write(&current->mm->mmap_sem); 144 - return ret; 145 - } 146 - 147 - /* 148 - * isp_video_buffer_sglist_kernel - Build a scatter list for a vmalloc'ed buffer 149 - * 150 - * Iterate over the vmalloc'ed area and create a scatter list entry for every 151 - * page. 152 - */ 153 - static int isp_video_buffer_sglist_kernel(struct isp_video_buffer *buf) 154 - { 155 - struct scatterlist *sglist; 156 - unsigned int npages; 157 - unsigned int i; 158 - void *addr; 159 - 160 - addr = buf->vaddr; 161 - npages = PAGE_ALIGN(buf->vbuf.length) >> PAGE_SHIFT; 162 - 163 - sglist = vmalloc(npages * sizeof(*sglist)); 164 - if (sglist == NULL) 165 - return -ENOMEM; 166 - 167 - sg_init_table(sglist, npages); 168 - 169 - for (i = 0; i < npages; ++i, addr += PAGE_SIZE) { 170 - struct page *page = vmalloc_to_page(addr); 171 - 172 - if (page == NULL || PageHighMem(page)) { 173 - vfree(sglist); 174 - return -EINVAL; 175 - } 176 - 177 - sg_set_page(&sglist[i], page, PAGE_SIZE, 0); 178 - } 179 - 180 - buf->sglen = npages; 181 - buf->sglist = sglist; 182 - 183 - return 0; 184 - } 185 - 186 - /* 187 - * isp_video_buffer_sglist_user - Build a scatter list for a userspace buffer 188 - * 189 - * Walk the buffer pages list and create a 1:1 mapping to a scatter list. 190 - */ 191 - static int isp_video_buffer_sglist_user(struct isp_video_buffer *buf) 192 - { 193 - struct scatterlist *sglist; 194 - unsigned int offset = buf->offset; 195 - unsigned int i; 196 - 197 - sglist = vmalloc(buf->npages * sizeof(*sglist)); 198 - if (sglist == NULL) 199 - return -ENOMEM; 200 - 201 - sg_init_table(sglist, buf->npages); 202 - 203 - for (i = 0; i < buf->npages; ++i) { 204 - if (PageHighMem(buf->pages[i])) { 205 - vfree(sglist); 206 - return -EINVAL; 207 - } 208 - 209 - sg_set_page(&sglist[i], buf->pages[i], PAGE_SIZE - offset, 210 - offset); 211 - offset = 0; 212 - } 213 - 214 - buf->sglen = buf->npages; 215 - buf->sglist = sglist; 216 - 217 - return 0; 218 - } 219 - 220 - /* 221 - * isp_video_buffer_sglist_pfnmap - Build a scatter list for a VM_PFNMAP buffer 222 - * 223 - * Create a scatter list of physically contiguous pages starting at the buffer 224 - * memory physical address. 225 - */ 226 - static int isp_video_buffer_sglist_pfnmap(struct isp_video_buffer *buf) 227 - { 228 - struct scatterlist *sglist; 229 - unsigned int offset = buf->offset; 230 - unsigned long pfn = buf->paddr >> PAGE_SHIFT; 231 - unsigned int i; 232 - 233 - sglist = vmalloc(buf->npages * sizeof(*sglist)); 234 - if (sglist == NULL) 235 - return -ENOMEM; 236 - 237 - sg_init_table(sglist, buf->npages); 238 - 239 - for (i = 0; i < buf->npages; ++i, ++pfn) { 240 - sg_set_page(&sglist[i], pfn_to_page(pfn), PAGE_SIZE - offset, 241 - offset); 242 - /* PFNMAP buffers will not get DMA-mapped, set the DMA address 243 - * manually. 244 - */ 245 - sg_dma_address(&sglist[i]) = (pfn << PAGE_SHIFT) + offset; 246 - offset = 0; 247 - } 248 - 249 - buf->sglen = buf->npages; 250 - buf->sglist = sglist; 251 - 252 - return 0; 253 - } 254 - 255 - /* 256 - * isp_video_buffer_cleanup - Release pages for a userspace VMA. 257 - * 258 - * Release pages locked by a call isp_video_buffer_prepare_user and free the 259 - * pages table. 260 - */ 261 - static void isp_video_buffer_cleanup(struct isp_video_buffer *buf) 262 - { 263 - enum dma_data_direction direction; 264 - unsigned int i; 265 - 266 - if (buf->queue->ops->buffer_cleanup) 267 - buf->queue->ops->buffer_cleanup(buf); 268 - 269 - if (!(buf->vm_flags & VM_PFNMAP)) { 270 - direction = buf->vbuf.type == V4L2_BUF_TYPE_VIDEO_CAPTURE 271 - ? DMA_FROM_DEVICE : DMA_TO_DEVICE; 272 - dma_unmap_sg(buf->queue->dev, buf->sglist, buf->sglen, 273 - direction); 274 - } 275 - 276 - vfree(buf->sglist); 277 - buf->sglist = NULL; 278 - buf->sglen = 0; 279 - 280 - if (buf->pages != NULL) { 281 - isp_video_buffer_lock_vma(buf, 0); 282 - 283 - for (i = 0; i < buf->npages; ++i) 284 - page_cache_release(buf->pages[i]); 285 - 286 - vfree(buf->pages); 287 - buf->pages = NULL; 288 - } 289 - 290 - buf->npages = 0; 291 - buf->skip_cache = false; 292 - } 293 - 294 - /* 295 - * isp_video_buffer_prepare_user - Pin userspace VMA pages to memory. 296 - * 297 - * This function creates a list of pages for a userspace VMA. The number of 298 - * pages is first computed based on the buffer size, and pages are then 299 - * retrieved by a call to get_user_pages. 300 - * 301 - * Pages are pinned to memory by get_user_pages, making them available for DMA 302 - * transfers. However, due to memory management optimization, it seems the 303 - * get_user_pages doesn't guarantee that the pinned pages will not be written 304 - * to swap and removed from the userspace mapping(s). When this happens, a page 305 - * fault can be generated when accessing those unmapped pages. 306 - * 307 - * If the fault is triggered by a page table walk caused by VIPT cache 308 - * management operations, the page fault handler might oops if the MM semaphore 309 - * is held, as it can't handle kernel page faults in that case. To fix that, a 310 - * fixup entry needs to be added to the cache management code, or the userspace 311 - * VMA must be locked to avoid removing pages from the userspace mapping in the 312 - * first place. 313 - * 314 - * If the number of pages retrieved is smaller than the number required by the 315 - * buffer size, the function returns -EFAULT. 316 - */ 317 - static int isp_video_buffer_prepare_user(struct isp_video_buffer *buf) 318 - { 319 - unsigned long data; 320 - unsigned int first; 321 - unsigned int last; 322 - int ret; 323 - 324 - data = buf->vbuf.m.userptr; 325 - first = (data & PAGE_MASK) >> PAGE_SHIFT; 326 - last = ((data + buf->vbuf.length - 1) & PAGE_MASK) >> PAGE_SHIFT; 327 - 328 - buf->offset = data & ~PAGE_MASK; 329 - buf->npages = last - first + 1; 330 - buf->pages = vmalloc(buf->npages * sizeof(buf->pages[0])); 331 - if (buf->pages == NULL) 332 - return -ENOMEM; 333 - 334 - down_read(&current->mm->mmap_sem); 335 - ret = get_user_pages(current, current->mm, data & PAGE_MASK, 336 - buf->npages, 337 - buf->vbuf.type == V4L2_BUF_TYPE_VIDEO_CAPTURE, 0, 338 - buf->pages, NULL); 339 - up_read(&current->mm->mmap_sem); 340 - 341 - if (ret != buf->npages) { 342 - buf->npages = ret < 0 ? 0 : ret; 343 - isp_video_buffer_cleanup(buf); 344 - return -EFAULT; 345 - } 346 - 347 - ret = isp_video_buffer_lock_vma(buf, 1); 348 - if (ret < 0) 349 - isp_video_buffer_cleanup(buf); 350 - 351 - return ret; 352 - } 353 - 354 - /* 355 - * isp_video_buffer_prepare_pfnmap - Validate a VM_PFNMAP userspace buffer 356 - * 357 - * Userspace VM_PFNMAP buffers are supported only if they are contiguous in 358 - * memory and if they span a single VMA. 359 - * 360 - * Return 0 if the buffer is valid, or -EFAULT otherwise. 361 - */ 362 - static int isp_video_buffer_prepare_pfnmap(struct isp_video_buffer *buf) 363 - { 364 - struct vm_area_struct *vma; 365 - unsigned long prev_pfn; 366 - unsigned long this_pfn; 367 - unsigned long start; 368 - unsigned long end; 369 - dma_addr_t pa = 0; 370 - int ret = -EFAULT; 371 - 372 - start = buf->vbuf.m.userptr; 373 - end = buf->vbuf.m.userptr + buf->vbuf.length - 1; 374 - 375 - buf->offset = start & ~PAGE_MASK; 376 - buf->npages = (end >> PAGE_SHIFT) - (start >> PAGE_SHIFT) + 1; 377 - buf->pages = NULL; 378 - 379 - down_read(&current->mm->mmap_sem); 380 - vma = find_vma(current->mm, start); 381 - if (vma == NULL || vma->vm_end < end) 382 - goto done; 383 - 384 - for (prev_pfn = 0; start <= end; start += PAGE_SIZE) { 385 - ret = follow_pfn(vma, start, &this_pfn); 386 - if (ret) 387 - goto done; 388 - 389 - if (prev_pfn == 0) 390 - pa = this_pfn << PAGE_SHIFT; 391 - else if (this_pfn != prev_pfn + 1) { 392 - ret = -EFAULT; 393 - goto done; 394 - } 395 - 396 - prev_pfn = this_pfn; 397 - } 398 - 399 - buf->paddr = pa + buf->offset; 400 - ret = 0; 401 - 402 - done: 403 - up_read(&current->mm->mmap_sem); 404 - return ret; 405 - } 406 - 407 - /* 408 - * isp_video_buffer_prepare_vm_flags - Get VMA flags for a userspace address 409 - * 410 - * This function locates the VMAs for the buffer's userspace address and checks 411 - * that their flags match. The only flag that we need to care for at the moment 412 - * is VM_PFNMAP. 413 - * 414 - * The buffer vm_flags field is set to the first VMA flags. 415 - * 416 - * Return -EFAULT if no VMA can be found for part of the buffer, or if the VMAs 417 - * have incompatible flags. 418 - */ 419 - static int isp_video_buffer_prepare_vm_flags(struct isp_video_buffer *buf) 420 - { 421 - struct vm_area_struct *vma; 422 - pgprot_t uninitialized_var(vm_page_prot); 423 - unsigned long start; 424 - unsigned long end; 425 - int ret = -EFAULT; 426 - 427 - start = buf->vbuf.m.userptr; 428 - end = buf->vbuf.m.userptr + buf->vbuf.length - 1; 429 - 430 - down_read(&current->mm->mmap_sem); 431 - 432 - do { 433 - vma = find_vma(current->mm, start); 434 - if (vma == NULL) 435 - goto done; 436 - 437 - if (start == buf->vbuf.m.userptr) { 438 - buf->vm_flags = vma->vm_flags; 439 - vm_page_prot = vma->vm_page_prot; 440 - } 441 - 442 - if ((buf->vm_flags ^ vma->vm_flags) & VM_PFNMAP) 443 - goto done; 444 - 445 - if (vm_page_prot != vma->vm_page_prot) 446 - goto done; 447 - 448 - start = vma->vm_end + 1; 449 - } while (vma->vm_end < end); 450 - 451 - /* Skip cache management to enhance performances for non-cached or 452 - * write-combining buffers. 453 - */ 454 - if (vm_page_prot == pgprot_noncached(vm_page_prot) || 455 - vm_page_prot == pgprot_writecombine(vm_page_prot)) 456 - buf->skip_cache = true; 457 - 458 - ret = 0; 459 - 460 - done: 461 - up_read(&current->mm->mmap_sem); 462 - return ret; 463 - } 464 - 465 - /* 466 - * isp_video_buffer_prepare - Make a buffer ready for operation 467 - * 468 - * Preparing a buffer involves: 469 - * 470 - * - validating VMAs (userspace buffers only) 471 - * - locking pages and VMAs into memory (userspace buffers only) 472 - * - building page and scatter-gather lists 473 - * - mapping buffers for DMA operation 474 - * - performing driver-specific preparation 475 - * 476 - * The function must be called in userspace context with a valid mm context 477 - * (this excludes cleanup paths such as sys_close when the userspace process 478 - * segfaults). 479 - */ 480 - static int isp_video_buffer_prepare(struct isp_video_buffer *buf) 481 - { 482 - enum dma_data_direction direction; 483 - int ret; 484 - 485 - switch (buf->vbuf.memory) { 486 - case V4L2_MEMORY_MMAP: 487 - ret = isp_video_buffer_sglist_kernel(buf); 488 - break; 489 - 490 - case V4L2_MEMORY_USERPTR: 491 - ret = isp_video_buffer_prepare_vm_flags(buf); 492 - if (ret < 0) 493 - return ret; 494 - 495 - if (buf->vm_flags & VM_PFNMAP) { 496 - ret = isp_video_buffer_prepare_pfnmap(buf); 497 - if (ret < 0) 498 - return ret; 499 - 500 - ret = isp_video_buffer_sglist_pfnmap(buf); 501 - } else { 502 - ret = isp_video_buffer_prepare_user(buf); 503 - if (ret < 0) 504 - return ret; 505 - 506 - ret = isp_video_buffer_sglist_user(buf); 507 - } 508 - break; 509 - 510 - default: 511 - return -EINVAL; 512 - } 513 - 514 - if (ret < 0) 515 - goto done; 516 - 517 - if (!(buf->vm_flags & VM_PFNMAP)) { 518 - direction = buf->vbuf.type == V4L2_BUF_TYPE_VIDEO_CAPTURE 519 - ? DMA_FROM_DEVICE : DMA_TO_DEVICE; 520 - ret = dma_map_sg(buf->queue->dev, buf->sglist, buf->sglen, 521 - direction); 522 - if (ret != buf->sglen) { 523 - ret = -EFAULT; 524 - goto done; 525 - } 526 - } 527 - 528 - if (buf->queue->ops->buffer_prepare) 529 - ret = buf->queue->ops->buffer_prepare(buf); 530 - 531 - done: 532 - if (ret < 0) { 533 - isp_video_buffer_cleanup(buf); 534 - return ret; 535 - } 536 - 537 - return ret; 538 - } 539 - 540 - /* 541 - * isp_video_queue_query - Query the status of a given buffer 542 - * 543 - * Locking: must be called with the queue lock held. 544 - */ 545 - static void isp_video_buffer_query(struct isp_video_buffer *buf, 546 - struct v4l2_buffer *vbuf) 547 - { 548 - memcpy(vbuf, &buf->vbuf, sizeof(*vbuf)); 549 - 550 - if (buf->vma_use_count) 551 - vbuf->flags |= V4L2_BUF_FLAG_MAPPED; 552 - 553 - switch (buf->state) { 554 - case ISP_BUF_STATE_ERROR: 555 - vbuf->flags |= V4L2_BUF_FLAG_ERROR; 556 - /* Fallthrough */ 557 - case ISP_BUF_STATE_DONE: 558 - vbuf->flags |= V4L2_BUF_FLAG_DONE; 559 - break; 560 - case ISP_BUF_STATE_QUEUED: 561 - case ISP_BUF_STATE_ACTIVE: 562 - vbuf->flags |= V4L2_BUF_FLAG_QUEUED; 563 - break; 564 - case ISP_BUF_STATE_IDLE: 565 - default: 566 - break; 567 - } 568 - } 569 - 570 - /* 571 - * isp_video_buffer_wait - Wait for a buffer to be ready 572 - * 573 - * In non-blocking mode, return immediately with 0 if the buffer is ready or 574 - * -EAGAIN if the buffer is in the QUEUED or ACTIVE state. 575 - * 576 - * In blocking mode, wait (interruptibly but with no timeout) on the buffer wait 577 - * queue using the same condition. 578 - */ 579 - static int isp_video_buffer_wait(struct isp_video_buffer *buf, int nonblocking) 580 - { 581 - if (nonblocking) { 582 - return (buf->state != ISP_BUF_STATE_QUEUED && 583 - buf->state != ISP_BUF_STATE_ACTIVE) 584 - ? 0 : -EAGAIN; 585 - } 586 - 587 - return wait_event_interruptible(buf->wait, 588 - buf->state != ISP_BUF_STATE_QUEUED && 589 - buf->state != ISP_BUF_STATE_ACTIVE); 590 - } 591 - 592 - /* ----------------------------------------------------------------------------- 593 - * Queue management 594 - */ 595 - 596 - /* 597 - * isp_video_queue_free - Free video buffers memory 598 - * 599 - * Buffers can only be freed if the queue isn't streaming and if no buffer is 600 - * mapped to userspace. Return -EBUSY if those conditions aren't satisfied. 601 - * 602 - * This function must be called with the queue lock held. 603 - */ 604 - static int isp_video_queue_free(struct isp_video_queue *queue) 605 - { 606 - unsigned int i; 607 - 608 - if (queue->streaming) 609 - return -EBUSY; 610 - 611 - for (i = 0; i < queue->count; ++i) { 612 - if (queue->buffers[i]->vma_use_count != 0) 613 - return -EBUSY; 614 - } 615 - 616 - for (i = 0; i < queue->count; ++i) { 617 - struct isp_video_buffer *buf = queue->buffers[i]; 618 - 619 - isp_video_buffer_cleanup(buf); 620 - 621 - vfree(buf->vaddr); 622 - buf->vaddr = NULL; 623 - 624 - kfree(buf); 625 - queue->buffers[i] = NULL; 626 - } 627 - 628 - INIT_LIST_HEAD(&queue->queue); 629 - queue->count = 0; 630 - return 0; 631 - } 632 - 633 - /* 634 - * isp_video_queue_alloc - Allocate video buffers memory 635 - * 636 - * This function must be called with the queue lock held. 637 - */ 638 - static int isp_video_queue_alloc(struct isp_video_queue *queue, 639 - unsigned int nbuffers, 640 - unsigned int size, enum v4l2_memory memory) 641 - { 642 - struct isp_video_buffer *buf; 643 - unsigned int i; 644 - void *mem; 645 - int ret; 646 - 647 - /* Start by freeing the buffers. */ 648 - ret = isp_video_queue_free(queue); 649 - if (ret < 0) 650 - return ret; 651 - 652 - /* Bail out if no buffers should be allocated. */ 653 - if (nbuffers == 0) 654 - return 0; 655 - 656 - /* Initialize the allocated buffers. */ 657 - for (i = 0; i < nbuffers; ++i) { 658 - buf = kzalloc(queue->bufsize, GFP_KERNEL); 659 - if (buf == NULL) 660 - break; 661 - 662 - if (memory == V4L2_MEMORY_MMAP) { 663 - /* Allocate video buffers memory for mmap mode. Align 664 - * the size to the page size. 665 - */ 666 - mem = vmalloc_32_user(PAGE_ALIGN(size)); 667 - if (mem == NULL) { 668 - kfree(buf); 669 - break; 670 - } 671 - 672 - buf->vbuf.m.offset = i * PAGE_ALIGN(size); 673 - buf->vaddr = mem; 674 - } 675 - 676 - buf->vbuf.index = i; 677 - buf->vbuf.length = size; 678 - buf->vbuf.type = queue->type; 679 - buf->vbuf.flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 680 - buf->vbuf.field = V4L2_FIELD_NONE; 681 - buf->vbuf.memory = memory; 682 - 683 - buf->queue = queue; 684 - init_waitqueue_head(&buf->wait); 685 - 686 - queue->buffers[i] = buf; 687 - } 688 - 689 - if (i == 0) 690 - return -ENOMEM; 691 - 692 - queue->count = i; 693 - return nbuffers; 694 - } 695 - 696 - /** 697 - * omap3isp_video_queue_cleanup - Clean up the video buffers queue 698 - * @queue: Video buffers queue 699 - * 700 - * Free all allocated resources and clean up the video buffers queue. The queue 701 - * must not be busy (no ongoing video stream) and buffers must have been 702 - * unmapped. 703 - * 704 - * Return 0 on success or -EBUSY if the queue is busy or buffers haven't been 705 - * unmapped. 706 - */ 707 - int omap3isp_video_queue_cleanup(struct isp_video_queue *queue) 708 - { 709 - return isp_video_queue_free(queue); 710 - } 711 - 712 - /** 713 - * omap3isp_video_queue_init - Initialize the video buffers queue 714 - * @queue: Video buffers queue 715 - * @type: V4L2 buffer type (capture or output) 716 - * @ops: Driver-specific queue operations 717 - * @dev: Device used for DMA operations 718 - * @bufsize: Size of the driver-specific buffer structure 719 - * 720 - * Initialize the video buffers queue with the supplied parameters. 721 - * 722 - * The queue type must be one of V4L2_BUF_TYPE_VIDEO_CAPTURE or 723 - * V4L2_BUF_TYPE_VIDEO_OUTPUT. Other buffer types are not supported yet. 724 - * 725 - * Buffer objects will be allocated using the given buffer size to allow room 726 - * for driver-specific fields. Driver-specific buffer structures must start 727 - * with a struct isp_video_buffer field. Drivers with no driver-specific buffer 728 - * structure must pass the size of the isp_video_buffer structure in the bufsize 729 - * parameter. 730 - * 731 - * Return 0 on success. 732 - */ 733 - int omap3isp_video_queue_init(struct isp_video_queue *queue, 734 - enum v4l2_buf_type type, 735 - const struct isp_video_queue_operations *ops, 736 - struct device *dev, unsigned int bufsize) 737 - { 738 - INIT_LIST_HEAD(&queue->queue); 739 - mutex_init(&queue->lock); 740 - spin_lock_init(&queue->irqlock); 741 - 742 - queue->type = type; 743 - queue->ops = ops; 744 - queue->dev = dev; 745 - queue->bufsize = bufsize; 746 - 747 - return 0; 748 - } 749 - 750 - /* ----------------------------------------------------------------------------- 751 - * V4L2 operations 752 - */ 753 - 754 - /** 755 - * omap3isp_video_queue_reqbufs - Allocate video buffers memory 756 - * 757 - * This function is intended to be used as a VIDIOC_REQBUFS ioctl handler. It 758 - * allocated video buffer objects and, for MMAP buffers, buffer memory. 759 - * 760 - * If the number of buffers is 0, all buffers are freed and the function returns 761 - * without performing any allocation. 762 - * 763 - * If the number of buffers is not 0, currently allocated buffers (if any) are 764 - * freed and the requested number of buffers are allocated. Depending on 765 - * driver-specific requirements and on memory availability, a number of buffer 766 - * smaller or bigger than requested can be allocated. This isn't considered as 767 - * an error. 768 - * 769 - * Return 0 on success or one of the following error codes: 770 - * 771 - * -EINVAL if the buffer type or index are invalid 772 - * -EBUSY if the queue is busy (streaming or buffers mapped) 773 - * -ENOMEM if the buffers can't be allocated due to an out-of-memory condition 774 - */ 775 - int omap3isp_video_queue_reqbufs(struct isp_video_queue *queue, 776 - struct v4l2_requestbuffers *rb) 777 - { 778 - unsigned int nbuffers = rb->count; 779 - unsigned int size; 780 - int ret; 781 - 782 - if (rb->type != queue->type) 783 - return -EINVAL; 784 - 785 - queue->ops->queue_prepare(queue, &nbuffers, &size); 786 - if (size == 0) 787 - return -EINVAL; 788 - 789 - nbuffers = min_t(unsigned int, nbuffers, ISP_VIDEO_MAX_BUFFERS); 790 - 791 - mutex_lock(&queue->lock); 792 - 793 - ret = isp_video_queue_alloc(queue, nbuffers, size, rb->memory); 794 - if (ret < 0) 795 - goto done; 796 - 797 - rb->count = ret; 798 - ret = 0; 799 - 800 - done: 801 - mutex_unlock(&queue->lock); 802 - return ret; 803 - } 804 - 805 - /** 806 - * omap3isp_video_queue_querybuf - Query the status of a buffer in a queue 807 - * 808 - * This function is intended to be used as a VIDIOC_QUERYBUF ioctl handler. It 809 - * returns the status of a given video buffer. 810 - * 811 - * Return 0 on success or -EINVAL if the buffer type or index are invalid. 812 - */ 813 - int omap3isp_video_queue_querybuf(struct isp_video_queue *queue, 814 - struct v4l2_buffer *vbuf) 815 - { 816 - struct isp_video_buffer *buf; 817 - int ret = 0; 818 - 819 - if (vbuf->type != queue->type) 820 - return -EINVAL; 821 - 822 - mutex_lock(&queue->lock); 823 - 824 - if (vbuf->index >= queue->count) { 825 - ret = -EINVAL; 826 - goto done; 827 - } 828 - 829 - buf = queue->buffers[vbuf->index]; 830 - isp_video_buffer_query(buf, vbuf); 831 - 832 - done: 833 - mutex_unlock(&queue->lock); 834 - return ret; 835 - } 836 - 837 - /** 838 - * omap3isp_video_queue_qbuf - Queue a buffer 839 - * 840 - * This function is intended to be used as a VIDIOC_QBUF ioctl handler. 841 - * 842 - * The v4l2_buffer structure passed from userspace is first sanity tested. If 843 - * sane, the buffer is then processed and added to the main queue and, if the 844 - * queue is streaming, to the IRQ queue. 845 - * 846 - * Before being enqueued, USERPTR buffers are checked for address changes. If 847 - * the buffer has a different userspace address, the old memory area is unlocked 848 - * and the new memory area is locked. 849 - */ 850 - int omap3isp_video_queue_qbuf(struct isp_video_queue *queue, 851 - struct v4l2_buffer *vbuf) 852 - { 853 - struct isp_video_buffer *buf; 854 - unsigned long flags; 855 - int ret = -EINVAL; 856 - 857 - if (vbuf->type != queue->type) 858 - goto done; 859 - 860 - mutex_lock(&queue->lock); 861 - 862 - if (vbuf->index >= queue->count) 863 - goto done; 864 - 865 - buf = queue->buffers[vbuf->index]; 866 - 867 - if (vbuf->memory != buf->vbuf.memory) 868 - goto done; 869 - 870 - if (buf->state != ISP_BUF_STATE_IDLE) 871 - goto done; 872 - 873 - if (vbuf->memory == V4L2_MEMORY_USERPTR && 874 - vbuf->length < buf->vbuf.length) 875 - goto done; 876 - 877 - if (vbuf->memory == V4L2_MEMORY_USERPTR && 878 - vbuf->m.userptr != buf->vbuf.m.userptr) { 879 - isp_video_buffer_cleanup(buf); 880 - buf->vbuf.m.userptr = vbuf->m.userptr; 881 - buf->prepared = 0; 882 - } 883 - 884 - if (!buf->prepared) { 885 - ret = isp_video_buffer_prepare(buf); 886 - if (ret < 0) 887 - goto done; 888 - buf->prepared = 1; 889 - } 890 - 891 - isp_video_buffer_cache_sync(buf); 892 - 893 - buf->state = ISP_BUF_STATE_QUEUED; 894 - list_add_tail(&buf->stream, &queue->queue); 895 - 896 - if (queue->streaming) { 897 - spin_lock_irqsave(&queue->irqlock, flags); 898 - queue->ops->buffer_queue(buf); 899 - spin_unlock_irqrestore(&queue->irqlock, flags); 900 - } 901 - 902 - ret = 0; 903 - 904 - done: 905 - mutex_unlock(&queue->lock); 906 - return ret; 907 - } 908 - 909 - /** 910 - * omap3isp_video_queue_dqbuf - Dequeue a buffer 911 - * 912 - * This function is intended to be used as a VIDIOC_DQBUF ioctl handler. 913 - * 914 - * Wait until a buffer is ready to be dequeued, remove it from the queue and 915 - * copy its information to the v4l2_buffer structure. 916 - * 917 - * If the nonblocking argument is not zero and no buffer is ready, return 918 - * -EAGAIN immediately instead of waiting. 919 - * 920 - * If no buffer has been enqueued, or if the requested buffer type doesn't match 921 - * the queue type, return -EINVAL. 922 - */ 923 - int omap3isp_video_queue_dqbuf(struct isp_video_queue *queue, 924 - struct v4l2_buffer *vbuf, int nonblocking) 925 - { 926 - struct isp_video_buffer *buf; 927 - int ret; 928 - 929 - if (vbuf->type != queue->type) 930 - return -EINVAL; 931 - 932 - mutex_lock(&queue->lock); 933 - 934 - if (list_empty(&queue->queue)) { 935 - ret = -EINVAL; 936 - goto done; 937 - } 938 - 939 - buf = list_first_entry(&queue->queue, struct isp_video_buffer, stream); 940 - ret = isp_video_buffer_wait(buf, nonblocking); 941 - if (ret < 0) 942 - goto done; 943 - 944 - list_del(&buf->stream); 945 - 946 - isp_video_buffer_query(buf, vbuf); 947 - buf->state = ISP_BUF_STATE_IDLE; 948 - vbuf->flags &= ~V4L2_BUF_FLAG_QUEUED; 949 - 950 - done: 951 - mutex_unlock(&queue->lock); 952 - return ret; 953 - } 954 - 955 - /** 956 - * omap3isp_video_queue_streamon - Start streaming 957 - * 958 - * This function is intended to be used as a VIDIOC_STREAMON ioctl handler. It 959 - * starts streaming on the queue and calls the buffer_queue operation for all 960 - * queued buffers. 961 - * 962 - * Return 0 on success. 963 - */ 964 - int omap3isp_video_queue_streamon(struct isp_video_queue *queue) 965 - { 966 - struct isp_video_buffer *buf; 967 - unsigned long flags; 968 - 969 - mutex_lock(&queue->lock); 970 - 971 - if (queue->streaming) 972 - goto done; 973 - 974 - queue->streaming = 1; 975 - 976 - spin_lock_irqsave(&queue->irqlock, flags); 977 - list_for_each_entry(buf, &queue->queue, stream) 978 - queue->ops->buffer_queue(buf); 979 - spin_unlock_irqrestore(&queue->irqlock, flags); 980 - 981 - done: 982 - mutex_unlock(&queue->lock); 983 - return 0; 984 - } 985 - 986 - /** 987 - * omap3isp_video_queue_streamoff - Stop streaming 988 - * 989 - * This function is intended to be used as a VIDIOC_STREAMOFF ioctl handler. It 990 - * stops streaming on the queue and wakes up all the buffers. 991 - * 992 - * Drivers must stop the hardware and synchronize with interrupt handlers and/or 993 - * delayed works before calling this function to make sure no buffer will be 994 - * touched by the driver and/or hardware. 995 - */ 996 - void omap3isp_video_queue_streamoff(struct isp_video_queue *queue) 997 - { 998 - struct isp_video_buffer *buf; 999 - unsigned long flags; 1000 - unsigned int i; 1001 - 1002 - mutex_lock(&queue->lock); 1003 - 1004 - if (!queue->streaming) 1005 - goto done; 1006 - 1007 - queue->streaming = 0; 1008 - 1009 - spin_lock_irqsave(&queue->irqlock, flags); 1010 - for (i = 0; i < queue->count; ++i) { 1011 - buf = queue->buffers[i]; 1012 - 1013 - if (buf->state == ISP_BUF_STATE_ACTIVE) 1014 - wake_up(&buf->wait); 1015 - 1016 - buf->state = ISP_BUF_STATE_IDLE; 1017 - } 1018 - spin_unlock_irqrestore(&queue->irqlock, flags); 1019 - 1020 - INIT_LIST_HEAD(&queue->queue); 1021 - 1022 - done: 1023 - mutex_unlock(&queue->lock); 1024 - } 1025 - 1026 - /** 1027 - * omap3isp_video_queue_discard_done - Discard all buffers marked as DONE 1028 - * 1029 - * This function is intended to be used with suspend/resume operations. It 1030 - * discards all 'done' buffers as they would be too old to be requested after 1031 - * resume. 1032 - * 1033 - * Drivers must stop the hardware and synchronize with interrupt handlers and/or 1034 - * delayed works before calling this function to make sure no buffer will be 1035 - * touched by the driver and/or hardware. 1036 - */ 1037 - void omap3isp_video_queue_discard_done(struct isp_video_queue *queue) 1038 - { 1039 - struct isp_video_buffer *buf; 1040 - unsigned int i; 1041 - 1042 - mutex_lock(&queue->lock); 1043 - 1044 - if (!queue->streaming) 1045 - goto done; 1046 - 1047 - for (i = 0; i < queue->count; ++i) { 1048 - buf = queue->buffers[i]; 1049 - 1050 - if (buf->state == ISP_BUF_STATE_DONE) 1051 - buf->state = ISP_BUF_STATE_ERROR; 1052 - } 1053 - 1054 - done: 1055 - mutex_unlock(&queue->lock); 1056 - } 1057 - 1058 - static void isp_video_queue_vm_open(struct vm_area_struct *vma) 1059 - { 1060 - struct isp_video_buffer *buf = vma->vm_private_data; 1061 - 1062 - buf->vma_use_count++; 1063 - } 1064 - 1065 - static void isp_video_queue_vm_close(struct vm_area_struct *vma) 1066 - { 1067 - struct isp_video_buffer *buf = vma->vm_private_data; 1068 - 1069 - buf->vma_use_count--; 1070 - } 1071 - 1072 - static const struct vm_operations_struct isp_video_queue_vm_ops = { 1073 - .open = isp_video_queue_vm_open, 1074 - .close = isp_video_queue_vm_close, 1075 - }; 1076 - 1077 - /** 1078 - * omap3isp_video_queue_mmap - Map buffers to userspace 1079 - * 1080 - * This function is intended to be used as an mmap() file operation handler. It 1081 - * maps a buffer to userspace based on the VMA offset. 1082 - * 1083 - * Only buffers of memory type MMAP are supported. 1084 - */ 1085 - int omap3isp_video_queue_mmap(struct isp_video_queue *queue, 1086 - struct vm_area_struct *vma) 1087 - { 1088 - struct isp_video_buffer *uninitialized_var(buf); 1089 - unsigned long size; 1090 - unsigned int i; 1091 - int ret = 0; 1092 - 1093 - mutex_lock(&queue->lock); 1094 - 1095 - for (i = 0; i < queue->count; ++i) { 1096 - buf = queue->buffers[i]; 1097 - if ((buf->vbuf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff) 1098 - break; 1099 - } 1100 - 1101 - if (i == queue->count) { 1102 - ret = -EINVAL; 1103 - goto done; 1104 - } 1105 - 1106 - size = vma->vm_end - vma->vm_start; 1107 - 1108 - if (buf->vbuf.memory != V4L2_MEMORY_MMAP || 1109 - size != PAGE_ALIGN(buf->vbuf.length)) { 1110 - ret = -EINVAL; 1111 - goto done; 1112 - } 1113 - 1114 - ret = remap_vmalloc_range(vma, buf->vaddr, 0); 1115 - if (ret < 0) 1116 - goto done; 1117 - 1118 - vma->vm_ops = &isp_video_queue_vm_ops; 1119 - vma->vm_private_data = buf; 1120 - isp_video_queue_vm_open(vma); 1121 - 1122 - done: 1123 - mutex_unlock(&queue->lock); 1124 - return ret; 1125 - } 1126 - 1127 - /** 1128 - * omap3isp_video_queue_poll - Poll video queue state 1129 - * 1130 - * This function is intended to be used as a poll() file operation handler. It 1131 - * polls the state of the video buffer at the front of the queue and returns an 1132 - * events mask. 1133 - * 1134 - * If no buffer is present at the front of the queue, POLLERR is returned. 1135 - */ 1136 - unsigned int omap3isp_video_queue_poll(struct isp_video_queue *queue, 1137 - struct file *file, poll_table *wait) 1138 - { 1139 - struct isp_video_buffer *buf; 1140 - unsigned int mask = 0; 1141 - 1142 - mutex_lock(&queue->lock); 1143 - if (list_empty(&queue->queue)) { 1144 - mask |= POLLERR; 1145 - goto done; 1146 - } 1147 - buf = list_first_entry(&queue->queue, struct isp_video_buffer, stream); 1148 - 1149 - poll_wait(file, &buf->wait, wait); 1150 - if (buf->state == ISP_BUF_STATE_DONE || 1151 - buf->state == ISP_BUF_STATE_ERROR) { 1152 - if (queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 1153 - mask |= POLLIN | POLLRDNORM; 1154 - else 1155 - mask |= POLLOUT | POLLWRNORM; 1156 - } 1157 - 1158 - done: 1159 - mutex_unlock(&queue->lock); 1160 - return mask; 1161 - }

-188

drivers/media/platform/omap3isp/ispqueue.h

··· 1 - /* 2 - * ispqueue.h 3 - * 4 - * TI OMAP3 ISP - Video buffers queue handling 5 - * 6 - * Copyright (C) 2010 Nokia Corporation 7 - * 8 - * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com> 9 - * Sakari Ailus <sakari.ailus@iki.fi> 10 - * 11 - * This program is free software; you can redistribute it and/or modify 12 - * it under the terms of the GNU General Public License version 2 as 13 - * published by the Free Software Foundation. 14 - * 15 - * This program is distributed in the hope that it will be useful, but 16 - * WITHOUT ANY WARRANTY; without even the implied warranty of 17 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 - * General Public License for more details. 19 - * 20 - * You should have received a copy of the GNU General Public License 21 - * along with this program; if not, write to the Free Software 22 - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 23 - * 02110-1301 USA 24 - */ 25 - 26 - #ifndef OMAP3_ISP_QUEUE_H 27 - #define OMAP3_ISP_QUEUE_H 28 - 29 - #include <linux/kernel.h> 30 - #include <linux/list.h> 31 - #include <linux/mm_types.h> 32 - #include <linux/mutex.h> 33 - #include <linux/videodev2.h> 34 - #include <linux/wait.h> 35 - 36 - struct isp_video_queue; 37 - struct page; 38 - struct scatterlist; 39 - 40 - #define ISP_VIDEO_MAX_BUFFERS 16 41 - 42 - /** 43 - * enum isp_video_buffer_state - ISP video buffer state 44 - * @ISP_BUF_STATE_IDLE: The buffer is under userspace control (dequeued 45 - * or not queued yet). 46 - * @ISP_BUF_STATE_QUEUED: The buffer has been queued but isn't used by the 47 - * device yet. 48 - * @ISP_BUF_STATE_ACTIVE: The buffer is in use for an active video transfer. 49 - * @ISP_BUF_STATE_ERROR: The device is done with the buffer and an error 50 - * occurred. For capture device the buffer likely contains corrupted data or 51 - * no data at all. 52 - * @ISP_BUF_STATE_DONE: The device is done with the buffer and no error occurred. 53 - * For capture devices the buffer contains valid data. 54 - */ 55 - enum isp_video_buffer_state { 56 - ISP_BUF_STATE_IDLE, 57 - ISP_BUF_STATE_QUEUED, 58 - ISP_BUF_STATE_ACTIVE, 59 - ISP_BUF_STATE_ERROR, 60 - ISP_BUF_STATE_DONE, 61 - }; 62 - 63 - /** 64 - * struct isp_video_buffer - ISP video buffer 65 - * @vma_use_count: Number of times the buffer is mmap'ed to userspace 66 - * @stream: List head for insertion into main queue 67 - * @queue: ISP buffers queue this buffer belongs to 68 - * @prepared: Whether the buffer has been prepared 69 - * @skip_cache: Whether to skip cache management operations for this buffer 70 - * @vaddr: Memory virtual address (for kernel buffers) 71 - * @vm_flags: Buffer VMA flags (for userspace buffers) 72 - * @offset: Offset inside the first page (for userspace buffers) 73 - * @npages: Number of pages (for userspace buffers) 74 - * @pages: Pages table (for userspace non-VM_PFNMAP buffers) 75 - * @paddr: Memory physical address (for userspace VM_PFNMAP buffers) 76 - * @sglen: Number of elements in the scatter list (for non-VM_PFNMAP buffers) 77 - * @sglist: Scatter list (for non-VM_PFNMAP buffers) 78 - * @vbuf: V4L2 buffer 79 - * @irqlist: List head for insertion into IRQ queue 80 - * @state: Current buffer state 81 - * @wait: Wait queue to signal buffer completion 82 - */ 83 - struct isp_video_buffer { 84 - unsigned long vma_use_count; 85 - struct list_head stream; 86 - struct isp_video_queue *queue; 87 - unsigned int prepared:1; 88 - bool skip_cache; 89 - 90 - /* For kernel buffers. */ 91 - void *vaddr; 92 - 93 - /* For userspace buffers. */ 94 - vm_flags_t vm_flags; 95 - unsigned long offset; 96 - unsigned int npages; 97 - struct page **pages; 98 - dma_addr_t paddr; 99 - 100 - /* For all buffers except VM_PFNMAP. */ 101 - unsigned int sglen; 102 - struct scatterlist *sglist; 103 - 104 - /* Touched by the interrupt handler. */ 105 - struct v4l2_buffer vbuf; 106 - struct list_head irqlist; 107 - enum isp_video_buffer_state state; 108 - wait_queue_head_t wait; 109 - }; 110 - 111 - #define to_isp_video_buffer(vb) container_of(vb, struct isp_video_buffer, vb) 112 - 113 - /** 114 - * struct isp_video_queue_operations - Driver-specific operations 115 - * @queue_prepare: Called before allocating buffers. Drivers should clamp the 116 - * number of buffers according to their requirements, and must return the 117 - * buffer size in bytes. 118 - * @buffer_prepare: Called the first time a buffer is queued, or after changing 119 - * the userspace memory address for a USERPTR buffer, with the queue lock 120 - * held. Drivers should perform device-specific buffer preparation (such as 121 - * mapping the buffer memory in an IOMMU). This operation is optional. 122 - * @buffer_queue: Called when a buffer is being added to the queue with the 123 - * queue irqlock spinlock held. 124 - * @buffer_cleanup: Called before freeing buffers, or before changing the 125 - * userspace memory address for a USERPTR buffer, with the queue lock held. 126 - * Drivers must perform cleanup operations required to undo the 127 - * buffer_prepare call. This operation is optional. 128 - */ 129 - struct isp_video_queue_operations { 130 - void (*queue_prepare)(struct isp_video_queue *queue, 131 - unsigned int *nbuffers, unsigned int *size); 132 - int (*buffer_prepare)(struct isp_video_buffer *buf); 133 - void (*buffer_queue)(struct isp_video_buffer *buf); 134 - void (*buffer_cleanup)(struct isp_video_buffer *buf); 135 - }; 136 - 137 - /** 138 - * struct isp_video_queue - ISP video buffers queue 139 - * @type: Type of video buffers handled by this queue 140 - * @ops: Queue operations 141 - * @dev: Device used for DMA operations 142 - * @bufsize: Size of a driver-specific buffer object 143 - * @count: Number of currently allocated buffers 144 - * @buffers: ISP video buffers 145 - * @lock: Mutex to protect access to the buffers, main queue and state 146 - * @irqlock: Spinlock to protect access to the IRQ queue 147 - * @streaming: Queue state, indicates whether the queue is streaming 148 - * @queue: List of all queued buffers 149 - */ 150 - struct isp_video_queue { 151 - enum v4l2_buf_type type; 152 - const struct isp_video_queue_operations *ops; 153 - struct device *dev; 154 - unsigned int bufsize; 155 - 156 - unsigned int count; 157 - struct isp_video_buffer *buffers[ISP_VIDEO_MAX_BUFFERS]; 158 - struct mutex lock; 159 - spinlock_t irqlock; 160 - 161 - unsigned int streaming:1; 162 - 163 - struct list_head queue; 164 - }; 165 - 166 - int omap3isp_video_queue_cleanup(struct isp_video_queue *queue); 167 - int omap3isp_video_queue_init(struct isp_video_queue *queue, 168 - enum v4l2_buf_type type, 169 - const struct isp_video_queue_operations *ops, 170 - struct device *dev, unsigned int bufsize); 171 - 172 - int omap3isp_video_queue_reqbufs(struct isp_video_queue *queue, 173 - struct v4l2_requestbuffers *rb); 174 - int omap3isp_video_queue_querybuf(struct isp_video_queue *queue, 175 - struct v4l2_buffer *vbuf); 176 - int omap3isp_video_queue_qbuf(struct isp_video_queue *queue, 177 - struct v4l2_buffer *vbuf); 178 - int omap3isp_video_queue_dqbuf(struct isp_video_queue *queue, 179 - struct v4l2_buffer *vbuf, int nonblocking); 180 - int omap3isp_video_queue_streamon(struct isp_video_queue *queue); 181 - void omap3isp_video_queue_streamoff(struct isp_video_queue *queue); 182 - void omap3isp_video_queue_discard_done(struct isp_video_queue *queue); 183 - int omap3isp_video_queue_mmap(struct isp_video_queue *queue, 184 - struct vm_area_struct *vma); 185 - unsigned int omap3isp_video_queue_poll(struct isp_video_queue *queue, 186 - struct file *file, poll_table *wait); 187 - 188 - #endif /* OMAP3_ISP_QUEUE_H */

+4 -4

drivers/media/platform/omap3isp/ispresizer.c

··· 1040 1040 */ 1041 1041 buffer = omap3isp_video_buffer_next(&res->video_out); 1042 1042 if (buffer != NULL) { 1043 - resizer_set_outaddr(res, buffer->isp_addr); 1043 + resizer_set_outaddr(res, buffer->dma); 1044 1044 restart = 1; 1045 1045 } 1046 1046 ··· 1049 1049 if (res->input == RESIZER_INPUT_MEMORY) { 1050 1050 buffer = omap3isp_video_buffer_next(&res->video_in); 1051 1051 if (buffer != NULL) 1052 - resizer_set_inaddr(res, buffer->isp_addr); 1052 + resizer_set_inaddr(res, buffer->dma); 1053 1053 pipe->state |= ISP_PIPELINE_IDLE_INPUT; 1054 1054 } 1055 1055 ··· 1101 1101 struct isp_res_device *res = &video->isp->isp_res; 1102 1102 1103 1103 if (video->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 1104 - resizer_set_inaddr(res, buffer->isp_addr); 1104 + resizer_set_inaddr(res, buffer->dma); 1105 1105 1106 1106 /* 1107 1107 * We now have a buffer queued on the output. Despite what the ··· 1116 1116 * continuous mode or when starting the stream. 1117 1117 */ 1118 1118 if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 1119 - resizer_set_outaddr(res, buffer->isp_addr); 1119 + resizer_set_outaddr(res, buffer->dma); 1120 1120 1121 1121 return 0; 1122 1122 }

+83 -114

drivers/media/platform/omap3isp/ispstat.c

··· 26 26 */ 27 27 28 28 #include <linux/dma-mapping.h> 29 - #include <linux/omap-iommu.h> 30 29 #include <linux/slab.h> 31 30 #include <linux/uaccess.h> 32 31 33 32 #include "isp.h" 34 33 35 - #define IS_COHERENT_BUF(stat) ((stat)->dma_ch >= 0) 34 + #define ISP_STAT_USES_DMAENGINE(stat) ((stat)->dma_ch >= 0) 36 35 37 36 /* 38 37 * MAGIC_SIZE must always be the greatest common divisor of ··· 76 77 dma_addr_t, unsigned long, size_t, 77 78 enum dma_data_direction)) 78 79 { 79 - struct device *dev = stat->isp->dev; 80 - struct page *pg; 81 - dma_addr_t dma_addr; 82 - u32 offset; 83 - 84 - /* Initial magic words */ 85 - pg = vmalloc_to_page(buf->virt_addr); 86 - dma_addr = pfn_to_dma(dev, page_to_pfn(pg)); 87 - dma_sync(dev, dma_addr, 0, MAGIC_SIZE, dir); 88 - 89 - /* Final magic words */ 90 - pg = vmalloc_to_page(buf->virt_addr + buf_size); 91 - dma_addr = pfn_to_dma(dev, page_to_pfn(pg)); 92 - offset = ((u32)buf->virt_addr + buf_size) & ~PAGE_MASK; 93 - dma_sync(dev, dma_addr, offset, MAGIC_SIZE, dir); 80 + /* Sync the initial and final magic words. */ 81 + dma_sync(stat->isp->dev, buf->dma_addr, 0, MAGIC_SIZE, dir); 82 + dma_sync(stat->isp->dev, buf->dma_addr + (buf_size & PAGE_MASK), 83 + buf_size & ~PAGE_MASK, MAGIC_SIZE, dir); 94 84 } 95 85 96 86 static void isp_stat_buf_sync_magic_for_device(struct ispstat *stat, ··· 87 99 u32 buf_size, 88 100 enum dma_data_direction dir) 89 101 { 90 - if (IS_COHERENT_BUF(stat)) 102 + if (ISP_STAT_USES_DMAENGINE(stat)) 91 103 return; 92 104 93 105 __isp_stat_buf_sync_magic(stat, buf, buf_size, dir, ··· 99 111 u32 buf_size, 100 112 enum dma_data_direction dir) 101 113 { 102 - if (IS_COHERENT_BUF(stat)) 114 + if (ISP_STAT_USES_DMAENGINE(stat)) 103 115 return; 104 116 105 117 __isp_stat_buf_sync_magic(stat, buf, buf_size, dir, ··· 168 180 static void isp_stat_buf_sync_for_device(struct ispstat *stat, 169 181 struct ispstat_buffer *buf) 170 182 { 171 - if (IS_COHERENT_BUF(stat)) 183 + if (ISP_STAT_USES_DMAENGINE(stat)) 172 184 return; 173 185 174 - dma_sync_sg_for_device(stat->isp->dev, buf->iovm->sgt->sgl, 175 - buf->iovm->sgt->nents, DMA_FROM_DEVICE); 186 + dma_sync_sg_for_device(stat->isp->dev, buf->sgt.sgl, 187 + buf->sgt.nents, DMA_FROM_DEVICE); 176 188 } 177 189 178 190 static void isp_stat_buf_sync_for_cpu(struct ispstat *stat, 179 191 struct ispstat_buffer *buf) 180 192 { 181 - if (IS_COHERENT_BUF(stat)) 193 + if (ISP_STAT_USES_DMAENGINE(stat)) 182 194 return; 183 195 184 - dma_sync_sg_for_cpu(stat->isp->dev, buf->iovm->sgt->sgl, 185 - buf->iovm->sgt->nents, DMA_FROM_DEVICE); 196 + dma_sync_sg_for_cpu(stat->isp->dev, buf->sgt.sgl, 197 + buf->sgt.nents, DMA_FROM_DEVICE); 186 198 } 187 199 188 200 static void isp_stat_buf_clear(struct ispstat *stat) ··· 342 354 343 355 static void isp_stat_bufs_free(struct ispstat *stat) 344 356 { 345 - struct isp_device *isp = stat->isp; 346 - int i; 357 + struct device *dev = ISP_STAT_USES_DMAENGINE(stat) 358 + ? NULL : stat->isp->dev; 359 + unsigned int i; 347 360 348 361 for (i = 0; i < STAT_MAX_BUFS; i++) { 349 362 struct ispstat_buffer *buf = &stat->buf[i]; 350 363 351 - if (!IS_COHERENT_BUF(stat)) { 352 - if (IS_ERR_OR_NULL((void *)buf->iommu_addr)) 353 - continue; 354 - if (buf->iovm) 355 - dma_unmap_sg(isp->dev, buf->iovm->sgt->sgl, 356 - buf->iovm->sgt->nents, 357 - DMA_FROM_DEVICE); 358 - omap_iommu_vfree(isp->domain, isp->dev, 359 - buf->iommu_addr); 360 - } else { 361 - if (!buf->virt_addr) 362 - continue; 363 - dma_free_coherent(stat->isp->dev, stat->buf_alloc_size, 364 - buf->virt_addr, buf->dma_addr); 365 - } 366 - buf->iommu_addr = 0; 367 - buf->iovm = NULL; 364 + if (!buf->virt_addr) 365 + continue; 366 + 367 + sg_free_table(&buf->sgt); 368 + 369 + dma_free_coherent(dev, stat->buf_alloc_size, buf->virt_addr, 370 + buf->dma_addr); 371 + 368 372 buf->dma_addr = 0; 369 373 buf->virt_addr = NULL; 370 374 buf->empty = 1; ··· 369 389 stat->active_buf = NULL; 370 390 } 371 391 372 - static int isp_stat_bufs_alloc_iommu(struct ispstat *stat, unsigned int size) 392 + static int isp_stat_bufs_alloc_one(struct device *dev, 393 + struct ispstat_buffer *buf, 394 + unsigned int size) 373 395 { 374 - struct isp_device *isp = stat->isp; 375 - int i; 396 + int ret; 376 397 377 - stat->buf_alloc_size = size; 398 + buf->virt_addr = dma_alloc_coherent(dev, size, &buf->dma_addr, 399 + GFP_KERNEL | GFP_DMA); 400 + if (!buf->virt_addr) 401 + return -ENOMEM; 378 402 379 - for (i = 0; i < STAT_MAX_BUFS; i++) { 380 - struct ispstat_buffer *buf = &stat->buf[i]; 381 - struct iovm_struct *iovm; 382 - 383 - WARN_ON(buf->dma_addr); 384 - buf->iommu_addr = omap_iommu_vmalloc(isp->domain, isp->dev, 0, 385 - size, IOMMU_FLAG); 386 - if (IS_ERR((void *)buf->iommu_addr)) { 387 - dev_err(stat->isp->dev, 388 - "%s: Can't acquire memory for " 389 - "buffer %d\n", stat->subdev.name, i); 390 - isp_stat_bufs_free(stat); 391 - return -ENOMEM; 392 - } 393 - 394 - iovm = omap_find_iovm_area(isp->dev, buf->iommu_addr); 395 - if (!iovm || 396 - !dma_map_sg(isp->dev, iovm->sgt->sgl, iovm->sgt->nents, 397 - DMA_FROM_DEVICE)) { 398 - isp_stat_bufs_free(stat); 399 - return -ENOMEM; 400 - } 401 - buf->iovm = iovm; 402 - 403 - buf->virt_addr = omap_da_to_va(stat->isp->dev, 404 - (u32)buf->iommu_addr); 405 - buf->empty = 1; 406 - dev_dbg(stat->isp->dev, "%s: buffer[%d] allocated." 407 - "iommu_addr=0x%08lx virt_addr=0x%08lx", 408 - stat->subdev.name, i, buf->iommu_addr, 409 - (unsigned long)buf->virt_addr); 403 + ret = dma_get_sgtable(dev, &buf->sgt, buf->virt_addr, buf->dma_addr, 404 + size); 405 + if (ret < 0) { 406 + dma_free_coherent(dev, size, buf->virt_addr, buf->dma_addr); 407 + buf->virt_addr = NULL; 408 + buf->dma_addr = 0; 409 + return ret; 410 410 } 411 411 412 412 return 0; 413 413 } 414 414 415 - static int isp_stat_bufs_alloc_dma(struct ispstat *stat, unsigned int size) 416 - { 417 - int i; 418 - 419 - stat->buf_alloc_size = size; 420 - 421 - for (i = 0; i < STAT_MAX_BUFS; i++) { 422 - struct ispstat_buffer *buf = &stat->buf[i]; 423 - 424 - WARN_ON(buf->iommu_addr); 425 - buf->virt_addr = dma_alloc_coherent(stat->isp->dev, size, 426 - &buf->dma_addr, GFP_KERNEL | GFP_DMA); 427 - 428 - if (!buf->virt_addr || !buf->dma_addr) { 429 - dev_info(stat->isp->dev, 430 - "%s: Can't acquire memory for " 431 - "DMA buffer %d\n", stat->subdev.name, i); 432 - isp_stat_bufs_free(stat); 433 - return -ENOMEM; 434 - } 435 - buf->empty = 1; 436 - 437 - dev_dbg(stat->isp->dev, "%s: buffer[%d] allocated." 438 - "dma_addr=0x%08lx virt_addr=0x%08lx\n", 439 - stat->subdev.name, i, (unsigned long)buf->dma_addr, 440 - (unsigned long)buf->virt_addr); 441 - } 442 - 443 - return 0; 444 - } 445 - 415 + /* 416 + * The device passed to the DMA API depends on whether the statistics block uses 417 + * ISP DMA, external DMA or PIO to transfer data. 418 + * 419 + * The first case (for the AEWB and AF engines) passes the ISP device, resulting 420 + * in the DMA buffers being mapped through the ISP IOMMU. 421 + * 422 + * The second case (for the histogram engine) should pass the DMA engine device. 423 + * As that device isn't accessible through the OMAP DMA engine API the driver 424 + * passes NULL instead, resulting in the buffers being mapped directly as 425 + * physical pages. 426 + * 427 + * The third case (for the histogram engine) doesn't require any mapping. The 428 + * buffers could be allocated with kmalloc/vmalloc, but we still use 429 + * dma_alloc_coherent() for consistency purpose. 430 + */ 446 431 static int isp_stat_bufs_alloc(struct ispstat *stat, u32 size) 447 432 { 433 + struct device *dev = ISP_STAT_USES_DMAENGINE(stat) 434 + ? NULL : stat->isp->dev; 448 435 unsigned long flags; 436 + unsigned int i; 449 437 450 438 spin_lock_irqsave(&stat->isp->stat_lock, flags); 451 439 ··· 437 489 438 490 isp_stat_bufs_free(stat); 439 491 440 - if (IS_COHERENT_BUF(stat)) 441 - return isp_stat_bufs_alloc_dma(stat, size); 442 - else 443 - return isp_stat_bufs_alloc_iommu(stat, size); 492 + stat->buf_alloc_size = size; 493 + 494 + for (i = 0; i < STAT_MAX_BUFS; i++) { 495 + struct ispstat_buffer *buf = &stat->buf[i]; 496 + int ret; 497 + 498 + ret = isp_stat_bufs_alloc_one(dev, buf, size); 499 + if (ret < 0) { 500 + dev_err(stat->isp->dev, 501 + "%s: Failed to allocate DMA buffer %u\n", 502 + stat->subdev.name, i); 503 + isp_stat_bufs_free(stat); 504 + return ret; 505 + } 506 + 507 + buf->empty = 1; 508 + 509 + dev_dbg(stat->isp->dev, 510 + "%s: buffer[%u] allocated. dma=0x%08lx virt=0x%08lx", 511 + stat->subdev.name, i, 512 + (unsigned long)buf->dma_addr, 513 + (unsigned long)buf->virt_addr); 514 + } 515 + 516 + return 0; 444 517 } 445 518 446 519 static void isp_stat_queue_event(struct ispstat *stat, int err)

+1 -2

drivers/media/platform/omap3isp/ispstat.h

··· 46 46 struct ispstat; 47 47 48 48 struct ispstat_buffer { 49 - unsigned long iommu_addr; 50 - struct iovm_struct *iovm; 49 + struct sg_table sgt; 51 50 void *virt_addr; 52 51 dma_addr_t dma_addr; 53 52 struct timespec ts;

+169 -160

drivers/media/platform/omap3isp/ispvideo.c

··· 27 27 #include <linux/clk.h> 28 28 #include <linux/mm.h> 29 29 #include <linux/module.h> 30 - #include <linux/omap-iommu.h> 31 30 #include <linux/pagemap.h> 32 31 #include <linux/scatterlist.h> 33 32 #include <linux/sched.h> ··· 34 35 #include <linux/vmalloc.h> 35 36 #include <media/v4l2-dev.h> 36 37 #include <media/v4l2-ioctl.h> 38 + #include <media/videobuf2-dma-contig.h> 37 39 38 40 #include "ispvideo.h" 39 41 #include "isp.h" ··· 326 326 } 327 327 328 328 /* ----------------------------------------------------------------------------- 329 - * IOMMU management 330 - */ 331 - 332 - #define IOMMU_FLAG (IOVMF_ENDIAN_LITTLE | IOVMF_ELSZ_8) 333 - 334 - /* 335 - * ispmmu_vmap - Wrapper for Virtual memory mapping of a scatter gather list 336 - * @isp: Device pointer specific to the OMAP3 ISP. 337 - * @sglist: Pointer to source Scatter gather list to allocate. 338 - * @sglen: Number of elements of the scatter-gatter list. 339 - * 340 - * Returns a resulting mapped device address by the ISP MMU, or -ENOMEM if 341 - * we ran out of memory. 342 - */ 343 - static dma_addr_t 344 - ispmmu_vmap(struct isp_device *isp, const struct scatterlist *sglist, int sglen) 345 - { 346 - struct sg_table *sgt; 347 - u32 da; 348 - 349 - sgt = kmalloc(sizeof(*sgt), GFP_KERNEL); 350 - if (sgt == NULL) 351 - return -ENOMEM; 352 - 353 - sgt->sgl = (struct scatterlist *)sglist; 354 - sgt->nents = sglen; 355 - sgt->orig_nents = sglen; 356 - 357 - da = omap_iommu_vmap(isp->domain, isp->dev, 0, sgt, IOMMU_FLAG); 358 - if (IS_ERR_VALUE(da)) 359 - kfree(sgt); 360 - 361 - return da; 362 - } 363 - 364 - /* 365 - * ispmmu_vunmap - Unmap a device address from the ISP MMU 366 - * @isp: Device pointer specific to the OMAP3 ISP. 367 - * @da: Device address generated from a ispmmu_vmap call. 368 - */ 369 - static void ispmmu_vunmap(struct isp_device *isp, dma_addr_t da) 370 - { 371 - struct sg_table *sgt; 372 - 373 - sgt = omap_iommu_vunmap(isp->domain, isp->dev, (u32)da); 374 - kfree(sgt); 375 - } 376 - 377 - /* ----------------------------------------------------------------------------- 378 329 * Video queue operations 379 330 */ 380 331 381 - static void isp_video_queue_prepare(struct isp_video_queue *queue, 382 - unsigned int *nbuffers, unsigned int *size) 332 + static int isp_video_queue_setup(struct vb2_queue *queue, 333 + const struct v4l2_format *fmt, 334 + unsigned int *count, unsigned int *num_planes, 335 + unsigned int sizes[], void *alloc_ctxs[]) 383 336 { 384 - struct isp_video_fh *vfh = 385 - container_of(queue, struct isp_video_fh, queue); 337 + struct isp_video_fh *vfh = vb2_get_drv_priv(queue); 386 338 struct isp_video *video = vfh->video; 387 339 388 - *size = vfh->format.fmt.pix.sizeimage; 389 - if (*size == 0) 390 - return; 340 + *num_planes = 1; 391 341 392 - *nbuffers = min(*nbuffers, video->capture_mem / PAGE_ALIGN(*size)); 342 + sizes[0] = vfh->format.fmt.pix.sizeimage; 343 + if (sizes[0] == 0) 344 + return -EINVAL; 345 + 346 + alloc_ctxs[0] = video->alloc_ctx; 347 + 348 + *count = min(*count, video->capture_mem / PAGE_ALIGN(sizes[0])); 349 + 350 + return 0; 393 351 } 394 352 395 - static void isp_video_buffer_cleanup(struct isp_video_buffer *buf) 353 + static int isp_video_buffer_prepare(struct vb2_buffer *buf) 396 354 { 397 - struct isp_video_fh *vfh = isp_video_queue_to_isp_video_fh(buf->queue); 355 + struct isp_video_fh *vfh = vb2_get_drv_priv(buf->vb2_queue); 398 356 struct isp_buffer *buffer = to_isp_buffer(buf); 399 357 struct isp_video *video = vfh->video; 400 - 401 - if (buffer->isp_addr) { 402 - ispmmu_vunmap(video->isp, buffer->isp_addr); 403 - buffer->isp_addr = 0; 404 - } 405 - } 406 - 407 - static int isp_video_buffer_prepare(struct isp_video_buffer *buf) 408 - { 409 - struct isp_video_fh *vfh = isp_video_queue_to_isp_video_fh(buf->queue); 410 - struct isp_buffer *buffer = to_isp_buffer(buf); 411 - struct isp_video *video = vfh->video; 412 - unsigned long addr; 358 + dma_addr_t addr; 413 359 414 360 /* Refuse to prepare the buffer is the video node has registered an 415 361 * error. We don't need to take any lock here as the operation is ··· 366 420 if (unlikely(video->error)) 367 421 return -EIO; 368 422 369 - addr = ispmmu_vmap(video->isp, buf->sglist, buf->sglen); 370 - if (IS_ERR_VALUE(addr)) 371 - return -EIO; 372 - 423 + addr = vb2_dma_contig_plane_dma_addr(buf, 0); 373 424 if (!IS_ALIGNED(addr, 32)) { 374 - dev_dbg(video->isp->dev, "Buffer address must be " 375 - "aligned to 32 bytes boundary.\n"); 376 - ispmmu_vunmap(video->isp, buffer->isp_addr); 425 + dev_dbg(video->isp->dev, 426 + "Buffer address must be aligned to 32 bytes boundary.\n"); 377 427 return -EINVAL; 378 428 } 379 429 380 - buf->vbuf.bytesused = vfh->format.fmt.pix.sizeimage; 381 - buffer->isp_addr = addr; 430 + vb2_set_plane_payload(&buffer->vb, 0, vfh->format.fmt.pix.sizeimage); 431 + buffer->dma = addr; 432 + 382 433 return 0; 383 434 } 384 435 ··· 388 445 * If the pipeline is busy, it will be restarted in the output module interrupt 389 446 * handler. 390 447 */ 391 - static void isp_video_buffer_queue(struct isp_video_buffer *buf) 448 + static void isp_video_buffer_queue(struct vb2_buffer *buf) 392 449 { 393 - struct isp_video_fh *vfh = isp_video_queue_to_isp_video_fh(buf->queue); 450 + struct isp_video_fh *vfh = vb2_get_drv_priv(buf->vb2_queue); 394 451 struct isp_buffer *buffer = to_isp_buffer(buf); 395 452 struct isp_video *video = vfh->video; 396 453 struct isp_pipeline *pipe = to_isp_pipeline(&video->video.entity); ··· 399 456 unsigned int empty; 400 457 unsigned int start; 401 458 459 + spin_lock_irqsave(&video->irqlock, flags); 460 + 402 461 if (unlikely(video->error)) { 403 - buf->state = ISP_BUF_STATE_ERROR; 404 - wake_up(&buf->wait); 462 + vb2_buffer_done(&buffer->vb, VB2_BUF_STATE_ERROR); 463 + spin_unlock_irqrestore(&video->irqlock, flags); 405 464 return; 406 465 } 407 466 408 467 empty = list_empty(&video->dmaqueue); 409 - list_add_tail(&buffer->buffer.irqlist, &video->dmaqueue); 468 + list_add_tail(&buffer->irqlist, &video->dmaqueue); 469 + 470 + spin_unlock_irqrestore(&video->irqlock, flags); 410 471 411 472 if (empty) { 412 473 if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) ··· 434 487 } 435 488 } 436 489 437 - static const struct isp_video_queue_operations isp_video_queue_ops = { 438 - .queue_prepare = &isp_video_queue_prepare, 439 - .buffer_prepare = &isp_video_buffer_prepare, 440 - .buffer_queue = &isp_video_buffer_queue, 441 - .buffer_cleanup = &isp_video_buffer_cleanup, 490 + static const struct vb2_ops isp_video_queue_ops = { 491 + .queue_setup = isp_video_queue_setup, 492 + .buf_prepare = isp_video_buffer_prepare, 493 + .buf_queue = isp_video_buffer_queue, 442 494 }; 443 495 444 496 /* 445 497 * omap3isp_video_buffer_next - Complete the current buffer and return the next 446 498 * @video: ISP video object 447 499 * 448 - * Remove the current video buffer from the DMA queue and fill its timestamp, 449 - * field count and state fields before waking up its completion handler. 500 + * Remove the current video buffer from the DMA queue and fill its timestamp and 501 + * field count before handing it back to videobuf2. 450 502 * 451 - * For capture video nodes the buffer state is set to ISP_BUF_STATE_DONE if no 452 - * error has been flagged in the pipeline, or to ISP_BUF_STATE_ERROR otherwise. 453 - * For video output nodes the buffer state is always set to ISP_BUF_STATE_DONE. 503 + * For capture video nodes the buffer state is set to VB2_BUF_STATE_DONE if no 504 + * error has been flagged in the pipeline, or to VB2_BUF_STATE_ERROR otherwise. 505 + * For video output nodes the buffer state is always set to VB2_BUF_STATE_DONE. 454 506 * 455 507 * The DMA queue is expected to contain at least one buffer. 456 508 * ··· 459 513 struct isp_buffer *omap3isp_video_buffer_next(struct isp_video *video) 460 514 { 461 515 struct isp_pipeline *pipe = to_isp_pipeline(&video->video.entity); 462 - struct isp_video_queue *queue = video->queue; 463 516 enum isp_pipeline_state state; 464 - struct isp_video_buffer *buf; 517 + struct isp_buffer *buf; 465 518 unsigned long flags; 466 519 struct timespec ts; 467 520 468 - spin_lock_irqsave(&queue->irqlock, flags); 521 + spin_lock_irqsave(&video->irqlock, flags); 469 522 if (WARN_ON(list_empty(&video->dmaqueue))) { 470 - spin_unlock_irqrestore(&queue->irqlock, flags); 523 + spin_unlock_irqrestore(&video->irqlock, flags); 471 524 return NULL; 472 525 } 473 526 474 - buf = list_first_entry(&video->dmaqueue, struct isp_video_buffer, 527 + buf = list_first_entry(&video->dmaqueue, struct isp_buffer, 475 528 irqlist); 476 529 list_del(&buf->irqlist); 477 - spin_unlock_irqrestore(&queue->irqlock, flags); 530 + spin_unlock_irqrestore(&video->irqlock, flags); 478 531 479 532 ktime_get_ts(&ts); 480 - buf->vbuf.timestamp.tv_sec = ts.tv_sec; 481 - buf->vbuf.timestamp.tv_usec = ts.tv_nsec / NSEC_PER_USEC; 533 + buf->vb.v4l2_buf.timestamp.tv_sec = ts.tv_sec; 534 + buf->vb.v4l2_buf.timestamp.tv_usec = ts.tv_nsec / NSEC_PER_USEC; 482 535 483 536 /* Do frame number propagation only if this is the output video node. 484 537 * Frame number either comes from the CSI receivers or it gets ··· 486 541 * first, so the input number might lag behind by 1 in some cases. 487 542 */ 488 543 if (video == pipe->output && !pipe->do_propagation) 489 - buf->vbuf.sequence = atomic_inc_return(&pipe->frame_number); 544 + buf->vb.v4l2_buf.sequence = 545 + atomic_inc_return(&pipe->frame_number); 490 546 else 491 - buf->vbuf.sequence = atomic_read(&pipe->frame_number); 547 + buf->vb.v4l2_buf.sequence = atomic_read(&pipe->frame_number); 492 548 493 549 /* Report pipeline errors to userspace on the capture device side. */ 494 - if (queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && pipe->error) { 495 - buf->state = ISP_BUF_STATE_ERROR; 550 + if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && pipe->error) { 551 + state = VB2_BUF_STATE_ERROR; 496 552 pipe->error = false; 497 553 } else { 498 - buf->state = ISP_BUF_STATE_DONE; 554 + state = VB2_BUF_STATE_DONE; 499 555 } 500 556 501 - wake_up(&buf->wait); 557 + vb2_buffer_done(&buf->vb, state); 558 + 559 + spin_lock_irqsave(&video->irqlock, flags); 502 560 503 561 if (list_empty(&video->dmaqueue)) { 504 - if (queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 562 + spin_unlock_irqrestore(&video->irqlock, flags); 563 + 564 + if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 505 565 state = ISP_PIPELINE_QUEUE_OUTPUT 506 566 | ISP_PIPELINE_STREAM; 507 567 else ··· 521 571 return NULL; 522 572 } 523 573 524 - if (queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && pipe->input != NULL) { 525 - spin_lock_irqsave(&pipe->lock, flags); 574 + if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && pipe->input != NULL) { 575 + spin_lock(&pipe->lock); 526 576 pipe->state &= ~ISP_PIPELINE_STREAM; 527 - spin_unlock_irqrestore(&pipe->lock, flags); 577 + spin_unlock(&pipe->lock); 528 578 } 529 579 530 - buf = list_first_entry(&video->dmaqueue, struct isp_video_buffer, 580 + buf = list_first_entry(&video->dmaqueue, struct isp_buffer, 531 581 irqlist); 532 - buf->state = ISP_BUF_STATE_ACTIVE; 533 - return to_isp_buffer(buf); 582 + buf->vb.state = VB2_BUF_STATE_ACTIVE; 583 + 584 + spin_unlock_irqrestore(&video->irqlock, flags); 585 + 586 + return buf; 534 587 } 535 588 536 589 /* ··· 545 592 */ 546 593 void omap3isp_video_cancel_stream(struct isp_video *video) 547 594 { 548 - struct isp_video_queue *queue = video->queue; 549 595 unsigned long flags; 550 596 551 - spin_lock_irqsave(&queue->irqlock, flags); 597 + spin_lock_irqsave(&video->irqlock, flags); 552 598 553 599 while (!list_empty(&video->dmaqueue)) { 554 - struct isp_video_buffer *buf; 600 + struct isp_buffer *buf; 555 601 556 602 buf = list_first_entry(&video->dmaqueue, 557 - struct isp_video_buffer, irqlist); 603 + struct isp_buffer, irqlist); 558 604 list_del(&buf->irqlist); 559 - 560 - buf->state = ISP_BUF_STATE_ERROR; 561 - wake_up(&buf->wait); 605 + vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR); 562 606 } 563 607 564 608 video->error = true; 565 609 566 - spin_unlock_irqrestore(&queue->irqlock, flags); 610 + spin_unlock_irqrestore(&video->irqlock, flags); 567 611 } 568 612 569 613 /* ··· 577 627 { 578 628 struct isp_buffer *buf = NULL; 579 629 580 - if (continuous && video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 581 - omap3isp_video_queue_discard_done(video->queue); 630 + if (continuous && video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 631 + mutex_lock(&video->queue_lock); 632 + vb2_discard_done(video->queue); 633 + mutex_unlock(&video->queue_lock); 634 + } 582 635 583 636 if (!list_empty(&video->dmaqueue)) { 584 637 buf = list_first_entry(&video->dmaqueue, 585 - struct isp_buffer, buffer.irqlist); 638 + struct isp_buffer, irqlist); 586 639 video->ops->queue(video, buf); 587 640 video->dmaqueue_flags |= ISP_VIDEO_DMAQUEUE_QUEUED; 588 641 } else { ··· 793 840 isp_video_reqbufs(struct file *file, void *fh, struct v4l2_requestbuffers *rb) 794 841 { 795 842 struct isp_video_fh *vfh = to_isp_video_fh(fh); 843 + struct isp_video *video = video_drvdata(file); 844 + int ret; 796 845 797 - return omap3isp_video_queue_reqbufs(&vfh->queue, rb); 846 + mutex_lock(&video->queue_lock); 847 + ret = vb2_reqbufs(&vfh->queue, rb); 848 + mutex_unlock(&video->queue_lock); 849 + 850 + return ret; 798 851 } 799 852 800 853 static int 801 854 isp_video_querybuf(struct file *file, void *fh, struct v4l2_buffer *b) 802 855 { 803 856 struct isp_video_fh *vfh = to_isp_video_fh(fh); 857 + struct isp_video *video = video_drvdata(file); 858 + int ret; 804 859 805 - return omap3isp_video_queue_querybuf(&vfh->queue, b); 860 + mutex_lock(&video->queue_lock); 861 + ret = vb2_querybuf(&vfh->queue, b); 862 + mutex_unlock(&video->queue_lock); 863 + 864 + return ret; 806 865 } 807 866 808 867 static int 809 868 isp_video_qbuf(struct file *file, void *fh, struct v4l2_buffer *b) 810 869 { 811 870 struct isp_video_fh *vfh = to_isp_video_fh(fh); 871 + struct isp_video *video = video_drvdata(file); 872 + int ret; 812 873 813 - return omap3isp_video_queue_qbuf(&vfh->queue, b); 874 + mutex_lock(&video->queue_lock); 875 + ret = vb2_qbuf(&vfh->queue, b); 876 + mutex_unlock(&video->queue_lock); 877 + 878 + return ret; 814 879 } 815 880 816 881 static int 817 882 isp_video_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b) 818 883 { 819 884 struct isp_video_fh *vfh = to_isp_video_fh(fh); 885 + struct isp_video *video = video_drvdata(file); 886 + int ret; 820 887 821 - return omap3isp_video_queue_dqbuf(&vfh->queue, b, 822 - file->f_flags & O_NONBLOCK); 888 + mutex_lock(&video->queue_lock); 889 + ret = vb2_dqbuf(&vfh->queue, b, file->f_flags & O_NONBLOCK); 890 + mutex_unlock(&video->queue_lock); 891 + 892 + return ret; 823 893 } 824 894 825 895 static int isp_video_check_external_subdevs(struct isp_video *video, ··· 982 1006 983 1007 mutex_lock(&video->stream_lock); 984 1008 985 - if (video->streaming) { 986 - mutex_unlock(&video->stream_lock); 987 - return -EBUSY; 988 - } 989 - 990 1009 /* Start streaming on the pipeline. No link touching an entity in the 991 1010 * pipeline can be activated or deactivated once streaming is started. 992 1011 */ ··· 1040 1069 INIT_LIST_HEAD(&video->dmaqueue); 1041 1070 atomic_set(&pipe->frame_number, -1); 1042 1071 1043 - ret = omap3isp_video_queue_streamon(&vfh->queue); 1072 + mutex_lock(&video->queue_lock); 1073 + ret = vb2_streamon(&vfh->queue, type); 1074 + mutex_unlock(&video->queue_lock); 1044 1075 if (ret < 0) 1045 1076 goto err_check_format; 1046 1077 ··· 1055 1082 ISP_PIPELINE_STREAM_CONTINUOUS); 1056 1083 if (ret < 0) 1057 1084 goto err_set_stream; 1058 - spin_lock_irqsave(&video->queue->irqlock, flags); 1085 + spin_lock_irqsave(&video->irqlock, flags); 1059 1086 if (list_empty(&video->dmaqueue)) 1060 1087 video->dmaqueue_flags |= ISP_VIDEO_DMAQUEUE_UNDERRUN; 1061 - spin_unlock_irqrestore(&video->queue->irqlock, flags); 1088 + spin_unlock_irqrestore(&video->irqlock, flags); 1062 1089 } 1063 - 1064 - video->streaming = 1; 1065 1090 1066 1091 mutex_unlock(&video->stream_lock); 1067 1092 return 0; 1068 1093 1069 1094 err_set_stream: 1070 - omap3isp_video_queue_streamoff(&vfh->queue); 1095 + mutex_lock(&video->queue_lock); 1096 + vb2_streamoff(&vfh->queue, type); 1097 + mutex_unlock(&video->queue_lock); 1071 1098 err_check_format: 1072 1099 media_entity_pipeline_stop(&video->video.entity); 1073 1100 err_pipeline_start: ··· 1103 1130 mutex_lock(&video->stream_lock); 1104 1131 1105 1132 /* Make sure we're not streaming yet. */ 1106 - mutex_lock(&vfh->queue.lock); 1107 - streaming = vfh->queue.streaming; 1108 - mutex_unlock(&vfh->queue.lock); 1133 + mutex_lock(&video->queue_lock); 1134 + streaming = vb2_is_streaming(&vfh->queue); 1135 + mutex_unlock(&video->queue_lock); 1109 1136 1110 1137 if (!streaming) 1111 1138 goto done; ··· 1124 1151 1125 1152 /* Stop the stream. */ 1126 1153 omap3isp_pipeline_set_stream(pipe, ISP_PIPELINE_STREAM_STOPPED); 1127 - omap3isp_video_queue_streamoff(&vfh->queue); 1154 + omap3isp_video_cancel_stream(video); 1155 + 1156 + mutex_lock(&video->queue_lock); 1157 + vb2_streamoff(&vfh->queue, type); 1158 + mutex_unlock(&video->queue_lock); 1128 1159 video->queue = NULL; 1129 - video->streaming = 0; 1130 1160 video->error = false; 1131 1161 1132 1162 if (video->isp->pdata->set_constraints) ··· 1199 1223 { 1200 1224 struct isp_video *video = video_drvdata(file); 1201 1225 struct isp_video_fh *handle; 1226 + struct vb2_queue *queue; 1202 1227 int ret = 0; 1203 1228 1204 1229 handle = kzalloc(sizeof(*handle), GFP_KERNEL); ··· 1221 1244 goto done; 1222 1245 } 1223 1246 1224 - omap3isp_video_queue_init(&handle->queue, video->type, 1225 - &isp_video_queue_ops, video->isp->dev, 1226 - sizeof(struct isp_buffer)); 1247 + queue = &handle->queue; 1248 + queue->type = video->type; 1249 + queue->io_modes = VB2_MMAP | VB2_USERPTR; 1250 + queue->drv_priv = handle; 1251 + queue->ops = &isp_video_queue_ops; 1252 + queue->mem_ops = &vb2_dma_contig_memops; 1253 + queue->buf_struct_size = sizeof(struct isp_buffer); 1254 + queue->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1255 + 1256 + ret = vb2_queue_init(&handle->queue); 1257 + if (ret < 0) { 1258 + omap3isp_put(video->isp); 1259 + goto done; 1260 + } 1227 1261 1228 1262 memset(&handle->format, 0, sizeof(handle->format)); 1229 1263 handle->format.type = video->type; ··· 1261 1273 /* Disable streaming and free the buffers queue resources. */ 1262 1274 isp_video_streamoff(file, vfh, video->type); 1263 1275 1264 - mutex_lock(&handle->queue.lock); 1265 - omap3isp_video_queue_cleanup(&handle->queue); 1266 - mutex_unlock(&handle->queue.lock); 1276 + mutex_lock(&video->queue_lock); 1277 + vb2_queue_release(&handle->queue); 1278 + mutex_unlock(&video->queue_lock); 1267 1279 1268 1280 omap3isp_pipeline_pm_use(&video->video.entity, 0); 1269 1281 ··· 1280 1292 static unsigned int isp_video_poll(struct file *file, poll_table *wait) 1281 1293 { 1282 1294 struct isp_video_fh *vfh = to_isp_video_fh(file->private_data); 1283 - struct isp_video_queue *queue = &vfh->queue; 1295 + struct isp_video *video = video_drvdata(file); 1296 + int ret; 1284 1297 1285 - return omap3isp_video_queue_poll(queue, file, wait); 1298 + mutex_lock(&video->queue_lock); 1299 + ret = vb2_poll(&vfh->queue, file, wait); 1300 + mutex_unlock(&video->queue_lock); 1301 + 1302 + return ret; 1286 1303 } 1287 1304 1288 1305 static int isp_video_mmap(struct file *file, struct vm_area_struct *vma) 1289 1306 { 1290 1307 struct isp_video_fh *vfh = to_isp_video_fh(file->private_data); 1308 + struct isp_video *video = video_drvdata(file); 1309 + int ret; 1291 1310 1292 - return omap3isp_video_queue_mmap(&vfh->queue, vma); 1311 + mutex_lock(&video->queue_lock); 1312 + ret = vb2_mmap(&vfh->queue, vma); 1313 + mutex_unlock(&video->queue_lock); 1314 + 1315 + return ret; 1293 1316 } 1294 1317 1295 1318 static struct v4l2_file_operations isp_video_fops = { ··· 1341 1342 return -EINVAL; 1342 1343 } 1343 1344 1345 + video->alloc_ctx = vb2_dma_contig_init_ctx(video->isp->dev); 1346 + if (IS_ERR(video->alloc_ctx)) 1347 + return PTR_ERR(video->alloc_ctx); 1348 + 1344 1349 ret = media_entity_init(&video->video.entity, 1, &video->pad, 0); 1345 - if (ret < 0) 1350 + if (ret < 0) { 1351 + vb2_dma_contig_cleanup_ctx(video->alloc_ctx); 1346 1352 return ret; 1353 + } 1347 1354 1348 1355 mutex_init(&video->mutex); 1349 1356 atomic_set(&video->active, 0); 1350 1357 1351 1358 spin_lock_init(&video->pipe.lock); 1352 1359 mutex_init(&video->stream_lock); 1360 + mutex_init(&video->queue_lock); 1361 + spin_lock_init(&video->irqlock); 1353 1362 1354 1363 /* Initialize the video device. */ 1355 1364 if (video->ops == NULL) ··· 1378 1371 1379 1372 void omap3isp_video_cleanup(struct isp_video *video) 1380 1373 { 1374 + vb2_dma_contig_cleanup_ctx(video->alloc_ctx); 1381 1375 media_entity_cleanup(&video->video.entity); 1376 + mutex_destroy(&video->queue_lock); 1382 1377 mutex_destroy(&video->stream_lock); 1383 1378 mutex_destroy(&video->mutex); 1384 1379 }

+15 -14

drivers/media/platform/omap3isp/ispvideo.h

··· 30 30 #include <media/media-entity.h> 31 31 #include <media/v4l2-dev.h> 32 32 #include <media/v4l2-fh.h> 33 - 34 - #include "ispqueue.h" 33 + #include <media/videobuf2-core.h> 35 34 36 35 #define ISP_VIDEO_DRIVER_NAME "ispvideo" 37 36 #define ISP_VIDEO_DRIVER_VERSION "0.0.2" ··· 123 124 ISP_PIPELINE_IDLE_OUTPUT); 124 125 } 125 126 126 - /* 127 - * struct isp_buffer - ISP buffer 128 - * @buffer: ISP video buffer 129 - * @isp_addr: MMU mapped address (a.k.a. device address) of the buffer. 127 + /** 128 + * struct isp_buffer - ISP video buffer 129 + * @vb: videobuf2 buffer 130 + * @irqlist: List head for insertion into IRQ queue 131 + * @dma: DMA address 130 132 */ 131 133 struct isp_buffer { 132 - struct isp_video_buffer buffer; 133 - dma_addr_t isp_addr; 134 + struct vb2_buffer vb; 135 + struct list_head irqlist; 136 + dma_addr_t dma; 134 137 }; 135 138 136 - #define to_isp_buffer(buf) container_of(buf, struct isp_buffer, buffer) 139 + #define to_isp_buffer(buf) container_of(buf, struct isp_buffer, vb) 137 140 138 141 enum isp_video_dmaqueue_flags { 139 142 /* Set if DMA queue becomes empty when ISP_PIPELINE_STREAM_CONTINUOUS */ ··· 173 172 unsigned int bpl_value; /* bytes per line value */ 174 173 unsigned int bpl_padding; /* padding at end of line */ 175 174 176 - /* Entity video node streaming */ 177 - unsigned int streaming:1; 178 - 179 175 /* Pipeline state */ 180 176 struct isp_pipeline pipe; 181 177 struct mutex stream_lock; /* pipeline and stream states */ 182 178 bool error; 183 179 184 180 /* Video buffers queue */ 185 - struct isp_video_queue *queue; 181 + void *alloc_ctx; 182 + struct vb2_queue *queue; 183 + struct mutex queue_lock; /* protects the queue */ 184 + spinlock_t irqlock; /* protects dmaqueue */ 186 185 struct list_head dmaqueue; 187 186 enum isp_video_dmaqueue_flags dmaqueue_flags; 188 187 ··· 194 193 struct isp_video_fh { 195 194 struct v4l2_fh vfh; 196 195 struct isp_video *video; 197 - struct isp_video_queue queue; 196 + struct vb2_queue queue; 198 197 struct v4l2_format format; 199 198 struct v4l2_fract timeperframe; 200 199 };

+24

drivers/media/v4l2-core/videobuf2-core.c

··· 1200 1200 EXPORT_SYMBOL_GPL(vb2_buffer_done); 1201 1201 1202 1202 /** 1203 + * vb2_discard_done() - discard all buffers marked as DONE 1204 + * @q: videobuf2 queue 1205 + * 1206 + * This function is intended to be used with suspend/resume operations. It 1207 + * discards all 'done' buffers as they would be too old to be requested after 1208 + * resume. 1209 + * 1210 + * Drivers must stop the hardware and synchronize with interrupt handlers and/or 1211 + * delayed works before calling this function to make sure no buffer will be 1212 + * touched by the driver and/or hardware. 1213 + */ 1214 + void vb2_discard_done(struct vb2_queue *q) 1215 + { 1216 + struct vb2_buffer *vb; 1217 + unsigned long flags; 1218 + 1219 + spin_lock_irqsave(&q->done_lock, flags); 1220 + list_for_each_entry(vb, &q->done_list, done_entry) 1221 + vb->state = VB2_BUF_STATE_ERROR; 1222 + spin_unlock_irqrestore(&q->done_lock, flags); 1223 + } 1224 + EXPORT_SYMBOL_GPL(vb2_discard_done); 1225 + 1226 + /** 1203 1227 * __fill_vb2_buffer() - fill a vb2_buffer with information provided in a 1204 1228 * v4l2_buffer by the userspace. The caller has already verified that struct 1205 1229 * v4l2_buffer has a valid number of planes.

+1 -1

drivers/staging/media/omap4iss/iss_video.c

··· 396 396 } 397 397 } 398 398 399 - static struct vb2_ops iss_video_vb2ops = { 399 + static const struct vb2_ops iss_video_vb2ops = { 400 400 .queue_setup = iss_video_queue_setup, 401 401 .buf_prepare = iss_video_buf_prepare, 402 402 .buf_queue = iss_video_buf_queue,

+1

include/media/videobuf2-core.h

··· 432 432 void *vb2_plane_cookie(struct vb2_buffer *vb, unsigned int plane_no); 433 433 434 434 void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state); 435 + void vb2_discard_done(struct vb2_queue *q); 435 436 int vb2_wait_for_all_buffers(struct vb2_queue *q); 436 437 437 438 int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b);

Configure Feed

Configure Feed