PageRenderTime 56ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/media/video/omap24xxcam.c

https://bitbucket.org/abioy/linux
C | 1899 lines | 1255 code | 343 blank | 301 comment | 202 complexity | 0884cccaae7e04f9ddafa80b1b851f39 MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0, AGPL-1.0
  1. /*
  2. * drivers/media/video/omap24xxcam.c
  3. *
  4. * OMAP 2 camera block driver.
  5. *
  6. * Copyright (C) 2004 MontaVista Software, Inc.
  7. * Copyright (C) 2004 Texas Instruments.
  8. * Copyright (C) 2007-2008 Nokia Corporation.
  9. *
  10. * Contact: Sakari Ailus <sakari.ailus@nokia.com>
  11. *
  12. * Based on code from Andy Lowe <source@mvista.com>
  13. *
  14. * This program is free software; you can redistribute it and/or
  15. * modify it under the terms of the GNU General Public License
  16. * version 2 as published by the Free Software Foundation.
  17. *
  18. * This program is distributed in the hope that it will be useful, but
  19. * WITHOUT ANY WARRANTY; without even the implied warranty of
  20. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  21. * General Public License for more details.
  22. *
  23. * You should have received a copy of the GNU General Public License
  24. * along with this program; if not, write to the Free Software
  25. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  26. * 02110-1301 USA
  27. */
  28. #include <linux/delay.h>
  29. #include <linux/kernel.h>
  30. #include <linux/interrupt.h>
  31. #include <linux/videodev2.h>
  32. #include <linux/pci.h> /* needed for videobufs */
  33. #include <linux/version.h>
  34. #include <linux/platform_device.h>
  35. #include <linux/clk.h>
  36. #include <linux/io.h>
  37. #include <linux/slab.h>
  38. #include <media/v4l2-common.h>
  39. #include <media/v4l2-ioctl.h>
  40. #include "omap24xxcam.h"
  41. #define OMAP24XXCAM_VERSION KERNEL_VERSION(0, 0, 0)
  42. #define RESET_TIMEOUT_NS 10000
  43. static void omap24xxcam_reset(struct omap24xxcam_device *cam);
  44. static int omap24xxcam_sensor_if_enable(struct omap24xxcam_device *cam);
  45. static void omap24xxcam_device_unregister(struct v4l2_int_device *s);
  46. static int omap24xxcam_remove(struct platform_device *pdev);
  47. /* module parameters */
  48. static int video_nr = -1; /* video device minor (-1 ==> auto assign) */
  49. /*
  50. * Maximum amount of memory to use for capture buffers.
  51. * Default is 4800KB, enough to double-buffer SXGA.
  52. */
  53. static int capture_mem = 1280 * 960 * 2 * 2;
  54. static struct v4l2_int_device omap24xxcam;
  55. /*
  56. *
  57. * Clocks.
  58. *
  59. */
  60. static void omap24xxcam_clock_put(struct omap24xxcam_device *cam)
  61. {
  62. if (cam->ick != NULL && !IS_ERR(cam->ick))
  63. clk_put(cam->ick);
  64. if (cam->fck != NULL && !IS_ERR(cam->fck))
  65. clk_put(cam->fck);
  66. cam->ick = cam->fck = NULL;
  67. }
  68. static int omap24xxcam_clock_get(struct omap24xxcam_device *cam)
  69. {
  70. int rval = 0;
  71. cam->fck = clk_get(cam->dev, "fck");
  72. if (IS_ERR(cam->fck)) {
  73. dev_err(cam->dev, "can't get camera fck");
  74. rval = PTR_ERR(cam->fck);
  75. omap24xxcam_clock_put(cam);
  76. return rval;
  77. }
  78. cam->ick = clk_get(cam->dev, "ick");
  79. if (IS_ERR(cam->ick)) {
  80. dev_err(cam->dev, "can't get camera ick");
  81. rval = PTR_ERR(cam->ick);
  82. omap24xxcam_clock_put(cam);
  83. }
  84. return rval;
  85. }
  86. static void omap24xxcam_clock_on(struct omap24xxcam_device *cam)
  87. {
  88. clk_enable(cam->fck);
  89. clk_enable(cam->ick);
  90. }
  91. static void omap24xxcam_clock_off(struct omap24xxcam_device *cam)
  92. {
  93. clk_disable(cam->fck);
  94. clk_disable(cam->ick);
  95. }
  96. /*
  97. *
  98. * Camera core
  99. *
  100. */
  101. /*
  102. * Set xclk.
  103. *
  104. * To disable xclk, use value zero.
  105. */
  106. static void omap24xxcam_core_xclk_set(const struct omap24xxcam_device *cam,
  107. u32 xclk)
  108. {
  109. if (xclk) {
  110. u32 divisor = CAM_MCLK / xclk;
  111. if (divisor == 1)
  112. omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
  113. CC_CTRL_XCLK,
  114. CC_CTRL_XCLK_DIV_BYPASS);
  115. else
  116. omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
  117. CC_CTRL_XCLK, divisor);
  118. } else
  119. omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
  120. CC_CTRL_XCLK, CC_CTRL_XCLK_DIV_STABLE_LOW);
  121. }
  122. static void omap24xxcam_core_hwinit(const struct omap24xxcam_device *cam)
  123. {
  124. /*
  125. * Setting the camera core AUTOIDLE bit causes problems with frame
  126. * synchronization, so we will clear the AUTOIDLE bit instead.
  127. */
  128. omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_SYSCONFIG,
  129. CC_SYSCONFIG_AUTOIDLE);
  130. /* program the camera interface DMA packet size */
  131. omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL_DMA,
  132. CC_CTRL_DMA_EN | (DMA_THRESHOLD / 4 - 1));
  133. /* enable camera core error interrupts */
  134. omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_IRQENABLE,
  135. CC_IRQENABLE_FW_ERR_IRQ
  136. | CC_IRQENABLE_FSC_ERR_IRQ
  137. | CC_IRQENABLE_SSC_ERR_IRQ
  138. | CC_IRQENABLE_FIFO_OF_IRQ);
  139. }
  140. /*
  141. * Enable the camera core.
  142. *
  143. * Data transfer to the camera DMA starts from next starting frame.
  144. */
  145. static void omap24xxcam_core_enable(const struct omap24xxcam_device *cam)
  146. {
  147. omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL,
  148. cam->cc_ctrl);
  149. }
  150. /*
  151. * Disable camera core.
  152. *
  153. * The data transfer will be stopped immediately (CC_CTRL_CC_RST). The
  154. * core internal state machines will be reset. Use
  155. * CC_CTRL_CC_FRAME_TRIG instead if you want to transfer the current
  156. * frame completely.
  157. */
  158. static void omap24xxcam_core_disable(const struct omap24xxcam_device *cam)
  159. {
  160. omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL,
  161. CC_CTRL_CC_RST);
  162. }
  163. /* Interrupt service routine for camera core interrupts. */
  164. static void omap24xxcam_core_isr(struct omap24xxcam_device *cam)
  165. {
  166. u32 cc_irqstatus;
  167. const u32 cc_irqstatus_err =
  168. CC_IRQSTATUS_FW_ERR_IRQ
  169. | CC_IRQSTATUS_FSC_ERR_IRQ
  170. | CC_IRQSTATUS_SSC_ERR_IRQ
  171. | CC_IRQSTATUS_FIFO_UF_IRQ
  172. | CC_IRQSTATUS_FIFO_OF_IRQ;
  173. cc_irqstatus = omap24xxcam_reg_in(cam->mmio_base + CC_REG_OFFSET,
  174. CC_IRQSTATUS);
  175. omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_IRQSTATUS,
  176. cc_irqstatus);
  177. if (cc_irqstatus & cc_irqstatus_err
  178. && !atomic_read(&cam->in_reset)) {
  179. dev_dbg(cam->dev, "resetting camera, cc_irqstatus 0x%x\n",
  180. cc_irqstatus);
  181. omap24xxcam_reset(cam);
  182. }
  183. }
  184. /*
  185. *
  186. * videobuf_buffer handling.
  187. *
  188. * Memory for mmapped videobuf_buffers is not allocated
  189. * conventionally, but by several kmalloc allocations and then
  190. * creating the scatterlist on our own. User-space buffers are handled
  191. * normally.
  192. *
  193. */
  194. /*
  195. * Free the memory-mapped buffer memory allocated for a
  196. * videobuf_buffer and the associated scatterlist.
  197. */
  198. static void omap24xxcam_vbq_free_mmap_buffer(struct videobuf_buffer *vb)
  199. {
  200. struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
  201. size_t alloc_size;
  202. struct page *page;
  203. int i;
  204. if (dma->sglist == NULL)
  205. return;
  206. i = dma->sglen;
  207. while (i) {
  208. i--;
  209. alloc_size = sg_dma_len(&dma->sglist[i]);
  210. page = sg_page(&dma->sglist[i]);
  211. do {
  212. ClearPageReserved(page++);
  213. } while (alloc_size -= PAGE_SIZE);
  214. __free_pages(sg_page(&dma->sglist[i]),
  215. get_order(sg_dma_len(&dma->sglist[i])));
  216. }
  217. kfree(dma->sglist);
  218. dma->sglist = NULL;
  219. }
  220. /* Release all memory related to the videobuf_queue. */
  221. static void omap24xxcam_vbq_free_mmap_buffers(struct videobuf_queue *vbq)
  222. {
  223. int i;
  224. mutex_lock(&vbq->vb_lock);
  225. for (i = 0; i < VIDEO_MAX_FRAME; i++) {
  226. if (NULL == vbq->bufs[i])
  227. continue;
  228. if (V4L2_MEMORY_MMAP != vbq->bufs[i]->memory)
  229. continue;
  230. vbq->ops->buf_release(vbq, vbq->bufs[i]);
  231. omap24xxcam_vbq_free_mmap_buffer(vbq->bufs[i]);
  232. kfree(vbq->bufs[i]);
  233. vbq->bufs[i] = NULL;
  234. }
  235. mutex_unlock(&vbq->vb_lock);
  236. videobuf_mmap_free(vbq);
  237. }
  238. /*
  239. * Allocate physically as contiguous as possible buffer for video
  240. * frame and allocate and build DMA scatter-gather list for it.
  241. */
  242. static int omap24xxcam_vbq_alloc_mmap_buffer(struct videobuf_buffer *vb)
  243. {
  244. unsigned int order;
  245. size_t alloc_size, size = vb->bsize; /* vb->bsize is page aligned */
  246. struct page *page;
  247. int max_pages, err = 0, i = 0;
  248. struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
  249. /*
  250. * allocate maximum size scatter-gather list. Note this is
  251. * overhead. We may not use as many entries as we allocate
  252. */
  253. max_pages = vb->bsize >> PAGE_SHIFT;
  254. dma->sglist = kcalloc(max_pages, sizeof(*dma->sglist), GFP_KERNEL);
  255. if (dma->sglist == NULL) {
  256. err = -ENOMEM;
  257. goto out;
  258. }
  259. while (size) {
  260. order = get_order(size);
  261. /*
  262. * do not over-allocate even if we would get larger
  263. * contiguous chunk that way
  264. */
  265. if ((PAGE_SIZE << order) > size)
  266. order--;
  267. /* try to allocate as many contiguous pages as possible */
  268. page = alloc_pages(GFP_KERNEL | GFP_DMA, order);
  269. /* if allocation fails, try to allocate smaller amount */
  270. while (page == NULL) {
  271. order--;
  272. page = alloc_pages(GFP_KERNEL | GFP_DMA, order);
  273. if (page == NULL && !order) {
  274. err = -ENOMEM;
  275. goto out;
  276. }
  277. }
  278. size -= (PAGE_SIZE << order);
  279. /* append allocated chunk of pages into scatter-gather list */
  280. sg_set_page(&dma->sglist[i], page, PAGE_SIZE << order, 0);
  281. dma->sglen++;
  282. i++;
  283. alloc_size = (PAGE_SIZE << order);
  284. /* clear pages before giving them to user space */
  285. memset(page_address(page), 0, alloc_size);
  286. /* mark allocated pages reserved */
  287. do {
  288. SetPageReserved(page++);
  289. } while (alloc_size -= PAGE_SIZE);
  290. }
  291. /*
  292. * REVISIT: not fully correct to assign nr_pages == sglen but
  293. * video-buf is passing nr_pages for e.g. unmap_sg calls
  294. */
  295. dma->nr_pages = dma->sglen;
  296. dma->direction = PCI_DMA_FROMDEVICE;
  297. return 0;
  298. out:
  299. omap24xxcam_vbq_free_mmap_buffer(vb);
  300. return err;
  301. }
  302. static int omap24xxcam_vbq_alloc_mmap_buffers(struct videobuf_queue *vbq,
  303. unsigned int count)
  304. {
  305. int i, err = 0;
  306. struct omap24xxcam_fh *fh =
  307. container_of(vbq, struct omap24xxcam_fh, vbq);
  308. mutex_lock(&vbq->vb_lock);
  309. for (i = 0; i < count; i++) {
  310. err = omap24xxcam_vbq_alloc_mmap_buffer(vbq->bufs[i]);
  311. if (err)
  312. goto out;
  313. dev_dbg(fh->cam->dev, "sglen is %d for buffer %d\n",
  314. videobuf_to_dma(vbq->bufs[i])->sglen, i);
  315. }
  316. mutex_unlock(&vbq->vb_lock);
  317. return 0;
  318. out:
  319. while (i) {
  320. i--;
  321. omap24xxcam_vbq_free_mmap_buffer(vbq->bufs[i]);
  322. }
  323. mutex_unlock(&vbq->vb_lock);
  324. return err;
  325. }
  326. /*
  327. * This routine is called from interrupt context when a scatter-gather DMA
  328. * transfer of a videobuf_buffer completes.
  329. */
  330. static void omap24xxcam_vbq_complete(struct omap24xxcam_sgdma *sgdma,
  331. u32 csr, void *arg)
  332. {
  333. struct omap24xxcam_device *cam =
  334. container_of(sgdma, struct omap24xxcam_device, sgdma);
  335. struct omap24xxcam_fh *fh = cam->streaming->private_data;
  336. struct videobuf_buffer *vb = (struct videobuf_buffer *)arg;
  337. const u32 csr_error = CAMDMA_CSR_MISALIGNED_ERR
  338. | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
  339. | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
  340. unsigned long flags;
  341. spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
  342. if (--cam->sgdma_in_queue == 0)
  343. omap24xxcam_core_disable(cam);
  344. spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
  345. do_gettimeofday(&vb->ts);
  346. vb->field_count = atomic_add_return(2, &fh->field_count);
  347. if (csr & csr_error) {
  348. vb->state = VIDEOBUF_ERROR;
  349. if (!atomic_read(&fh->cam->in_reset)) {
  350. dev_dbg(cam->dev, "resetting camera, csr 0x%x\n", csr);
  351. omap24xxcam_reset(cam);
  352. }
  353. } else
  354. vb->state = VIDEOBUF_DONE;
  355. wake_up(&vb->done);
  356. }
  357. static void omap24xxcam_vbq_release(struct videobuf_queue *vbq,
  358. struct videobuf_buffer *vb)
  359. {
  360. struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
  361. /* wait for buffer, especially to get out of the sgdma queue */
  362. videobuf_waiton(vb, 0, 0);
  363. if (vb->memory == V4L2_MEMORY_MMAP) {
  364. dma_unmap_sg(vbq->dev, dma->sglist, dma->sglen,
  365. dma->direction);
  366. dma->direction = DMA_NONE;
  367. } else {
  368. videobuf_dma_unmap(vbq, videobuf_to_dma(vb));
  369. videobuf_dma_free(videobuf_to_dma(vb));
  370. }
  371. vb->state = VIDEOBUF_NEEDS_INIT;
  372. }
  373. /*
  374. * Limit the number of available kernel image capture buffers based on the
  375. * number requested, the currently selected image size, and the maximum
  376. * amount of memory permitted for kernel capture buffers.
  377. */
  378. static int omap24xxcam_vbq_setup(struct videobuf_queue *vbq, unsigned int *cnt,
  379. unsigned int *size)
  380. {
  381. struct omap24xxcam_fh *fh = vbq->priv_data;
  382. if (*cnt <= 0)
  383. *cnt = VIDEO_MAX_FRAME; /* supply a default number of buffers */
  384. if (*cnt > VIDEO_MAX_FRAME)
  385. *cnt = VIDEO_MAX_FRAME;
  386. *size = fh->pix.sizeimage;
  387. /* accessing fh->cam->capture_mem is ok, it's constant */
  388. while (*size * *cnt > fh->cam->capture_mem)
  389. (*cnt)--;
  390. return 0;
  391. }
  392. static int omap24xxcam_dma_iolock(struct videobuf_queue *vbq,
  393. struct videobuf_dmabuf *dma)
  394. {
  395. int err = 0;
  396. dma->direction = PCI_DMA_FROMDEVICE;
  397. if (!dma_map_sg(vbq->dev, dma->sglist, dma->sglen, dma->direction)) {
  398. kfree(dma->sglist);
  399. dma->sglist = NULL;
  400. dma->sglen = 0;
  401. err = -EIO;
  402. }
  403. return err;
  404. }
  405. static int omap24xxcam_vbq_prepare(struct videobuf_queue *vbq,
  406. struct videobuf_buffer *vb,
  407. enum v4l2_field field)
  408. {
  409. struct omap24xxcam_fh *fh = vbq->priv_data;
  410. int err = 0;
  411. /*
  412. * Accessing pix here is okay since it's constant while
  413. * streaming is on (and we only get called then).
  414. */
  415. if (vb->baddr) {
  416. /* This is a userspace buffer. */
  417. if (fh->pix.sizeimage > vb->bsize) {
  418. /* The buffer isn't big enough. */
  419. err = -EINVAL;
  420. } else
  421. vb->size = fh->pix.sizeimage;
  422. } else {
  423. if (vb->state != VIDEOBUF_NEEDS_INIT) {
  424. /*
  425. * We have a kernel bounce buffer that has
  426. * already been allocated.
  427. */
  428. if (fh->pix.sizeimage > vb->size) {
  429. /*
  430. * The image size has been changed to
  431. * a larger size since this buffer was
  432. * allocated, so we need to free and
  433. * reallocate it.
  434. */
  435. omap24xxcam_vbq_release(vbq, vb);
  436. vb->size = fh->pix.sizeimage;
  437. }
  438. } else {
  439. /* We need to allocate a new kernel bounce buffer. */
  440. vb->size = fh->pix.sizeimage;
  441. }
  442. }
  443. if (err)
  444. return err;
  445. vb->width = fh->pix.width;
  446. vb->height = fh->pix.height;
  447. vb->field = field;
  448. if (vb->state == VIDEOBUF_NEEDS_INIT) {
  449. if (vb->memory == V4L2_MEMORY_MMAP)
  450. /*
  451. * we have built the scatter-gather list by ourself so
  452. * do the scatter-gather mapping as well
  453. */
  454. err = omap24xxcam_dma_iolock(vbq, videobuf_to_dma(vb));
  455. else
  456. err = videobuf_iolock(vbq, vb, NULL);
  457. }
  458. if (!err)
  459. vb->state = VIDEOBUF_PREPARED;
  460. else
  461. omap24xxcam_vbq_release(vbq, vb);
  462. return err;
  463. }
  464. static void omap24xxcam_vbq_queue(struct videobuf_queue *vbq,
  465. struct videobuf_buffer *vb)
  466. {
  467. struct omap24xxcam_fh *fh = vbq->priv_data;
  468. struct omap24xxcam_device *cam = fh->cam;
  469. enum videobuf_state state = vb->state;
  470. unsigned long flags;
  471. int err;
  472. /*
  473. * FIXME: We're marking the buffer active since we have no
  474. * pretty way of marking it active exactly when the
  475. * scatter-gather transfer starts.
  476. */
  477. vb->state = VIDEOBUF_ACTIVE;
  478. err = omap24xxcam_sgdma_queue(&fh->cam->sgdma,
  479. videobuf_to_dma(vb)->sglist,
  480. videobuf_to_dma(vb)->sglen, vb->size,
  481. omap24xxcam_vbq_complete, vb);
  482. if (!err) {
  483. spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
  484. if (++cam->sgdma_in_queue == 1
  485. && !atomic_read(&cam->in_reset))
  486. omap24xxcam_core_enable(cam);
  487. spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
  488. } else {
  489. /*
  490. * Oops. We're not supposed to get any errors here.
  491. * The only way we could get an error is if we ran out
  492. * of scatter-gather DMA slots, but we are supposed to
  493. * have at least as many scatter-gather DMA slots as
  494. * video buffers so that can't happen.
  495. */
  496. dev_err(cam->dev, "failed to queue a video buffer for dma!\n");
  497. dev_err(cam->dev, "likely a bug in the driver!\n");
  498. vb->state = state;
  499. }
  500. }
  501. static struct videobuf_queue_ops omap24xxcam_vbq_ops = {
  502. .buf_setup = omap24xxcam_vbq_setup,
  503. .buf_prepare = omap24xxcam_vbq_prepare,
  504. .buf_queue = omap24xxcam_vbq_queue,
  505. .buf_release = omap24xxcam_vbq_release,
  506. };
  507. /*
  508. *
  509. * OMAP main camera system
  510. *
  511. */
  512. /*
  513. * Reset camera block to power-on state.
  514. */
  515. static void omap24xxcam_poweron_reset(struct omap24xxcam_device *cam)
  516. {
  517. int max_loop = RESET_TIMEOUT_NS;
  518. /* Reset whole camera subsystem */
  519. omap24xxcam_reg_out(cam->mmio_base,
  520. CAM_SYSCONFIG,
  521. CAM_SYSCONFIG_SOFTRESET);
  522. /* Wait till it's finished */
  523. while (!(omap24xxcam_reg_in(cam->mmio_base, CAM_SYSSTATUS)
  524. & CAM_SYSSTATUS_RESETDONE)
  525. && --max_loop) {
  526. ndelay(1);
  527. }
  528. if (!(omap24xxcam_reg_in(cam->mmio_base, CAM_SYSSTATUS)
  529. & CAM_SYSSTATUS_RESETDONE))
  530. dev_err(cam->dev, "camera soft reset timeout\n");
  531. }
  532. /*
  533. * (Re)initialise the camera block.
  534. */
  535. static void omap24xxcam_hwinit(struct omap24xxcam_device *cam)
  536. {
  537. omap24xxcam_poweron_reset(cam);
  538. /* set the camera subsystem autoidle bit */
  539. omap24xxcam_reg_out(cam->mmio_base, CAM_SYSCONFIG,
  540. CAM_SYSCONFIG_AUTOIDLE);
  541. /* set the camera MMU autoidle bit */
  542. omap24xxcam_reg_out(cam->mmio_base,
  543. CAMMMU_REG_OFFSET + CAMMMU_SYSCONFIG,
  544. CAMMMU_SYSCONFIG_AUTOIDLE);
  545. omap24xxcam_core_hwinit(cam);
  546. omap24xxcam_dma_hwinit(&cam->sgdma.dma);
  547. }
  548. /*
  549. * Callback for dma transfer stalling.
  550. */
  551. static void omap24xxcam_stalled_dma_reset(unsigned long data)
  552. {
  553. struct omap24xxcam_device *cam = (struct omap24xxcam_device *)data;
  554. if (!atomic_read(&cam->in_reset)) {
  555. dev_dbg(cam->dev, "dma stalled, resetting camera\n");
  556. omap24xxcam_reset(cam);
  557. }
  558. }
  559. /*
  560. * Stop capture. Mark we're doing a reset, stop DMA transfers and
  561. * core. (No new scatter-gather transfers will be queued whilst
  562. * in_reset is non-zero.)
  563. *
  564. * If omap24xxcam_capture_stop is called from several places at
  565. * once, only the first call will have an effect. Similarly, the last
  566. * call omap24xxcam_streaming_cont will have effect.
  567. *
  568. * Serialisation is ensured by using cam->core_enable_disable_lock.
  569. */
  570. static void omap24xxcam_capture_stop(struct omap24xxcam_device *cam)
  571. {
  572. unsigned long flags;
  573. spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
  574. if (atomic_inc_return(&cam->in_reset) != 1) {
  575. spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
  576. return;
  577. }
  578. omap24xxcam_core_disable(cam);
  579. spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
  580. omap24xxcam_sgdma_sync(&cam->sgdma);
  581. }
  582. /*
  583. * Reset and continue streaming.
  584. *
  585. * Note: Resetting the camera FIFO via the CC_RST bit in the CC_CTRL
  586. * register is supposed to be sufficient to recover from a camera
  587. * interface error, but it doesn't seem to be enough. If we only do
  588. * that then subsequent image captures are out of sync by either one
  589. * or two times DMA_THRESHOLD bytes. Resetting and re-initializing the
  590. * entire camera subsystem prevents the problem with frame
  591. * synchronization.
  592. */
  593. static void omap24xxcam_capture_cont(struct omap24xxcam_device *cam)
  594. {
  595. unsigned long flags;
  596. spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
  597. if (atomic_read(&cam->in_reset) != 1)
  598. goto out;
  599. omap24xxcam_hwinit(cam);
  600. omap24xxcam_sensor_if_enable(cam);
  601. omap24xxcam_sgdma_process(&cam->sgdma);
  602. if (cam->sgdma_in_queue)
  603. omap24xxcam_core_enable(cam);
  604. out:
  605. atomic_dec(&cam->in_reset);
  606. spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
  607. }
  608. static ssize_t
  609. omap24xxcam_streaming_show(struct device *dev, struct device_attribute *attr,
  610. char *buf)
  611. {
  612. struct omap24xxcam_device *cam = dev_get_drvdata(dev);
  613. return sprintf(buf, "%s\n", cam->streaming ? "active" : "inactive");
  614. }
  615. static DEVICE_ATTR(streaming, S_IRUGO, omap24xxcam_streaming_show, NULL);
  616. /*
  617. * Stop capture and restart it. I.e. reset the camera during use.
  618. */
  619. static void omap24xxcam_reset(struct omap24xxcam_device *cam)
  620. {
  621. omap24xxcam_capture_stop(cam);
  622. omap24xxcam_capture_cont(cam);
  623. }
  624. /*
  625. * The main interrupt handler.
  626. */
  627. static irqreturn_t omap24xxcam_isr(int irq, void *arg)
  628. {
  629. struct omap24xxcam_device *cam = (struct omap24xxcam_device *)arg;
  630. u32 irqstatus;
  631. unsigned int irqhandled = 0;
  632. irqstatus = omap24xxcam_reg_in(cam->mmio_base, CAM_IRQSTATUS);
  633. if (irqstatus &
  634. (CAM_IRQSTATUS_DMA_IRQ2 | CAM_IRQSTATUS_DMA_IRQ1
  635. | CAM_IRQSTATUS_DMA_IRQ0)) {
  636. omap24xxcam_dma_isr(&cam->sgdma.dma);
  637. irqhandled = 1;
  638. }
  639. if (irqstatus & CAM_IRQSTATUS_CC_IRQ) {
  640. omap24xxcam_core_isr(cam);
  641. irqhandled = 1;
  642. }
  643. if (irqstatus & CAM_IRQSTATUS_MMU_IRQ)
  644. dev_err(cam->dev, "unhandled camera MMU interrupt!\n");
  645. return IRQ_RETVAL(irqhandled);
  646. }
  647. /*
  648. *
  649. * Sensor handling.
  650. *
  651. */
  652. /*
  653. * Enable the external sensor interface. Try to negotiate interface
  654. * parameters with the sensor and start using the new ones. The calls
  655. * to sensor_if_enable and sensor_if_disable need not to be balanced.
  656. */
  657. static int omap24xxcam_sensor_if_enable(struct omap24xxcam_device *cam)
  658. {
  659. int rval;
  660. struct v4l2_ifparm p;
  661. rval = vidioc_int_g_ifparm(cam->sdev, &p);
  662. if (rval) {
  663. dev_err(cam->dev, "vidioc_int_g_ifparm failed with %d\n", rval);
  664. return rval;
  665. }
  666. cam->if_type = p.if_type;
  667. cam->cc_ctrl = CC_CTRL_CC_EN;
  668. switch (p.if_type) {
  669. case V4L2_IF_TYPE_BT656:
  670. if (p.u.bt656.frame_start_on_rising_vs)
  671. cam->cc_ctrl |= CC_CTRL_NOBT_SYNCHRO;
  672. if (p.u.bt656.bt_sync_correct)
  673. cam->cc_ctrl |= CC_CTRL_BT_CORRECT;
  674. if (p.u.bt656.swap)
  675. cam->cc_ctrl |= CC_CTRL_PAR_ORDERCAM;
  676. if (p.u.bt656.latch_clk_inv)
  677. cam->cc_ctrl |= CC_CTRL_PAR_CLK_POL;
  678. if (p.u.bt656.nobt_hs_inv)
  679. cam->cc_ctrl |= CC_CTRL_NOBT_HS_POL;
  680. if (p.u.bt656.nobt_vs_inv)
  681. cam->cc_ctrl |= CC_CTRL_NOBT_VS_POL;
  682. switch (p.u.bt656.mode) {
  683. case V4L2_IF_TYPE_BT656_MODE_NOBT_8BIT:
  684. cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT8;
  685. break;
  686. case V4L2_IF_TYPE_BT656_MODE_NOBT_10BIT:
  687. cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT10;
  688. break;
  689. case V4L2_IF_TYPE_BT656_MODE_NOBT_12BIT:
  690. cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT12;
  691. break;
  692. case V4L2_IF_TYPE_BT656_MODE_BT_8BIT:
  693. cam->cc_ctrl |= CC_CTRL_PAR_MODE_BT8;
  694. break;
  695. case V4L2_IF_TYPE_BT656_MODE_BT_10BIT:
  696. cam->cc_ctrl |= CC_CTRL_PAR_MODE_BT10;
  697. break;
  698. default:
  699. dev_err(cam->dev,
  700. "bt656 interface mode %d not supported\n",
  701. p.u.bt656.mode);
  702. return -EINVAL;
  703. }
  704. /*
  705. * The clock rate that the sensor wants has changed.
  706. * We have to adjust the xclk from OMAP 2 side to
  707. * match the sensor's wish as closely as possible.
  708. */
  709. if (p.u.bt656.clock_curr != cam->if_u.bt656.xclk) {
  710. u32 xclk = p.u.bt656.clock_curr;
  711. u32 divisor;
  712. if (xclk == 0)
  713. return -EINVAL;
  714. if (xclk > CAM_MCLK)
  715. xclk = CAM_MCLK;
  716. divisor = CAM_MCLK / xclk;
  717. if (divisor * xclk < CAM_MCLK)
  718. divisor++;
  719. if (CAM_MCLK / divisor < p.u.bt656.clock_min
  720. && divisor > 1)
  721. divisor--;
  722. if (divisor > 30)
  723. divisor = 30;
  724. xclk = CAM_MCLK / divisor;
  725. if (xclk < p.u.bt656.clock_min
  726. || xclk > p.u.bt656.clock_max)
  727. return -EINVAL;
  728. cam->if_u.bt656.xclk = xclk;
  729. }
  730. omap24xxcam_core_xclk_set(cam, cam->if_u.bt656.xclk);
  731. break;
  732. default:
  733. /* FIXME: how about other interfaces? */
  734. dev_err(cam->dev, "interface type %d not supported\n",
  735. p.if_type);
  736. return -EINVAL;
  737. }
  738. return 0;
  739. }
  740. static void omap24xxcam_sensor_if_disable(const struct omap24xxcam_device *cam)
  741. {
  742. switch (cam->if_type) {
  743. case V4L2_IF_TYPE_BT656:
  744. omap24xxcam_core_xclk_set(cam, 0);
  745. break;
  746. }
  747. }
  748. /*
  749. * Initialise the sensor hardware.
  750. */
  751. static int omap24xxcam_sensor_init(struct omap24xxcam_device *cam)
  752. {
  753. int err = 0;
  754. struct v4l2_int_device *sdev = cam->sdev;
  755. omap24xxcam_clock_on(cam);
  756. err = omap24xxcam_sensor_if_enable(cam);
  757. if (err) {
  758. dev_err(cam->dev, "sensor interface could not be enabled at "
  759. "initialisation, %d\n", err);
  760. cam->sdev = NULL;
  761. goto out;
  762. }
  763. /* power up sensor during sensor initialization */
  764. vidioc_int_s_power(sdev, 1);
  765. err = vidioc_int_dev_init(sdev);
  766. if (err) {
  767. dev_err(cam->dev, "cannot initialize sensor, error %d\n", err);
  768. /* Sensor init failed --- it's nonexistent to us! */
  769. cam->sdev = NULL;
  770. goto out;
  771. }
  772. dev_info(cam->dev, "sensor is %s\n", sdev->name);
  773. out:
  774. omap24xxcam_sensor_if_disable(cam);
  775. omap24xxcam_clock_off(cam);
  776. vidioc_int_s_power(sdev, 0);
  777. return err;
  778. }
  779. static void omap24xxcam_sensor_exit(struct omap24xxcam_device *cam)
  780. {
  781. if (cam->sdev)
  782. vidioc_int_dev_exit(cam->sdev);
  783. }
  784. static void omap24xxcam_sensor_disable(struct omap24xxcam_device *cam)
  785. {
  786. omap24xxcam_sensor_if_disable(cam);
  787. omap24xxcam_clock_off(cam);
  788. vidioc_int_s_power(cam->sdev, 0);
  789. }
  790. /*
  791. * Power-up and configure camera sensor. It's ready for capturing now.
  792. */
  793. static int omap24xxcam_sensor_enable(struct omap24xxcam_device *cam)
  794. {
  795. int rval;
  796. omap24xxcam_clock_on(cam);
  797. omap24xxcam_sensor_if_enable(cam);
  798. rval = vidioc_int_s_power(cam->sdev, 1);
  799. if (rval)
  800. goto out;
  801. rval = vidioc_int_init(cam->sdev);
  802. if (rval)
  803. goto out;
  804. return 0;
  805. out:
  806. omap24xxcam_sensor_disable(cam);
  807. return rval;
  808. }
  809. static void omap24xxcam_sensor_reset_work(struct work_struct *work)
  810. {
  811. struct omap24xxcam_device *cam =
  812. container_of(work, struct omap24xxcam_device,
  813. sensor_reset_work);
  814. if (atomic_read(&cam->reset_disable))
  815. return;
  816. omap24xxcam_capture_stop(cam);
  817. if (vidioc_int_reset(cam->sdev) == 0) {
  818. vidioc_int_init(cam->sdev);
  819. } else {
  820. /* Can't reset it by vidioc_int_reset. */
  821. omap24xxcam_sensor_disable(cam);
  822. omap24xxcam_sensor_enable(cam);
  823. }
  824. omap24xxcam_capture_cont(cam);
  825. }
  826. /*
  827. *
  828. * IOCTL interface.
  829. *
  830. */
  831. static int vidioc_querycap(struct file *file, void *fh,
  832. struct v4l2_capability *cap)
  833. {
  834. struct omap24xxcam_fh *ofh = fh;
  835. struct omap24xxcam_device *cam = ofh->cam;
  836. strlcpy(cap->driver, CAM_NAME, sizeof(cap->driver));
  837. strlcpy(cap->card, cam->vfd->name, sizeof(cap->card));
  838. cap->version = OMAP24XXCAM_VERSION;
  839. cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
  840. return 0;
  841. }
  842. static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
  843. struct v4l2_fmtdesc *f)
  844. {
  845. struct omap24xxcam_fh *ofh = fh;
  846. struct omap24xxcam_device *cam = ofh->cam;
  847. int rval;
  848. rval = vidioc_int_enum_fmt_cap(cam->sdev, f);
  849. return rval;
  850. }
  851. static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
  852. struct v4l2_format *f)
  853. {
  854. struct omap24xxcam_fh *ofh = fh;
  855. struct omap24xxcam_device *cam = ofh->cam;
  856. int rval;
  857. mutex_lock(&cam->mutex);
  858. rval = vidioc_int_g_fmt_cap(cam->sdev, f);
  859. mutex_unlock(&cam->mutex);
  860. return rval;
  861. }
  862. static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
  863. struct v4l2_format *f)
  864. {
  865. struct omap24xxcam_fh *ofh = fh;
  866. struct omap24xxcam_device *cam = ofh->cam;
  867. int rval;
  868. mutex_lock(&cam->mutex);
  869. if (cam->streaming) {
  870. rval = -EBUSY;
  871. goto out;
  872. }
  873. rval = vidioc_int_s_fmt_cap(cam->sdev, f);
  874. out:
  875. mutex_unlock(&cam->mutex);
  876. if (!rval) {
  877. mutex_lock(&ofh->vbq.vb_lock);
  878. ofh->pix = f->fmt.pix;
  879. mutex_unlock(&ofh->vbq.vb_lock);
  880. }
  881. memset(f, 0, sizeof(*f));
  882. vidioc_g_fmt_vid_cap(file, fh, f);
  883. return rval;
  884. }
  885. static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
  886. struct v4l2_format *f)
  887. {
  888. struct omap24xxcam_fh *ofh = fh;
  889. struct omap24xxcam_device *cam = ofh->cam;
  890. int rval;
  891. mutex_lock(&cam->mutex);
  892. rval = vidioc_int_try_fmt_cap(cam->sdev, f);
  893. mutex_unlock(&cam->mutex);
  894. return rval;
  895. }
  896. static int vidioc_reqbufs(struct file *file, void *fh,
  897. struct v4l2_requestbuffers *b)
  898. {
  899. struct omap24xxcam_fh *ofh = fh;
  900. struct omap24xxcam_device *cam = ofh->cam;
  901. int rval;
  902. mutex_lock(&cam->mutex);
  903. if (cam->streaming) {
  904. mutex_unlock(&cam->mutex);
  905. return -EBUSY;
  906. }
  907. omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
  908. mutex_unlock(&cam->mutex);
  909. rval = videobuf_reqbufs(&ofh->vbq, b);
  910. /*
  911. * Either videobuf_reqbufs failed or the buffers are not
  912. * memory-mapped (which would need special attention).
  913. */
  914. if (rval < 0 || b->memory != V4L2_MEMORY_MMAP)
  915. goto out;
  916. rval = omap24xxcam_vbq_alloc_mmap_buffers(&ofh->vbq, rval);
  917. if (rval)
  918. omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
  919. out:
  920. return rval;
  921. }
  922. static int vidioc_querybuf(struct file *file, void *fh,
  923. struct v4l2_buffer *b)
  924. {
  925. struct omap24xxcam_fh *ofh = fh;
  926. return videobuf_querybuf(&ofh->vbq, b);
  927. }
  928. static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
  929. {
  930. struct omap24xxcam_fh *ofh = fh;
  931. return videobuf_qbuf(&ofh->vbq, b);
  932. }
  933. static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
  934. {
  935. struct omap24xxcam_fh *ofh = fh;
  936. struct omap24xxcam_device *cam = ofh->cam;
  937. struct videobuf_buffer *vb;
  938. int rval;
  939. videobuf_dqbuf_again:
  940. rval = videobuf_dqbuf(&ofh->vbq, b, file->f_flags & O_NONBLOCK);
  941. if (rval)
  942. goto out;
  943. vb = ofh->vbq.bufs[b->index];
  944. mutex_lock(&cam->mutex);
  945. /* _needs_reset returns -EIO if reset is required. */
  946. rval = vidioc_int_g_needs_reset(cam->sdev, (void *)vb->baddr);
  947. mutex_unlock(&cam->mutex);
  948. if (rval == -EIO)
  949. schedule_work(&cam->sensor_reset_work);
  950. else
  951. rval = 0;
  952. out:
  953. /*
  954. * This is a hack. We don't want to show -EIO to the user
  955. * space. Requeue the buffer and try again if we're not doing
  956. * this in non-blocking mode.
  957. */
  958. if (rval == -EIO) {
  959. videobuf_qbuf(&ofh->vbq, b);
  960. if (!(file->f_flags & O_NONBLOCK))
  961. goto videobuf_dqbuf_again;
  962. /*
  963. * We don't have a videobuf_buffer now --- maybe next
  964. * time...
  965. */
  966. rval = -EAGAIN;
  967. }
  968. return rval;
  969. }
  970. static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
  971. {
  972. struct omap24xxcam_fh *ofh = fh;
  973. struct omap24xxcam_device *cam = ofh->cam;
  974. int rval;
  975. mutex_lock(&cam->mutex);
  976. if (cam->streaming) {
  977. rval = -EBUSY;
  978. goto out;
  979. }
  980. rval = omap24xxcam_sensor_if_enable(cam);
  981. if (rval) {
  982. dev_dbg(cam->dev, "vidioc_int_g_ifparm failed\n");
  983. goto out;
  984. }
  985. rval = videobuf_streamon(&ofh->vbq);
  986. if (!rval) {
  987. cam->streaming = file;
  988. sysfs_notify(&cam->dev->kobj, NULL, "streaming");
  989. }
  990. out:
  991. mutex_unlock(&cam->mutex);
  992. return rval;
  993. }
  994. static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
  995. {
  996. struct omap24xxcam_fh *ofh = fh;
  997. struct omap24xxcam_device *cam = ofh->cam;
  998. struct videobuf_queue *q = &ofh->vbq;
  999. int rval;
  1000. atomic_inc(&cam->reset_disable);
  1001. flush_scheduled_work();
  1002. rval = videobuf_streamoff(q);
  1003. if (!rval) {
  1004. mutex_lock(&cam->mutex);
  1005. cam->streaming = NULL;
  1006. mutex_unlock(&cam->mutex);
  1007. sysfs_notify(&cam->dev->kobj, NULL, "streaming");
  1008. }
  1009. atomic_dec(&cam->reset_disable);
  1010. return rval;
  1011. }
  1012. static int vidioc_enum_input(struct file *file, void *fh,
  1013. struct v4l2_input *inp)
  1014. {
  1015. if (inp->index > 0)
  1016. return -EINVAL;
  1017. strlcpy(inp->name, "camera", sizeof(inp->name));
  1018. inp->type = V4L2_INPUT_TYPE_CAMERA;
  1019. return 0;
  1020. }
  1021. static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
  1022. {
  1023. *i = 0;
  1024. return 0;
  1025. }
  1026. static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
  1027. {
  1028. if (i > 0)
  1029. return -EINVAL;
  1030. return 0;
  1031. }
  1032. static int vidioc_queryctrl(struct file *file, void *fh,
  1033. struct v4l2_queryctrl *a)
  1034. {
  1035. struct omap24xxcam_fh *ofh = fh;
  1036. struct omap24xxcam_device *cam = ofh->cam;
  1037. int rval;
  1038. rval = vidioc_int_queryctrl(cam->sdev, a);
  1039. return rval;
  1040. }
  1041. static int vidioc_g_ctrl(struct file *file, void *fh,
  1042. struct v4l2_control *a)
  1043. {
  1044. struct omap24xxcam_fh *ofh = fh;
  1045. struct omap24xxcam_device *cam = ofh->cam;
  1046. int rval;
  1047. mutex_lock(&cam->mutex);
  1048. rval = vidioc_int_g_ctrl(cam->sdev, a);
  1049. mutex_unlock(&cam->mutex);
  1050. return rval;
  1051. }
  1052. static int vidioc_s_ctrl(struct file *file, void *fh,
  1053. struct v4l2_control *a)
  1054. {
  1055. struct omap24xxcam_fh *ofh = fh;
  1056. struct omap24xxcam_device *cam = ofh->cam;
  1057. int rval;
  1058. mutex_lock(&cam->mutex);
  1059. rval = vidioc_int_s_ctrl(cam->sdev, a);
  1060. mutex_unlock(&cam->mutex);
  1061. return rval;
  1062. }
  1063. static int vidioc_g_parm(struct file *file, void *fh,
  1064. struct v4l2_streamparm *a) {
  1065. struct omap24xxcam_fh *ofh = fh;
  1066. struct omap24xxcam_device *cam = ofh->cam;
  1067. int rval;
  1068. mutex_lock(&cam->mutex);
  1069. rval = vidioc_int_g_parm(cam->sdev, a);
  1070. mutex_unlock(&cam->mutex);
  1071. return rval;
  1072. }
  1073. static int vidioc_s_parm(struct file *file, void *fh,
  1074. struct v4l2_streamparm *a)
  1075. {
  1076. struct omap24xxcam_fh *ofh = fh;
  1077. struct omap24xxcam_device *cam = ofh->cam;
  1078. struct v4l2_streamparm old_streamparm;
  1079. int rval;
  1080. mutex_lock(&cam->mutex);
  1081. if (cam->streaming) {
  1082. rval = -EBUSY;
  1083. goto out;
  1084. }
  1085. old_streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  1086. rval = vidioc_int_g_parm(cam->sdev, &old_streamparm);
  1087. if (rval)
  1088. goto out;
  1089. rval = vidioc_int_s_parm(cam->sdev, a);
  1090. if (rval)
  1091. goto out;
  1092. rval = omap24xxcam_sensor_if_enable(cam);
  1093. /*
  1094. * Revert to old streaming parameters if enabling sensor
  1095. * interface with the new ones failed.
  1096. */
  1097. if (rval)
  1098. vidioc_int_s_parm(cam->sdev, &old_streamparm);
  1099. out:
  1100. mutex_unlock(&cam->mutex);
  1101. return rval;
  1102. }
  1103. /*
  1104. *
  1105. * File operations.
  1106. *
  1107. */
  1108. static unsigned int omap24xxcam_poll(struct file *file,
  1109. struct poll_table_struct *wait)
  1110. {
  1111. struct omap24xxcam_fh *fh = file->private_data;
  1112. struct omap24xxcam_device *cam = fh->cam;
  1113. struct videobuf_buffer *vb;
  1114. mutex_lock(&cam->mutex);
  1115. if (cam->streaming != file) {
  1116. mutex_unlock(&cam->mutex);
  1117. return POLLERR;
  1118. }
  1119. mutex_unlock(&cam->mutex);
  1120. mutex_lock(&fh->vbq.vb_lock);
  1121. if (list_empty(&fh->vbq.stream)) {
  1122. mutex_unlock(&fh->vbq.vb_lock);
  1123. return POLLERR;
  1124. }
  1125. vb = list_entry(fh->vbq.stream.next, struct videobuf_buffer, stream);
  1126. mutex_unlock(&fh->vbq.vb_lock);
  1127. poll_wait(file, &vb->done, wait);
  1128. if (vb->state == VIDEOBUF_DONE || vb->state == VIDEOBUF_ERROR)
  1129. return POLLIN | POLLRDNORM;
  1130. return 0;
  1131. }
  1132. static int omap24xxcam_mmap_buffers(struct file *file,
  1133. struct vm_area_struct *vma)
  1134. {
  1135. struct omap24xxcam_fh *fh = file->private_data;
  1136. struct omap24xxcam_device *cam = fh->cam;
  1137. struct videobuf_queue *vbq = &fh->vbq;
  1138. unsigned int first, last, size, i, j;
  1139. int err = 0;
  1140. mutex_lock(&cam->mutex);
  1141. if (cam->streaming) {
  1142. mutex_unlock(&cam->mutex);
  1143. return -EBUSY;
  1144. }
  1145. mutex_unlock(&cam->mutex);
  1146. mutex_lock(&vbq->vb_lock);
  1147. /* look for first buffer to map */
  1148. for (first = 0; first < VIDEO_MAX_FRAME; first++) {
  1149. if (NULL == vbq->bufs[first])
  1150. continue;
  1151. if (V4L2_MEMORY_MMAP != vbq->bufs[first]->memory)
  1152. continue;
  1153. if (vbq->bufs[first]->boff == (vma->vm_pgoff << PAGE_SHIFT))
  1154. break;
  1155. }
  1156. /* look for last buffer to map */
  1157. for (size = 0, last = first; last < VIDEO_MAX_FRAME; last++) {
  1158. if (NULL == vbq->bufs[last])
  1159. continue;
  1160. if (V4L2_MEMORY_MMAP != vbq->bufs[last]->memory)
  1161. continue;
  1162. size += vbq->bufs[last]->bsize;
  1163. if (size == (vma->vm_end - vma->vm_start))
  1164. break;
  1165. }
  1166. size = 0;
  1167. for (i = first; i <= last && i < VIDEO_MAX_FRAME; i++) {
  1168. struct videobuf_dmabuf *dma = videobuf_to_dma(vbq->bufs[i]);
  1169. for (j = 0; j < dma->sglen; j++) {
  1170. err = remap_pfn_range(
  1171. vma, vma->vm_start + size,
  1172. page_to_pfn(sg_page(&dma->sglist[j])),
  1173. sg_dma_len(&dma->sglist[j]), vma->vm_page_prot);
  1174. if (err)
  1175. goto out;
  1176. size += sg_dma_len(&dma->sglist[j]);
  1177. }
  1178. }
  1179. out:
  1180. mutex_unlock(&vbq->vb_lock);
  1181. return err;
  1182. }
  1183. static int omap24xxcam_mmap(struct file *file, struct vm_area_struct *vma)
  1184. {
  1185. struct omap24xxcam_fh *fh = file->private_data;
  1186. int rval;
  1187. /* let the video-buf mapper check arguments and set-up structures */
  1188. rval = videobuf_mmap_mapper(&fh->vbq, vma);
  1189. if (rval)
  1190. return rval;
  1191. vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
  1192. /* do mapping to our allocated buffers */
  1193. rval = omap24xxcam_mmap_buffers(file, vma);
  1194. /*
  1195. * In case of error, free vma->vm_private_data allocated by
  1196. * videobuf_mmap_mapper.
  1197. */
  1198. if (rval)
  1199. kfree(vma->vm_private_data);
  1200. return rval;
  1201. }
  1202. static int omap24xxcam_open(struct file *file)
  1203. {
  1204. struct omap24xxcam_device *cam = omap24xxcam.priv;
  1205. struct omap24xxcam_fh *fh;
  1206. struct v4l2_format format;
  1207. if (!cam || !cam->vfd)
  1208. return -ENODEV;
  1209. fh = kzalloc(sizeof(*fh), GFP_KERNEL);
  1210. if (fh == NULL)
  1211. return -ENOMEM;
  1212. mutex_lock(&cam->mutex);
  1213. if (cam->sdev == NULL || !try_module_get(cam->sdev->module)) {
  1214. mutex_unlock(&cam->mutex);
  1215. goto out_try_module_get;
  1216. }
  1217. if (atomic_inc_return(&cam->users) == 1) {
  1218. omap24xxcam_hwinit(cam);
  1219. if (omap24xxcam_sensor_enable(cam)) {
  1220. mutex_unlock(&cam->mutex);
  1221. goto out_omap24xxcam_sensor_enable;
  1222. }
  1223. }
  1224. mutex_unlock(&cam->mutex);
  1225. fh->cam = cam;
  1226. mutex_lock(&cam->mutex);
  1227. vidioc_int_g_fmt_cap(cam->sdev, &format);
  1228. mutex_unlock(&cam->mutex);
  1229. /* FIXME: how about fh->pix when there are more users? */
  1230. fh->pix = format.fmt.pix;
  1231. file->private_data = fh;
  1232. spin_lock_init(&fh->vbq_lock);
  1233. videobuf_queue_sg_init(&fh->vbq, &omap24xxcam_vbq_ops, NULL,
  1234. &fh->vbq_lock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
  1235. V4L2_FIELD_NONE,
  1236. sizeof(struct videobuf_buffer), fh);
  1237. return 0;
  1238. out_omap24xxcam_sensor_enable:
  1239. omap24xxcam_poweron_reset(cam);
  1240. module_put(cam->sdev->module);
  1241. out_try_module_get:
  1242. kfree(fh);
  1243. return -ENODEV;
  1244. }
  1245. static int omap24xxcam_release(struct file *file)
  1246. {
  1247. struct omap24xxcam_fh *fh = file->private_data;
  1248. struct omap24xxcam_device *cam = fh->cam;
  1249. atomic_inc(&cam->reset_disable);
  1250. flush_scheduled_work();
  1251. /* stop streaming capture */
  1252. videobuf_streamoff(&fh->vbq);
  1253. mutex_lock(&cam->mutex);
  1254. if (cam->streaming == file) {
  1255. cam->streaming = NULL;
  1256. mutex_unlock(&cam->mutex);
  1257. sysfs_notify(&cam->dev->kobj, NULL, "streaming");
  1258. } else {
  1259. mutex_unlock(&cam->mutex);
  1260. }
  1261. atomic_dec(&cam->reset_disable);
  1262. omap24xxcam_vbq_free_mmap_buffers(&fh->vbq);
  1263. /*
  1264. * Make sure the reset work we might have scheduled is not
  1265. * pending! It may be run *only* if we have users. (And it may
  1266. * not be scheduled anymore since streaming is already
  1267. * disabled.)
  1268. */
  1269. flush_scheduled_work();
  1270. mutex_lock(&cam->mutex);
  1271. if (atomic_dec_return(&cam->users) == 0) {
  1272. omap24xxcam_sensor_disable(cam);
  1273. omap24xxcam_poweron_reset(cam);
  1274. }
  1275. mutex_unlock(&cam->mutex);
  1276. file->private_data = NULL;
  1277. module_put(cam->sdev->module);
  1278. kfree(fh);
  1279. return 0;
  1280. }
  1281. static struct v4l2_file_operations omap24xxcam_fops = {
  1282. .ioctl = video_ioctl2,
  1283. .poll = omap24xxcam_poll,
  1284. .mmap = omap24xxcam_mmap,
  1285. .open = omap24xxcam_open,
  1286. .release = omap24xxcam_release,
  1287. };
  1288. /*
  1289. *
  1290. * Power management.
  1291. *
  1292. */
  1293. #ifdef CONFIG_PM
  1294. static int omap24xxcam_suspend(struct platform_device *pdev, pm_message_t state)
  1295. {
  1296. struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
  1297. if (atomic_read(&cam->users) == 0)
  1298. return 0;
  1299. if (!atomic_read(&cam->reset_disable))
  1300. omap24xxcam_capture_stop(cam);
  1301. omap24xxcam_sensor_disable(cam);
  1302. omap24xxcam_poweron_reset(cam);
  1303. return 0;
  1304. }
  1305. static int omap24xxcam_resume(struct platform_device *pdev)
  1306. {
  1307. struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
  1308. if (atomic_read(&cam->users) == 0)
  1309. return 0;
  1310. omap24xxcam_hwinit(cam);
  1311. omap24xxcam_sensor_enable(cam);
  1312. if (!atomic_read(&cam->reset_disable))
  1313. omap24xxcam_capture_cont(cam);
  1314. return 0;
  1315. }
  1316. #endif /* CONFIG_PM */
  1317. static const struct v4l2_ioctl_ops omap24xxcam_ioctl_fops = {
  1318. .vidioc_querycap = vidioc_querycap,
  1319. .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
  1320. .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
  1321. .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
  1322. .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
  1323. .vidioc_reqbufs = vidioc_reqbufs,
  1324. .vidioc_querybuf = vidioc_querybuf,
  1325. .vidioc_qbuf = vidioc_qbuf,
  1326. .vidioc_dqbuf = vidioc_dqbuf,
  1327. .vidioc_streamon = vidioc_streamon,
  1328. .vidioc_streamoff = vidioc_streamoff,
  1329. .vidioc_enum_input = vidioc_enum_input,
  1330. .vidioc_g_input = vidioc_g_input,
  1331. .vidioc_s_input = vidioc_s_input,
  1332. .vidioc_queryctrl = vidioc_queryctrl,
  1333. .vidioc_g_ctrl = vidioc_g_ctrl,
  1334. .vidioc_s_ctrl = vidioc_s_ctrl,
  1335. .vidioc_g_parm = vidioc_g_parm,
  1336. .vidioc_s_parm = vidioc_s_parm,
  1337. };
  1338. /*
  1339. *
  1340. * Camera device (i.e. /dev/video).
  1341. *
  1342. */
  1343. static int omap24xxcam_device_register(struct v4l2_int_device *s)
  1344. {
  1345. struct omap24xxcam_device *cam = s->u.slave->master->priv;
  1346. struct video_device *vfd;
  1347. int rval;
  1348. /* We already have a slave. */
  1349. if (cam->sdev)
  1350. return -EBUSY;
  1351. cam->sdev = s;
  1352. if (device_create_file(cam->dev, &dev_attr_streaming) != 0) {
  1353. dev_err(cam->dev, "could not register sysfs entry\n");
  1354. rval = -EBUSY;
  1355. goto err;
  1356. }
  1357. /* initialize the video_device struct */
  1358. vfd = cam->vfd = video_device_alloc();
  1359. if (!vfd) {
  1360. dev_err(cam->dev, "could not allocate video device struct\n");
  1361. rval = -ENOMEM;
  1362. goto err;
  1363. }
  1364. vfd->release = video_device_release;
  1365. vfd->parent = cam->dev;
  1366. strlcpy(vfd->name, CAM_NAME, sizeof(vfd->name));
  1367. vfd->fops = &omap24xxcam_fops;
  1368. vfd->ioctl_ops = &omap24xxcam_ioctl_fops;
  1369. omap24xxcam_hwinit(cam);
  1370. rval = omap24xxcam_sensor_init(cam);
  1371. if (rval)
  1372. goto err;
  1373. if (video_register_device(vfd, VFL_TYPE_GRABBER, video_nr) < 0) {
  1374. dev_err(cam->dev, "could not register V4L device\n");
  1375. rval = -EBUSY;
  1376. goto err;
  1377. }
  1378. omap24xxcam_poweron_reset(cam);
  1379. dev_info(cam->dev, "registered device %s\n",
  1380. video_device_node_name(vfd));
  1381. return 0;
  1382. err:
  1383. omap24xxcam_device_unregister(s);
  1384. return rval;
  1385. }
  1386. static void omap24xxcam_device_unregister(struct v4l2_int_device *s)
  1387. {
  1388. struct omap24xxcam_device *cam = s->u.slave->master->priv;
  1389. omap24xxcam_sensor_exit(cam);
  1390. if (cam->vfd) {
  1391. if (!video_is_registered(cam->vfd)) {
  1392. /*
  1393. * The device was never registered, so release the
  1394. * video_device struct directly.
  1395. */
  1396. video_device_release(cam->vfd);
  1397. } else {
  1398. /*
  1399. * The unregister function will release the
  1400. * video_device struct as well as
  1401. * unregistering it.
  1402. */
  1403. video_unregister_device(cam->vfd);
  1404. }
  1405. cam->vfd = NULL;
  1406. }
  1407. device_remove_file(cam->dev, &dev_attr_streaming);
  1408. cam->sdev = NULL;
  1409. }
  1410. static struct v4l2_int_master omap24xxcam_master = {
  1411. .attach = omap24xxcam_device_register,
  1412. .detach = omap24xxcam_device_unregister,
  1413. };
  1414. static struct v4l2_int_device omap24xxcam = {
  1415. .module = THIS_MODULE,
  1416. .name = CAM_NAME,
  1417. .type = v4l2_int_type_master,
  1418. .u = {
  1419. .master = &omap24xxcam_master
  1420. },
  1421. };
  1422. /*
  1423. *
  1424. * Driver initialisation and deinitialisation.
  1425. *
  1426. */
  1427. static int __devinit omap24xxcam_probe(struct platform_device *pdev)
  1428. {
  1429. struct omap24xxcam_device *cam;
  1430. struct resource *mem;
  1431. int irq;
  1432. cam = kzalloc(sizeof(*cam), GFP_KERNEL);
  1433. if (!cam) {
  1434. dev_err(&pdev->dev, "could not allocate memory\n");
  1435. goto err;
  1436. }
  1437. platform_set_drvdata(pdev, cam);
  1438. cam->dev = &pdev->dev;
  1439. /*
  1440. * Impose a lower limit on the amount of memory allocated for
  1441. * capture. We require at least enough memory to double-buffer
  1442. * QVGA (300KB).
  1443. */
  1444. if (capture_mem < 320 * 240 * 2 * 2)
  1445. capture_mem = 320 * 240 * 2 * 2;
  1446. cam->capture_mem = capture_mem;
  1447. /* request the mem region for the camera registers */
  1448. mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  1449. if (!mem) {
  1450. dev_err(cam->dev, "no mem resource?\n");
  1451. goto err;
  1452. }
  1453. if (!request_mem_region(mem->start, (mem->end - mem->start) + 1,
  1454. pdev->name)) {
  1455. dev_err(cam->dev,
  1456. "cannot reserve camera register I/O region\n");
  1457. goto err;
  1458. }
  1459. cam->mmio_base_phys = mem->start;
  1460. cam->mmio_size = (mem->end - mem->start) + 1;
  1461. /* map the region */
  1462. cam->mmio_base = (unsigned long)
  1463. ioremap_nocache(cam->mmio_base_phys, cam->mmio_size);
  1464. if (!cam->mmio_base) {
  1465. dev_err(cam->dev, "cannot map camera register I/O region\n");
  1466. goto err;
  1467. }
  1468. irq = platform_get_irq(pdev, 0);
  1469. if (irq <= 0) {
  1470. dev_err(cam->dev, "no irq for camera?\n");
  1471. goto err;
  1472. }
  1473. /* install the interrupt service routine */
  1474. if (request_irq(irq, omap24xxcam_isr, 0, CAM_NAME, cam)) {
  1475. dev_err(cam->dev,
  1476. "could not install interrupt service routine\n");
  1477. goto err;
  1478. }
  1479. cam->irq = irq;
  1480. if (omap24xxcam_clock_get(cam))
  1481. goto err;
  1482. INIT_WORK(&cam->sensor_reset_work, omap24xxcam_sensor_reset_work);
  1483. mutex_init(&cam->mutex);
  1484. spin_lock_init(&cam->core_enable_disable_lock);
  1485. omap24xxcam_sgdma_init(&cam->sgdma,
  1486. cam->mmio_base + CAMDMA_REG_OFFSET,
  1487. omap24xxcam_stalled_dma_reset,
  1488. (unsigned long)cam);
  1489. omap24xxcam.priv = cam;
  1490. if (v4l2_int_device_register(&omap24xxcam))
  1491. goto err;
  1492. return 0;
  1493. err:
  1494. omap24xxcam_remove(pdev);
  1495. return -ENODEV;
  1496. }
  1497. static int omap24xxcam_remove(struct platform_device *pdev)
  1498. {
  1499. struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
  1500. if (!cam)
  1501. return 0;
  1502. if (omap24xxcam.priv != NULL)
  1503. v4l2_int_device_unregister(&omap24xxcam);
  1504. omap24xxcam.priv = NULL;
  1505. omap24xxcam_clock_put(cam);
  1506. if (cam->irq) {
  1507. free_irq(cam->irq, cam);
  1508. cam->irq = 0;
  1509. }
  1510. if (cam->mmio_base) {
  1511. iounmap((void *)cam->mmio_base);
  1512. cam->mmio_base = 0;
  1513. }
  1514. if (cam->mmio_base_phys) {
  1515. release_mem_region(cam->mmio_base_phys, cam->mmio_size);
  1516. cam->mmio_base_phys = 0;
  1517. }
  1518. kfree(cam);
  1519. return 0;
  1520. }
  1521. static struct platform_driver omap24xxcam_driver = {
  1522. .probe = omap24xxcam_probe,
  1523. .remove = omap24xxcam_remove,
  1524. #ifdef CONFIG_PM
  1525. .suspend = omap24xxcam_suspend,
  1526. .resume = omap24xxcam_resume,
  1527. #endif
  1528. .driver = {
  1529. .name = CAM_NAME,
  1530. .owner = THIS_MODULE,
  1531. },
  1532. };
  1533. /*
  1534. *
  1535. * Module initialisation and deinitialisation
  1536. *
  1537. */
  1538. static int __init omap24xxcam_init(void)
  1539. {
  1540. return platform_driver_register(&omap24xxcam_driver);
  1541. }
  1542. static void __exit omap24xxcam_cleanup(void)
  1543. {
  1544. platform_driver_unregister(&omap24xxcam_driver);
  1545. }
  1546. MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
  1547. MODULE_DESCRIPTION("OMAP24xx Video for Linux camera driver");
  1548. MODULE_LICENSE("GPL");
  1549. module_param(video_nr, int, 0);
  1550. MODULE_PARM_DESC(video_nr,
  1551. "Minor number for video device (-1 ==> auto assign)");
  1552. module_param(capture_mem, int, 0);
  1553. MODULE_PARM_DESC(capture_mem, "Maximum amount of memory for capture "
  1554. "buffers (default 4800kiB)");
  1555. module_init(omap24xxcam_init);
  1556. module_exit(omap24xxcam_cleanup);