/* open the camera */
static int zr364xx_open(struct inode *inode, struct file *file)
{
struct video_device *vdev = video_devdata(file);
struct zr364xx_camera *cam = video_get_drvdata(vdev);
struct usb_device *udev = cam->udev;
int i, err;
DBG("zr364xx_open");
cam->skip = 2;
err = video_exclusive_open(inode, file);
if (err < 0)
return err;
if (!cam->framebuf) {
cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
if (!cam->framebuf) {
info("vmalloc_32 failed!");
return -ENOMEM;
}
}
mutex_lock(&cam->lock);
for (i = 0; init[cam->method][i].size != -1; i++) {
err =
send_control_msg(udev, 1, init[cam->method][i].value,
0, init[cam->method][i].bytes,
init[cam->method][i].size);
if (err < 0) {
info("error during open sequence: %d", i);
mutex_unlock(&cam->lock);
return err;
}
}
file->private_data = vdev;
/* Added some delay here, since opening/closing the camera quickly,
* like Ekiga does during its startup, can crash the webcam
*/
mdelay(100);
mutex_unlock(&cam->lock);
return 0;
}
int videobuf_dma_init_kernel(struct videobuf_dmabuf *dma, int direction,
int nr_pages)
{
dprintk(1,"init kernel [%d pages]\n",nr_pages);
dma->direction = direction;
dma->vmalloc = vmalloc_32(nr_pages << PAGE_SHIFT);
if (NULL == dma->vmalloc) {
dprintk(1,"vmalloc_32(%d pages) failed\n",nr_pages);
return -ENOMEM;
}
dprintk(1,"vmalloc is at addr 0x%08lx, size=%d\n",
(unsigned long)dma->vmalloc,
nr_pages << PAGE_SHIFT);
memset(dma->vmalloc,0,nr_pages << PAGE_SHIFT);
dma->nr_pages = nr_pages;
return 0;
}
/**
* 分配显存
* @param size 显存大小
* @return 指针
*/
static void *rvmalloc(unsigned long size)
{
void *mem;
unsigned long adr;
size = PAGE_ALIGN(size);
mem = vmalloc_32(size);
if (!mem)
return NULL;
memset(mem, 0, size); /* Clear the ram out, no junk to the user */
adr = (unsigned long) mem;
while (size > 0) {
SetPageReserved(vmalloc_to_page((void *)adr));
adr += PAGE_SIZE;
size -= PAGE_SIZE;
}
return mem;
}
static void * rvmalloc(signed long size)
{
void * mem;
unsigned long adr, page;
mem=vmalloc_32(size);
if (mem)
{
memset(mem, 0, size); /* Clear the ram out, no junk to the user */
adr=(unsigned long) mem;
while (size > 0)
{
page = kvirt_to_pa(adr);
SetPageReserved(virt_to_page(__va(page)));
adr+=PAGE_SIZE;
size-=PAGE_SIZE;
}
}
return mem;
}
static int cx23885_alsa_dma_init(struct cx23885_audio_dev *chip, int nr_pages)
{
struct cx23885_audio_buffer *buf = chip->buf;
struct page *pg;
int i;
buf->vaddr = vmalloc_32(nr_pages << PAGE_SHIFT);
if (NULL == buf->vaddr) {
dprintk(1, "vmalloc_32(%d pages) failed\n", nr_pages);
return -ENOMEM;
}
dprintk(1, "vmalloc is at addr 0x%08lx, size=%d\n",
(unsigned long)buf->vaddr,
nr_pages << PAGE_SHIFT);
memset(buf->vaddr, 0, nr_pages << PAGE_SHIFT);
buf->nr_pages = nr_pages;
buf->sglist = vzalloc(buf->nr_pages * sizeof(*buf->sglist));
if (NULL == buf->sglist)
goto vzalloc_err;
sg_init_table(buf->sglist, buf->nr_pages);
for (i = 0; i < buf->nr_pages; i++) {
pg = vmalloc_to_page(buf->vaddr + i * PAGE_SIZE);
if (NULL == pg)
goto vmalloc_to_page_err;
sg_set_page(&buf->sglist[i], pg, PAGE_SIZE, 0);
}
return 0;
vmalloc_to_page_err:
vfree(buf->sglist);
buf->sglist = NULL;
vzalloc_err:
vfree(buf->vaddr);
buf->vaddr = NULL;
return -ENOMEM;
}
int init_module2_2(void)
{
static int *vbuf;
printk(KERN_INFO "LSDxxx: enter init_module2 \n");
LEN=BIGPHYS_PAGES_2*PAGE_SIZE;
printk(KERN_INFO "LSD: LEN %ld \n",LEN);
vbuf=(int *)vmalloc_32(LEN);
rvnail((char *)vbuf,LEN);
buf_start_2=(char *)vbuf;
if (!buf_start_2){
printk(KERN_INFO " eth_hook_2 asked for too much memory!\n");
printk(KERN_INFO " decrease BIGPHYS_PAGES_2 !\n");
}
printk(KERN_INFO "LSD: buf_start_2 is allocated \n");
buf_end_2=buf_start_2+(BIGPHYS_PAGES_2-RING_PAGES_2)*PAGE_SIZE-MAXPACKET_2;
buf_eend_2=buf_start_2+(BIGPHYS_PAGES_2-RING_PAGES_2)*PAGE_SIZE-TAILPOS-MAXEVENT_2;
ring_start_2=buf_start_2+(BIGPHYS_PAGES_2-RING_PAGES_2)*PAGE_SIZE;
ring_size_2=(RING_PAGES_2*PAGE_SIZE-RING_ENTRY_LENGTH-TAILMEM)/RING_ENTRY_LENGTH;
tail_start_2=buf_start_2+BIGPHYS_PAGES_2*PAGE_SIZE-TAILPOS;
schar_reset_2();
return 0;
}
void *saa7146_vmalloc_build_pgtable(struct pci_dev *pci, long length, struct saa7146_pgtable *pt)
{
int pages = (length+PAGE_SIZE-1)/PAGE_SIZE;
void *mem = vmalloc_32(length);
int slen = 0;
if (NULL == mem)
goto err_null;
if (!(pt->slist = vmalloc_to_sg(mem, pages)))
goto err_free_mem;
if (saa7146_pgtable_alloc(pci, pt))
goto err_free_slist;
pt->nents = pages;
slen = pci_map_sg(pci,pt->slist,pt->nents,PCI_DMA_FROMDEVICE);
if (0 == slen)
goto err_free_pgtable;
if (0 != saa7146_pgtable_build_single(pci, pt, pt->slist, slen))
goto err_unmap_sg;
return mem;
err_unmap_sg:
pci_unmap_sg(pci, pt->slist, pt->nents, PCI_DMA_FROMDEVICE);
err_free_pgtable:
saa7146_pgtable_free(pci, pt);
err_free_slist:
kfree(pt->slist);
pt->slist = NULL;
err_free_mem:
vfree(mem);
err_null:
return NULL;
}
/**
* @brief Allocate the video buffers.
*
* @param queue
* @param nbuffers
* @param buflength
*
* Pages are reserved to make sure they will not be swaped, as they will be
* filled in URB completion handler.
*
* Buffers will be individually mapped, so they must all be page aligned.
*/
int microdia_alloc_buffers(struct microdia_video_queue *queue,
unsigned int nbuffers, unsigned int buflength)
{
unsigned int bufsize = PAGE_ALIGN(buflength);
unsigned int i;
void *mem = NULL;
void *buffer = NULL;
int ret;
mutex_lock(&queue->mutex);
ret = microdia_free_buffers(queue);
if (ret < 0)
goto done;
/* Bail out if no buffers should be allocated. */
if (nbuffers == 0)
goto done;
if (nbuffers < queue->min_buffers)
nbuffers = queue->min_buffers;
else if (nbuffers > queue->max_buffers)
nbuffers = queue->max_buffers;
queue->scratch = vmalloc_32(bufsize);
if (queue->scratch == NULL) {
ret = -ENOMEM;
goto done;
}
/* Decrement the number of buffers until allocation succeeds. */
for (; nbuffers >= queue->min_buffers; --nbuffers) {
mem = vmalloc_32(nbuffers * bufsize);
buffer = kzalloc(nbuffers * sizeof(struct microdia_buffer),
GFP_KERNEL);
if (mem != NULL && buffer != NULL)
break;
if (mem != NULL)
vfree(mem);
if (buffer != NULL)
kfree(buffer);
}
if (mem == NULL || buffer == NULL) {
ret = -ENOMEM;
vfree(queue->scratch);
goto done;
}
queue->buffer = buffer;
for (i = 0; i < nbuffers; ++i) {
memset(&queue->buffer[i], 0, sizeof queue->buffer[i]);
queue->buffer[i].buf.index = i;
queue->buffer[i].buf.m.offset = i * bufsize;
queue->buffer[i].buf.length = buflength;
queue->buffer[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
queue->buffer[i].buf.sequence = 0;
queue->buffer[i].buf.field = V4L2_FIELD_NONE;
queue->buffer[i].buf.memory = V4L2_MEMORY_MMAP;
queue->buffer[i].buf.flags = 0;
init_waitqueue_head(&queue->buffer[i].wait);
}
queue->mem = mem;
queue->count = nbuffers;
queue->buf_size = bufsize;
ret = nbuffers;
done:
mutex_unlock(&queue->mutex);
return ret;
}
