/* * $Id: video-buf.h,v 1.9 2004/11/07 13:17:15 kraxel Exp $ * * generic helper functions for video4linux capture buffers, to handle * memory management and PCI DMA. Right now bttv + saa7134 use it. * * The functions expect the hardware being able to scatter gatter * (i.e. the buffers are not linear in physical memory, but fragmented * into PAGE_SIZE chunks). They also assume the driver does not need * to touch the video data (thus it is probably not useful for USB as * data often must be uncompressed by the drivers). * * (c) 2001,02 Gerd Knorr * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. */ #include #define UNSET (-1U) /* --------------------------------------------------------------------- */ /* * Return a scatterlist for some page-aligned vmalloc()'ed memory * block (NULL on errors). Memory for the scatterlist is allocated * using kmalloc. The caller must free the memory. */ struct scatterlist* videobuf_vmalloc_to_sg(unsigned char *virt, int nr_pages); /* * Return a scatterlist for a an array of userpages (NULL on errors). * Memory for the scatterlist is allocated using kmalloc. The caller * must free the memory. */ struct scatterlist* videobuf_pages_to_sg(struct page **pages, int nr_pages, int offset); /* --------------------------------------------------------------------- */ /* * A small set of helper functions to manage buffers (both userland * and kernel) for DMA. * * videobuf_dma_init_*() * creates a buffer. The userland version takes a userspace * pointer + length. The kernel version just wants the size and * does memory allocation too using vmalloc_32(). * * videobuf_dma_pci_*() * see Documentation/DMA-mapping.txt, these functions to * basically the same. The map function does also build a * scatterlist for the buffer (and unmap frees it ...) * * videobuf_dma_free() * no comment ... * */ struct videobuf_dmabuf { u32 magic; /* for userland buffer */ int offset; struct page **pages; /* for kernel buffers */ void *vmalloc; /* for overlay buffers (pci-pci dma) */ dma_addr_t bus_addr; /* common */ struct scatterlist *sglist; int sglen; int nr_pages; int direction; }; void videobuf_dma_init(struct videobuf_dmabuf *dma); int videobuf_dma_init_user(struct videobuf_dmabuf *dma, int direction, unsigned long data, unsigned long size); int videobuf_dma_init_kernel(struct videobuf_dmabuf *dma, int direction, int nr_pages); int videobuf_dma_init_overlay(struct videobuf_dmabuf *dma, int direction, dma_addr_t addr, int nr_pages); int videobuf_dma_pci_map(struct pci_dev *dev, struct videobuf_dmabuf *dma); int videobuf_dma_pci_sync(struct pci_dev *dev, struct videobuf_dmabuf *dma); int videobuf_dma_pci_unmap(struct pci_dev *dev, struct videobuf_dmabuf *dma); int videobuf_dma_free(struct videobuf_dmabuf *dma); /* --------------------------------------------------------------------- */ /* * A small set of helper functions to manage video4linux buffers. * * struct videobuf_buffer holds the data structures used by the helper * functions, additionally some commonly used fields for v4l buffers * (width, height, lists, waitqueue) are in there. That struct should * be used as first element in the drivers buffer struct. * * about the mmap helpers (videobuf_mmap_*): * * The mmaper function allows to map any subset of contingous buffers. * This includes one mmap() call for all buffers (which the original * video4linux API uses) as well as one mmap() for every single buffer * (which v4l2 uses). * * If there is a valid mapping for a buffer, buffer->baddr/bsize holds * userspace address + size which can be feeded into the * videobuf_dma_init_user function listed above. * */ struct videobuf_buffer; struct videobuf_queue; struct videobuf_mapping { unsigned int count; unsigned long start; unsigned long end; struct videobuf_queue *q; }; enum videobuf_state { STATE_NEEDS_INIT = 0, STATE_PREPARED = 1, STATE_QUEUED = 2, STATE_ACTIVE = 3, STATE_DONE = 4, STATE_ERROR = 5, STATE_IDLE = 6, }; struct videobuf_buffer { unsigned int i; u32 magic; /* info about the buffer */ unsigned int width; unsigned int height; unsigned int bytesperline; /* use only if != 0 */ unsigned long size; unsigned int input; enum v4l2_field field; enum videobuf_state state; struct videobuf_dmabuf dma; struct list_head stream; /* QBUF/DQBUF list */ /* for mmap'ed buffers */ enum v4l2_memory memory; size_t boff; /* buffer offset (mmap + overlay) */ size_t bsize; /* buffer size */ unsigned long baddr; /* buffer addr (userland ptr!) */ struct videobuf_mapping *map; /* touched by irq handler */ struct list_head queue; wait_queue_head_t done; unsigned int field_count; struct timeval ts; }; struct videobuf_queue_ops { int (*buf_setup)(struct videobuf_queue *q, unsigned int *count, unsigned int *size); int (*buf_prepare)(struct videobuf_queue *q, struct videobuf_buffer *vb, enum v4l2_field field); void (*buf_queue)(struct videobuf_queue *q, struct videobuf_buffer *vb); void (*buf_release)(struct videobuf_queue *q, struct videobuf_buffer *vb); }; struct videobuf_queue { struct semaphore lock; spinlock_t *irqlock; struct pci_dev *pci; enum v4l2_buf_type type; unsigned int inputs; /* for V4L2_BUF_FLAG_INPUT */ unsigned int msize; enum v4l2_field field; enum v4l2_field last; /* for field=V4L2_FIELD_ALTERNATE */ struct videobuf_buffer *bufs[VIDEO_MAX_FRAME]; struct videobuf_queue_ops *ops; /* capture via mmap() + ioctl(QBUF/DQBUF) */ unsigned int streaming; struct list_head stream; /* capture via read() */ unsigned int reading; unsigned int read_off; struct videobuf_buffer *read_buf; /* driver private data */ void *priv_data; }; void* videobuf_alloc(unsigned int size); int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr); int videobuf_iolock(struct pci_dev *pci, struct videobuf_buffer *vb, struct v4l2_framebuffer *fbuf); void videobuf_queue_init(struct videobuf_queue *q, struct videobuf_queue_ops *ops, struct pci_dev *pci, spinlock_t *irqlock, enum v4l2_buf_type type, enum v4l2_field field, unsigned int msize, void *priv); int videobuf_queue_is_busy(struct videobuf_queue *q); void videobuf_queue_cancel(struct videobuf_queue *q); enum v4l2_field videobuf_next_field(struct videobuf_queue *q); void videobuf_status(struct v4l2_buffer *b, struct videobuf_buffer *vb, enum v4l2_buf_type type); int videobuf_reqbufs(struct videobuf_queue *q, struct v4l2_requestbuffers *req); int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b); int videobuf_qbuf(struct videobuf_queue *q, struct v4l2_buffer *b); int videobuf_dqbuf(struct videobuf_queue *q, struct v4l2_buffer *b, int nonblocking); int videobuf_streamon(struct videobuf_queue *q); int videobuf_streamoff(struct videobuf_queue *q); int videobuf_read_start(struct videobuf_queue *q); void videobuf_read_stop(struct videobuf_queue *q); ssize_t videobuf_read_stream(struct videobuf_queue *q, char __user *data, size_t count, loff_t *ppos, int vbihack, int nonblocking); ssize_t videobuf_read_one(struct videobuf_queue *q, char __user *data, size_t count, loff_t *ppos, int nonblocking); unsigned int videobuf_poll_stream(struct file *file, struct videobuf_queue *q, poll_table *wait); int videobuf_mmap_setup(struct videobuf_queue *q, unsigned int bcount, unsigned int bsize, enum v4l2_memory memory); int videobuf_mmap_free(struct videobuf_queue *q); int videobuf_mmap_mapper(struct videobuf_queue *q, struct vm_area_struct *vma); /* --------------------------------------------------------------------- */ /* * Local variables: * c-basic-offset: 8 * End: */