Skip to content

L
linux
Commit 2d39d7cf authored by Stelian Pop's avatar Stelian Pop Committed by Linus Torvalds
Browse files
Options

[PATCH] meye: whitespace and coding style cleanups 

Signed-off-by: default avatarStelian Pop <stelian@popies.net>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 773f7f2f
Hide whitespace changes
Inline Side-by-side
Showing with 332 additions and 338 deletions
Documentation/video4linux/meye.txt
View file @ 2d39d7cf
Vaio Picturebook Motion Eye Camera Driver Readme Vaio Picturebook Motion Eye Camera Driver Readme
------------------------------------------------ ------------------------------------------------
Copyright (C) 2001-2003 Stelian Pop <stelian@popies.net> Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
Copyright (C) 2001-2002 Alcôve <www.alcove.com> Copyright (C) 2001-2002 Alcôve <www.alcove.com>
Copyright (C) 2000 Andrew Tridgell <tridge@samba.org> Copyright (C) 2000 Andrew Tridgell <tridge@samba.org>
This driver enable the use of video4linux compatible applications with the This driver enable the use of video4linux compatible applications with the
Motion Eye camera. This driver requires the "Sony Vaio Programmable I/O Motion Eye camera. This driver requires the "Sony Vaio Programmable I/O
Control Device" driver (which can be found in the "Character drivers" Control Device" driver (which can be found in the "Character drivers"
section of the kernel configuration utility) to be compiled and installed section of the kernel configuration utility) to be compiled and installed
(using its "camera=1" parameter). (using its "camera=1" parameter).
...@@ -24,7 +24,7 @@ This driver supports the 'second' version of the MotionEye camera :) ...@@ -24,7 +24,7 @@ This driver supports the 'second' version of the MotionEye camera :)
The first version was connected directly on the video bus of the Neomagic The first version was connected directly on the video bus of the Neomagic
video card and is unsupported. video card and is unsupported.
The second one, made by Kawasaki Steel is fully supported by this The second one, made by Kawasaki Steel is fully supported by this
driver (PCI vendor/device is 0x136b/0xff01) driver (PCI vendor/device is 0x136b/0xff01)
The third one, present in recent (more or less last year) Picturebooks The third one, present in recent (more or less last year) Picturebooks
...@@ -116,7 +116,7 @@ Private API: ...@@ -116,7 +116,7 @@ Private API:
MEYEIOC_STILLJCAPT MEYEIOC_STILLJCAPT
Takes a snapshot in an uncompressed or compressed jpeg format. Takes a snapshot in an uncompressed or compressed jpeg format.
This ioctl blocks until the snapshot is done and returns (for This ioctl blocks until the snapshot is done and returns (for
jpeg snapshot) the size of the image. The image data is jpeg snapshot) the size of the image. The image data is
available from the first mmap'ed buffer. available from the first mmap'ed buffer.
Look at the 'motioneye' application code for an actual example. Look at the 'motioneye' application code for an actual example.
......
drivers/media/video/meye.c
View file @ 2d39d7cf
/* /*
* Motion Eye video4linux driver for Sony Vaio PictureBook * Motion Eye video4linux driver for Sony Vaio PictureBook
* *
* Copyright (C) 2001-2003 Stelian Pop <stelian@popies.net> * Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
* *
* Copyright (C) 2001-2002 Alcve <www.alcove.com> * Copyright (C) 2001-2002 Alcve <www.alcove.com>
* *
...@@ -11,17 +11,17 @@ ...@@ -11,17 +11,17 @@
* *
* Some parts borrowed from various video4linux drivers, especially * Some parts borrowed from various video4linux drivers, especially
* bttv-driver.c and zoran.c, see original files for credits. * bttv-driver.c and zoran.c, see original files for credits.
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
...@@ -73,15 +73,16 @@ static struct meye meye; ...@@ -73,15 +73,16 @@ static struct meye meye;
/****************************************************************************/ /****************************************************************************/
/* Memory allocation routines (stolen from bttv-driver.c) */ /* Memory allocation routines (stolen from bttv-driver.c) */
/****************************************************************************/ /****************************************************************************/
static void *rvmalloc(unsigned long size) { static void *rvmalloc(unsigned long size)
{
void *mem; void *mem;
unsigned long adr; unsigned long adr;
size = PAGE_ALIGN(size); size = PAGE_ALIGN(size);
mem = vmalloc_32(size); mem = vmalloc_32(size);
if (mem) { if (mem) {
memset(mem, 0, size); /* Clear the ram out, no junk to the user */ memset(mem, 0, size);
adr = (unsigned long)mem; adr = (unsigned long) mem;
while (size > 0) { while (size > 0) {
SetPageReserved(vmalloc_to_page((void *)adr)); SetPageReserved(vmalloc_to_page((void *)adr));
adr += PAGE_SIZE; adr += PAGE_SIZE;
...@@ -91,11 +92,12 @@ static void *rvmalloc(unsigned long size) { ...@@ -91,11 +92,12 @@ static void *rvmalloc(unsigned long size) {
return mem; return mem;
} }
static void rvfree(void * mem, unsigned long size) { static void rvfree(void * mem, unsigned long size)
unsigned long adr; {
unsigned long adr;
if (mem) { if (mem) {
adr = (unsigned long) mem; adr = (unsigned long) mem;
while ((long) size > 0) { while ((long) size > 0) {
ClearPageReserved(vmalloc_to_page((void *)adr)); ClearPageReserved(vmalloc_to_page((void *)adr));
adr += PAGE_SIZE; adr += PAGE_SIZE;
...@@ -114,7 +116,8 @@ static void rvfree(void * mem, unsigned long size) { ...@@ -114,7 +116,8 @@ static void rvfree(void * mem, unsigned long size) {
* dma_addr_t for correctness but the compilation of this driver is * dma_addr_t for correctness but the compilation of this driver is
* disabled for HIGHMEM64G=y, where sizeof(dma_addr_t) != 4 * disabled for HIGHMEM64G=y, where sizeof(dma_addr_t) != 4
*/ */
static int ptable_alloc(void) { static int ptable_alloc(void)
{
dma_addr_t *pt; dma_addr_t *pt;
int i; int i;
...@@ -131,7 +134,7 @@ static int ptable_alloc(void) { ...@@ -131,7 +134,7 @@ static int ptable_alloc(void) {
pt = meye.mchip_ptable_toc; pt = meye.mchip_ptable_toc;
for (i = 0; i < MCHIP_NB_PAGES; i++) { for (i = 0; i < MCHIP_NB_PAGES; i++) {
meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev, meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
PAGE_SIZE, PAGE_SIZE,
pt, pt,
GFP_KERNEL); GFP_KERNEL);
...@@ -157,22 +160,23 @@ static int ptable_alloc(void) { ...@@ -157,22 +160,23 @@ static int ptable_alloc(void) {
return 0; return 0;
} }
static void ptable_free(void) { static void ptable_free(void)
{
dma_addr_t *pt; dma_addr_t *pt;
int i; int i;
pt = meye.mchip_ptable_toc; pt = meye.mchip_ptable_toc;
for (i = 0; i < MCHIP_NB_PAGES; i++) { for (i = 0; i < MCHIP_NB_PAGES; i++) {
if (meye.mchip_ptable[i]) if (meye.mchip_ptable[i])
dma_free_coherent(&meye.mchip_dev->dev, dma_free_coherent(&meye.mchip_dev->dev,
PAGE_SIZE, PAGE_SIZE,
meye.mchip_ptable[i], *pt); meye.mchip_ptable[i], *pt);
pt++; pt++;
} }
if (meye.mchip_ptable_toc) if (meye.mchip_ptable_toc)
dma_free_coherent(&meye.mchip_dev->dev, dma_free_coherent(&meye.mchip_dev->dev,
PAGE_SIZE, PAGE_SIZE,
meye.mchip_ptable_toc, meye.mchip_ptable_toc,
meye.mchip_dmahandle); meye.mchip_dmahandle);
...@@ -182,9 +186,10 @@ static void ptable_free(void) { ...@@ -182,9 +186,10 @@ static void ptable_free(void) {
} }
/* copy data from ptable into buf */ /* copy data from ptable into buf */
static void ptable_copy(u8 *buf, int start, int size, int pt_pages) { static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
{
int i; int i;
for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) { for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE); memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
if (start >= pt_pages) if (start >= pt_pages)
...@@ -193,224 +198,193 @@ static void ptable_copy(u8 *buf, int start, int size, int pt_pages) { ...@@ -193,224 +198,193 @@ static void ptable_copy(u8 *buf, int start, int size, int pt_pages) {
memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE); memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
} }
/****************************************************************************/ /****************************************************************************/
/* JPEG tables at different qualities to load into the VRJ chip */ /* JPEG tables at different qualities to load into the VRJ chip */
/****************************************************************************/ /****************************************************************************/
/* return a set of quantisation tables based on a quality from 1 to 10 */ /* return a set of quantisation tables based on a quality from 1 to 10 */
static u16 *jpeg_quantisation_tables(int *size, int quality) { static u16 *jpeg_quantisation_tables(int *length, int quality)
static u16 tables0[] = { {
0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, static u16 jpeg_tables[][70] = { {
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
}; 0xffff, 0xffff, 0xffff,
static u16 tables1[] = { },
0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46, {
0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8, 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
}; 0xffff, 0xffff, 0xffff,
static u16 tables2[] = { },
0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23, {
0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164, 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad, 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff, 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
0xe6ff, 0xfffd, 0xfff8, 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876, 0xe6ff, 0xfffd, 0xfff8,
0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
0xf8f8, 0xf8f8, 0xfff8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
}; 0xf8f8, 0xf8f8, 0xfff8,
static u16 tables3[] = { },
0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17, {
0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042, 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73, 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba, 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
0x99c7, 0xaba8, 0xffa4, 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e, 0x99c7, 0xaba8, 0xffa4,
0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
0xa4a4, 0xa4a4, 0xffa4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
}; 0xa4a4, 0xa4a4, 0xffa4,
static u16 tables4[] = { },
0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712, {
0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932, 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556, 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c, 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
0x7396, 0x817e, 0xff7c, 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b, 0x7396, 0x817e, 0xff7c,
0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
0x7c7c, 0x7c7c, 0xff7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
}; 0x7c7c, 0x7c7c, 0xff7c,
static u16 tables5[] = { },
0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e, {
0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28, 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745, 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470, 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
0x5c78, 0x6765, 0xff63, 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f, 0x5c78, 0x6765, 0xff63,
0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
0x6363, 0x6363, 0xff63, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
}; 0x6363, 0x6363, 0xff63,
static u16 tables6[] = { },
0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b, {
0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20, 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37, 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a, 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
0x4a60, 0x5251, 0xff4f, 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26, 0x4a60, 0x5251, 0xff4f,
0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
0x4f4f, 0x4f4f, 0xff4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
}; 0x4f4f, 0x4f4f, 0xff4f,
static u16 tables7[] = { },
0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08, {
0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318, 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129, 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43, 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
0x3748, 0x3e3d, 0xff3b, 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c, 0x3748, 0x3e3d, 0xff3b,
0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
0x3b3b, 0x3b3b, 0xff3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
}; 0x3b3b, 0x3b3b, 0xff3b,
static u16 tables8[] = { },
0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706, {
0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710, 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c, 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d, 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
0x2530, 0x2928, 0xff28, 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813, 0x2530, 0x2928, 0xff28,
0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
0x2828, 0x2828, 0xff28, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
}; 0x2828, 0x2828, 0xff28,
static u16 tables9[] = { },
0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403, {
0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08, 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e, 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416, 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
0x1218, 0x1514, 0xff14, 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409, 0x1218, 0x1514, 0xff14,
0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
0x1414, 0x1414, 0xff14, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
}; 0x1414, 0x1414, 0xff14,
static u16 tables10[] = { },
0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, {
0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0x0101, 0x0101, 0xff01, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0xff01,
0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0x0101, 0x0101, 0xff01, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
}; 0x0101, 0x0101, 0xff01,
} };
switch (quality) {
case 0: if (quality < 0 || quality > 10) {
*size = sizeof(tables0); printk(KERN_WARNING
return tables0; "meye: invalid quality level %d - using 8\n", quality);
case 1: quality = 8;
*size = sizeof(tables1); }
return tables1;
case 2: *length = ARRAY_SIZE(jpeg_tables[quality]);
*size = sizeof(tables2); return jpeg_tables[quality];
return tables2;
case 3:
*size = sizeof(tables3);
return tables3;
case 4:
*size = sizeof(tables4);
return tables4;
case 5:
*size = sizeof(tables5);
return tables5;
case 6:
*size = sizeof(tables6);
return tables6;
case 7:
*size = sizeof(tables7);
return tables7;
case 8:
*size = sizeof(tables8);
return tables8;
case 9:
*size = sizeof(tables9);
return tables9;
case 10:
*size = sizeof(tables10);
return tables10;
default:
printk(KERN_WARNING "meye: invalid quality level %d - using 8\n", quality);
*size = sizeof(tables8);
return tables8;
}
return NULL;
} }
/* return a generic set of huffman tables */ /* return a generic set of huffman tables */
static u16 *jpeg_huffman_tables(int *size) { static u16 *jpeg_huffman_tables(int *length)
{
static u16 tables[] = { static u16 tables[] = {
0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405, 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131, 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142, 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918, 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443, 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463, 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483, 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2, 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA, 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405, 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206, 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1, 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125, 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A, 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A, 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A, 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2, 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA, 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000, 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09, 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
0xFF0B, 0xFF0B,
0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101, 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09, 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
0xFF0B 0xFF0B
}; };
*size = sizeof(tables); *length = ARRAY_SIZE(tables);
return tables; return tables;
} }
...@@ -419,23 +393,27 @@ static u16 *jpeg_huffman_tables(int *size) { ...@@ -419,23 +393,27 @@ static u16 *jpeg_huffman_tables(int *size) {
/****************************************************************************/ /****************************************************************************/
/* returns the horizontal capture size */ /* returns the horizontal capture size */
static inline int mchip_hsize(void) { static inline int mchip_hsize(void)
{
return meye.params.subsample ? 320 : 640; return meye.params.subsample ? 320 : 640;
} }
/* returns the vertical capture size */ /* returns the vertical capture size */
static inline int mchip_vsize(void) { static inline int mchip_vsize(void)
{
return meye.params.subsample ? 240 : 480; return meye.params.subsample ? 240 : 480;
} }
/* waits for a register to be available */ /* waits for a register to be available */
static void mchip_sync(int reg) { static void mchip_sync(int reg)
{
u32 status; u32 status;
int i; int i;
if (reg == MCHIP_MM_FIFO_DATA) { if (reg == MCHIP_MM_FIFO_DATA) {
for (i = 0; i < MCHIP_REG_TIMEOUT; i++) { for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
status = readl(meye.mchip_mmregs + MCHIP_MM_FIFO_STATUS); status = readl(meye.mchip_mmregs +
MCHIP_MM_FIFO_STATUS);
if (!(status & MCHIP_MM_FIFO_WAIT)) { if (!(status & MCHIP_MM_FIFO_WAIT)) {
printk(KERN_WARNING "meye: fifo not ready\n"); printk(KERN_WARNING "meye: fifo not ready\n");
return; return;
...@@ -444,44 +422,48 @@ static void mchip_sync(int reg) { ...@@ -444,44 +422,48 @@ static void mchip_sync(int reg) {
return; return;
udelay(1); udelay(1);
} }
} } else if (reg > 0x80) {
else if (reg > 0x80) {
u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
: MCHIP_HIC_STATUS_VRJ_RDY; : MCHIP_HIC_STATUS_VRJ_RDY;
for (i = 0; i < MCHIP_REG_TIMEOUT; i++) { for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS); status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
if (status & mask) if (status & mask)
return; return;
udelay(1); udelay(1);
} }
} } else
else
return; return;
printk(KERN_WARNING "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n", reg, status); printk(KERN_WARNING
"meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
reg, status);
} }
/* sets a value into the register */ /* sets a value into the register */
static inline void mchip_set(int reg, u32 v) { static inline void mchip_set(int reg, u32 v)
{
mchip_sync(reg); mchip_sync(reg);
writel(v, meye.mchip_mmregs + reg); writel(v, meye.mchip_mmregs + reg);
} }
/* get the register value */ /* get the register value */
static inline u32 mchip_read(int reg) { static inline u32 mchip_read(int reg)
{
mchip_sync(reg); mchip_sync(reg);
return readl(meye.mchip_mmregs + reg); return readl(meye.mchip_mmregs + reg);
} }
/* wait for a register to become a particular value */ /* wait for a register to become a particular value */
static inline int mchip_delay(u32 reg, u32 v) { static inline int mchip_delay(u32 reg, u32 v)
{
int n = 10; int n = 10;
while (--n && mchip_read(reg) != v) while (--n && mchip_read(reg) != v)
udelay(1); udelay(1);
return n; return n;
} }
/* setup subsampling */ /* setup subsampling */
static void mchip_subsample(void) { static void mchip_subsample(void)
{
mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample); mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize()); mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize()); mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
...@@ -491,29 +473,31 @@ static void mchip_subsample(void) { ...@@ -491,29 +473,31 @@ static void mchip_subsample(void) {
} }
/* set the framerate into the mchip */ /* set the framerate into the mchip */
static void mchip_set_framerate(void) { static void mchip_set_framerate(void)
{
mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate); mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
} }
/* load some huffman and quantisation tables into the VRJ chip ready /* load some huffman and quantisation tables into the VRJ chip ready
for JPEG compression */ for JPEG compression */
static void mchip_load_tables(void) { static void mchip_load_tables(void)
{
int i; int i;
int size; int length;
u16 *tables; u16 *tables;
tables = jpeg_huffman_tables(&size); tables = jpeg_huffman_tables(&length);
for (i = 0; i < size / 2; i++) for (i = 0; i < length; i++)
writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA); writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
tables = jpeg_quantisation_tables(&size, meye.params.quality); tables = jpeg_quantisation_tables(&length, meye.params.quality);
for (i = 0; i < size / 2; i++) for (i = 0; i < length; i++)
writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA); writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
} }
/* setup the VRJ parameters in the chip */ /* setup the VRJ parameters in the chip */
static void mchip_vrj_setup(u8 mode) { static void mchip_vrj_setup(u8 mode)
{
mchip_set(MCHIP_VRJ_BUS_MODE, 5); mchip_set(MCHIP_VRJ_BUS_MODE, 5);
mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f); mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
mchip_set(MCHIP_VRJ_PDAT_USE, 1); mchip_set(MCHIP_VRJ_PDAT_USE, 1);
...@@ -530,13 +514,14 @@ static void mchip_vrj_setup(u8 mode) { ...@@ -530,13 +514,14 @@ static void mchip_vrj_setup(u8 mode) {
mchip_set(MCHIP_VRJ_SOF2, 0x1502); mchip_set(MCHIP_VRJ_SOF2, 0x1502);
mchip_set(MCHIP_VRJ_SOF3, 0x1503); mchip_set(MCHIP_VRJ_SOF3, 0x1503);
mchip_set(MCHIP_VRJ_SOF4, 0x1596); mchip_set(MCHIP_VRJ_SOF4, 0x1596);
mchip_set(MCHIP_VRJ_SOS, 0x0ed0); mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
mchip_load_tables(); mchip_load_tables();
} }
/* sets the DMA parameters into the chip */ /* sets the DMA parameters into the chip */
static void mchip_dma_setup(u32 dma_addr) { static void mchip_dma_setup(u32 dma_addr)
{
int i; int i;
mchip_set(MCHIP_MM_PT_ADDR, dma_addr); mchip_set(MCHIP_MM_PT_ADDR, dma_addr);
...@@ -546,7 +531,8 @@ static void mchip_dma_setup(u32 dma_addr) { ...@@ -546,7 +531,8 @@ static void mchip_dma_setup(u32 dma_addr) {
} }
/* setup for DMA transfers - also zeros the framebuffer */ /* setup for DMA transfers - also zeros the framebuffer */
static int mchip_dma_alloc(void) { static int mchip_dma_alloc(void)
{
if (!meye.mchip_dmahandle) if (!meye.mchip_dmahandle)
if (ptable_alloc()) if (ptable_alloc())
return -1; return -1;
...@@ -554,7 +540,8 @@ static int mchip_dma_alloc(void) { ...@@ -554,7 +540,8 @@ static int mchip_dma_alloc(void) {
} }
/* frees the DMA buffer */ /* frees the DMA buffer */
static void mchip_dma_free(void) { static void mchip_dma_free(void)
{
if (meye.mchip_dmahandle) { if (meye.mchip_dmahandle) {
mchip_dma_setup(0); mchip_dma_setup(0);
ptable_free(); ptable_free();
...@@ -563,7 +550,8 @@ static void mchip_dma_free(void) { ...@@ -563,7 +550,8 @@ static void mchip_dma_free(void) {
/* stop any existing HIC action and wait for any dma to complete then /* stop any existing HIC action and wait for any dma to complete then
reset the dma engine */ reset the dma engine */
static void mchip_hic_stop(void) { static void mchip_hic_stop(void)
{
int i, j; int i, j;
meye.mchip_mode = MCHIP_HIC_MODE_NOOP; meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
...@@ -573,12 +561,13 @@ static void mchip_hic_stop(void) { ...@@ -573,12 +561,13 @@ static void mchip_hic_stop(void) {
mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP); mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
mchip_delay(MCHIP_HIC_CMD, 0); mchip_delay(MCHIP_HIC_CMD, 0);
for (j = 0; j < 100; ++j) { for (j = 0; j < 100; ++j) {
if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE)) if (mchip_delay(MCHIP_HIC_STATUS,
MCHIP_HIC_STATUS_IDLE))
return; return;
msleep(1); msleep(1);
} }
printk(KERN_ERR "meye: need to reset HIC!\n"); printk(KERN_ERR "meye: need to reset HIC!\n");
mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET); mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
msleep(250); msleep(250);
} }
...@@ -590,15 +579,17 @@ static void mchip_hic_stop(void) { ...@@ -590,15 +579,17 @@ static void mchip_hic_stop(void) {
/****************************************************************************/ /****************************************************************************/
/* get the next ready frame from the dma engine */ /* get the next ready frame from the dma engine */
static u32 mchip_get_frame(void) { static u32 mchip_get_frame(void)
{
u32 v; u32 v;
v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum)); v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
return v; return v;
} }
/* frees the current frame from the dma engine */ /* frees the current frame from the dma engine */
static void mchip_free_frame(void) { static void mchip_free_frame(void)
{
mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0); mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
meye.mchip_fnum++; meye.mchip_fnum++;
meye.mchip_fnum %= 4; meye.mchip_fnum %= 4;
...@@ -606,17 +597,18 @@ static void mchip_free_frame(void) { ...@@ -606,17 +597,18 @@ static void mchip_free_frame(void) {
/* read one frame from the framebuffer assuming it was captured using /* read one frame from the framebuffer assuming it was captured using
a uncompressed transfer */ a uncompressed transfer */
static void mchip_cont_read_frame(u32 v, u8 *buf, int size) { static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
{
int pt_id; int pt_id;
pt_id = (v >> 17) & 0x3FF; pt_id = (v >> 17) & 0x3FF;
ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES); ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
} }
/* read a compressed frame from the framebuffer */ /* read a compressed frame from the framebuffer */
static int mchip_comp_read_frame(u32 v, u8 *buf, int size) { static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
{
int pt_start, pt_end, trailer; int pt_start, pt_end, trailer;
int fsize; int fsize;
int i; int i;
...@@ -632,18 +624,17 @@ static int mchip_comp_read_frame(u32 v, u8 *buf, int size) { ...@@ -632,18 +624,17 @@ static int mchip_comp_read_frame(u32 v, u8 *buf, int size) {
fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4; fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
if (fsize > size) { if (fsize > size) {
printk(KERN_WARNING "meye: oversized compressed frame %d\n", printk(KERN_WARNING "meye: oversized compressed frame %d\n",
fsize); fsize);
return -1; return -1;
} }
ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG); ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
#ifdef MEYE_JPEG_CORRECTION #ifdef MEYE_JPEG_CORRECTION
/* Some mchip generated jpeg frames are incorrect. In most /* Some mchip generated jpeg frames are incorrect. In most
* (all ?) of those cases, the final EOI (0xff 0xd9) marker * (all ?) of those cases, the final EOI (0xff 0xd9) marker
* is not present at the end of the frame. * is not present at the end of the frame.
* *
* Since adding the final marker is not enough to restore * Since adding the final marker is not enough to restore
...@@ -661,9 +652,10 @@ static int mchip_comp_read_frame(u32 v, u8 *buf, int size) { ...@@ -661,9 +652,10 @@ static int mchip_comp_read_frame(u32 v, u8 *buf, int size) {
} }
/* take a picture into SDRAM */ /* take a picture into SDRAM */
static void mchip_take_picture(void) { static void mchip_take_picture(void)
{
int i; int i;
mchip_hic_stop(); mchip_hic_stop();
mchip_subsample(); mchip_subsample();
mchip_dma_setup(meye.mchip_dmahandle); mchip_dma_setup(meye.mchip_dmahandle);
...@@ -681,7 +673,8 @@ static void mchip_take_picture(void) { ...@@ -681,7 +673,8 @@ static void mchip_take_picture(void) {
} }
/* dma a previously taken picture into a buffer */ /* dma a previously taken picture into a buffer */
static void mchip_get_picture(u8 *buf, int bufsize) { static void mchip_get_picture(u8 *buf, int bufsize)
{
u32 v; u32 v;
int i; int i;
...@@ -694,7 +687,7 @@ static void mchip_get_picture(u8 *buf, int bufsize) { ...@@ -694,7 +687,7 @@ static void mchip_get_picture(u8 *buf, int bufsize) {
break; break;
msleep(1); msleep(1);
} }
for (i = 0; i < 4 ; ++i) { for (i = 0; i < 4; ++i) {
v = mchip_get_frame(); v = mchip_get_frame();
if (v & MCHIP_MM_FIR_RDY) { if (v & MCHIP_MM_FIR_RDY) {
mchip_cont_read_frame(v, buf, bufsize); mchip_cont_read_frame(v, buf, bufsize);
...@@ -705,7 +698,8 @@ static void mchip_get_picture(u8 *buf, int bufsize) { ...@@ -705,7 +698,8 @@ static void mchip_get_picture(u8 *buf, int bufsize) {
} }
/* start continuous dma capture */ /* start continuous dma capture */
static void mchip_continuous_start(void) { static void mchip_continuous_start(void)
{
mchip_hic_stop(); mchip_hic_stop();
mchip_subsample(); mchip_subsample();
mchip_set_framerate(); mchip_set_framerate();
...@@ -720,7 +714,8 @@ static void mchip_continuous_start(void) { ...@@ -720,7 +714,8 @@ static void mchip_continuous_start(void) {
} }
/* compress one frame into a buffer */ /* compress one frame into a buffer */
static int mchip_compress_frame(u8 *buf, int bufsize) { static int mchip_compress_frame(u8 *buf, int bufsize)
{
u32 v; u32 v;
int len = -1, i; int len = -1, i;
...@@ -729,7 +724,7 @@ static int mchip_compress_frame(u8 *buf, int bufsize) { ...@@ -729,7 +724,7 @@ static int mchip_compress_frame(u8 *buf, int bufsize) {
mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP); mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START); mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
mchip_delay(MCHIP_HIC_CMD, 0); mchip_delay(MCHIP_HIC_CMD, 0);
for (i = 0; i < 100; ++i) { for (i = 0; i < 100; ++i) {
if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE)) if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
...@@ -737,7 +732,7 @@ static int mchip_compress_frame(u8 *buf, int bufsize) { ...@@ -737,7 +732,7 @@ static int mchip_compress_frame(u8 *buf, int bufsize) {
msleep(1); msleep(1);
} }
for (i = 0; i < 4 ; ++i) { for (i = 0; i < 4; ++i) {
v = mchip_get_frame(); v = mchip_get_frame();
if (v & MCHIP_MM_FIR_RDY) { if (v & MCHIP_MM_FIR_RDY) {
len = mchip_comp_read_frame(v, buf, bufsize); len = mchip_comp_read_frame(v, buf, bufsize);
...@@ -750,13 +745,14 @@ static int mchip_compress_frame(u8 *buf, int bufsize) { ...@@ -750,13 +745,14 @@ static int mchip_compress_frame(u8 *buf, int bufsize) {
#if 0 #if 0
/* uncompress one image into a buffer */ /* uncompress one image into a buffer */
static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize) { static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
{
mchip_vrj_setup(0x3f); mchip_vrj_setup(0x3f);
udelay(50); udelay(50);
mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP); mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START); mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
mchip_delay(MCHIP_HIC_CMD, 0); mchip_delay(MCHIP_HIC_CMD, 0);
return mchip_comp_read_frame(buf, bufsize); return mchip_comp_read_frame(buf, bufsize);
...@@ -764,7 +760,8 @@ static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize) { ...@@ -764,7 +760,8 @@ static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize) {
#endif #endif
/* start continuous compressed capture */ /* start continuous compressed capture */
static void mchip_cont_compression_start(void) { static void mchip_cont_compression_start(void)
{
mchip_hic_stop(); mchip_hic_stop();
mchip_vrj_setup(0x3f); mchip_vrj_setup(0x3f);
mchip_subsample(); mchip_subsample();
...@@ -782,6 +779,7 @@ static void mchip_cont_compression_start(void) { ...@@ -782,6 +779,7 @@ static void mchip_cont_compression_start(void) {
/****************************************************************************/ /****************************************************************************/
/* Interrupt handling */ /* Interrupt handling */
/****************************************************************************/ /****************************************************************************/
static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs)
{ {
u32 v; u32 v;
...@@ -842,10 +840,11 @@ static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs) ...@@ -842,10 +840,11 @@ static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs)
/* video4linux integration */ /* video4linux integration */
/****************************************************************************/ /****************************************************************************/
static int meye_open(struct inode *inode, struct file *file) { static int meye_open(struct inode *inode, struct file *file)
{
int i, err; int i, err;
err = video_exclusive_open(inode,file); err = video_exclusive_open(inode, file);
if (err < 0) if (err < 0)
return err; return err;
...@@ -853,7 +852,7 @@ static int meye_open(struct inode *inode, struct file *file) { ...@@ -853,7 +852,7 @@ static int meye_open(struct inode *inode, struct file *file) {
if (mchip_dma_alloc()) { if (mchip_dma_alloc()) {
printk(KERN_ERR "meye: mchip framebuffer allocation failed\n"); printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
video_exclusive_release(inode,file); video_exclusive_release(inode, file);
return -ENOBUFS; return -ENOBUFS;
} }
...@@ -861,20 +860,20 @@ static int meye_open(struct inode *inode, struct file *file) { ...@@ -861,20 +860,20 @@ static int meye_open(struct inode *inode, struct file *file) {
meye.grab_buffer[i].state = MEYE_BUF_UNUSED; meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
kfifo_reset(meye.grabq); kfifo_reset(meye.grabq);
kfifo_reset(meye.doneq); kfifo_reset(meye.doneq);
return 0; return 0;
} }
static int meye_release(struct inode *inode, struct file *file) { static int meye_release(struct inode *inode, struct file *file)
{
mchip_hic_stop(); mchip_hic_stop();
mchip_dma_free(); mchip_dma_free();
video_exclusive_release(inode,file); video_exclusive_release(inode, file);
return 0; return 0;
} }
static int meye_do_ioctl(struct inode *inode, struct file *file, static int meye_do_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, void *arg) { unsigned int cmd, void *arg)
{
switch (cmd) { switch (cmd) {
case VIDIOCGCAP: { case VIDIOCGCAP: {
...@@ -921,13 +920,13 @@ static int meye_do_ioctl(struct inode *inode, struct file *file, ...@@ -921,13 +920,13 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
if (p->palette != VIDEO_PALETTE_YUV422) if (p->palette != VIDEO_PALETTE_YUV422)
return -EINVAL; return -EINVAL;
down(&meye.lock); down(&meye.lock);
sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS, sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS,
p->brightness >> 10); p->brightness >> 10);
sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE, sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE,
p->hue >> 10); p->hue >> 10);
sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR, sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR,
p->colour >> 10); p->colour >> 10);
sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST, sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST,
p->contrast >> 10); p->contrast >> 10);
meye.picture = *p; meye.picture = *p;
up(&meye.lock); up(&meye.lock);
...@@ -988,14 +987,12 @@ static int meye_do_ioctl(struct inode *inode, struct file *file, ...@@ -988,14 +987,12 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
meye.params.subsample = 0; meye.params.subsample = 0;
restart = 1; restart = 1;
} }
} } else if (vm->width == 320 && vm->height == 240) {
else if (vm->width == 320 && vm->height == 240) {
if (!meye.params.subsample) { if (!meye.params.subsample) {
meye.params.subsample = 1; meye.params.subsample = 1;
restart = 1; restart = 1;
} }
} } else {
else {
up(&meye.lock); up(&meye.lock);
return -EINVAL; return -EINVAL;
} }
...@@ -1054,7 +1051,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file, ...@@ -1054,7 +1051,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
case MEYEIOC_QBUF_CAPT: { case MEYEIOC_QBUF_CAPT: {
int *nb = arg; int *nb = arg;
if (!meye.grab_fbuffer) if (!meye.grab_fbuffer)
return -EINVAL; return -EINVAL;
if (*nb >= gbuffers) if (*nb >= gbuffers)
return -EINVAL; return -EINVAL;
...@@ -1109,7 +1106,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file, ...@@ -1109,7 +1106,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
case MEYEIOC_STILLCAPT: { case MEYEIOC_STILLCAPT: {
if (!meye.grab_fbuffer) if (!meye.grab_fbuffer)
return -EINVAL; return -EINVAL;
if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED) if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
return -EBUSY; return -EBUSY;
...@@ -1127,7 +1124,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file, ...@@ -1127,7 +1124,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
case MEYEIOC_STILLJCAPT: { case MEYEIOC_STILLJCAPT: {
int *len = arg; int *len = arg;
if (!meye.grab_fbuffer) if (!meye.grab_fbuffer)
return -EINVAL; return -EINVAL;
if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED) if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
return -EBUSY; return -EBUSY;
...@@ -1695,7 +1692,8 @@ static struct vm_operations_struct meye_vm_ops = { ...@@ -1695,7 +1692,8 @@ static struct vm_operations_struct meye_vm_ops = {
.close = meye_vm_close, .close = meye_vm_close,
}; };
static int meye_mmap(struct file *file, struct vm_area_struct *vma) { static int meye_mmap(struct file *file, struct vm_area_struct *vma)
{
unsigned long start = vma->vm_start; unsigned long start = vma->vm_start;
unsigned long size = vma->vm_end - vma->vm_start; unsigned long size = vma->vm_end - vma->vm_start;
unsigned long offset = vma->vm_pgoff << PAGE_SHIFT; unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
...@@ -1801,8 +1799,9 @@ static int meye_resume(struct pci_dev *pdev) ...@@ -1801,8 +1799,9 @@ static int meye_resume(struct pci_dev *pdev)
} }
#endif #endif
static int __devinit meye_probe(struct pci_dev *pcidev, static int __devinit meye_probe(struct pci_dev *pcidev,
const struct pci_device_id *ent) { const struct pci_device_id *ent)
{
int ret = -EBUSY; int ret = -EBUSY;
unsigned long mchip_adr; unsigned long mchip_adr;
u8 revision; u8 revision;
...@@ -1897,12 +1896,12 @@ static int __devinit meye_probe(struct pci_dev *pcidev, ...@@ -1897,12 +1896,12 @@ static int __devinit meye_probe(struct pci_dev *pcidev,
msleep(1); msleep(1);
mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK); mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER, video_nr) < 0) { if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER,
video_nr) < 0) {
printk(KERN_ERR "meye: video_register_device failed\n"); printk(KERN_ERR "meye: video_register_device failed\n");
goto outvideoreg; goto outvideoreg;
} }
init_MUTEX(&meye.lock); init_MUTEX(&meye.lock);
init_waitqueue_head(&meye.proc_list); init_waitqueue_head(&meye.proc_list);
meye.picture.depth = 16; meye.picture.depth = 16;
...@@ -1956,8 +1955,8 @@ static int __devinit meye_probe(struct pci_dev *pcidev, ...@@ -1956,8 +1955,8 @@ static int __devinit meye_probe(struct pci_dev *pcidev,
return ret; return ret;
} }
static void __devexit meye_remove(struct pci_dev *pcidev) { static void __devexit meye_remove(struct pci_dev *pcidev)
{
video_unregister_device(meye.video_dev); video_unregister_device(meye.video_dev);
mchip_hic_stop(); mchip_hic_stop();
...@@ -1992,7 +1991,7 @@ static void __devexit meye_remove(struct pci_dev *pcidev) { ...@@ -1992,7 +1991,7 @@ static void __devexit meye_remove(struct pci_dev *pcidev) {
} }
static struct pci_device_id meye_pci_tbl[] = { static struct pci_device_id meye_pci_tbl[] = {
{ PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002, { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
{ } { }
}; };
...@@ -2010,20 +2009,23 @@ static struct pci_driver meye_driver = { ...@@ -2010,20 +2009,23 @@ static struct pci_driver meye_driver = {
#endif #endif
}; };
static int __init meye_init(void) { static int __init meye_init(void)
{
gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS)); gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE) if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
gbufsize = MEYE_MAX_BUFSIZE; gbufsize = MEYE_MAX_BUFSIZE;
gbufsize = PAGE_ALIGN(gbufsize); gbufsize = PAGE_ALIGN(gbufsize);
printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n", printk(KERN_INFO "meye: using %d buffers with %dk (%dk total)"
gbuffers, gbufsize/1024, gbuffers*gbufsize/1024); "for capture\n",
return pci_module_init(&meye_driver); gbuffers,
gbufsize / 1024, gbuffers * gbufsize / 1024);
return pci_register_driver(&meye_driver);
} }
static void __exit meye_exit(void) { static void __exit meye_exit(void)
{
pci_unregister_driver(&meye_driver); pci_unregister_driver(&meye_driver);
} }
/* Module entry points */
module_init(meye_init); module_init(meye_init);
module_exit(meye_exit); module_exit(meye_exit);
drivers/media/video/meye.h
View file @ 2d39d7cf
/* /*
* Motion Eye video4linux driver for Sony Vaio PictureBook * Motion Eye video4linux driver for Sony Vaio PictureBook
* *
* Copyright (C) 2001-2003 Stelian Pop <stelian@popies.net> * Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
* *
* Copyright (C) 2001-2002 Alcve <www.alcove.com> * Copyright (C) 2001-2002 Alcve <www.alcove.com>
* *
* Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com> * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
* *
* Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras. * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
* *
* Some parts borrowed from various video4linux drivers, especially * Some parts borrowed from various video4linux drivers, especially
* bttv-driver.c and zoran.c, see original files for credits. * bttv-driver.c and zoran.c, see original files for credits.
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
...@@ -30,7 +30,7 @@ ...@@ -30,7 +30,7 @@
#ifndef _MEYE_PRIV_H_ #ifndef _MEYE_PRIV_H_
#define _MEYE_PRIV_H_ #define _MEYE_PRIV_H_
#define MEYE_DRIVER_MAJORVERSION 1 #define MEYE_DRIVER_MAJORVERSION 1
#define MEYE_DRIVER_MINORVERSION 10 #define MEYE_DRIVER_MINORVERSION 10
#define MEYE_DRIVER_VERSION __stringify(MEYE_DRIVER_MAJORVERSION) "." \ #define MEYE_DRIVER_VERSION __stringify(MEYE_DRIVER_MAJORVERSION) "." \
...@@ -47,7 +47,7 @@ ...@@ -47,7 +47,7 @@
/* Motion JPEG chip PCI configuration registers */ /* Motion JPEG chip PCI configuration registers */
#define MCHIP_PCI_POWER_CSR 0x54 #define MCHIP_PCI_POWER_CSR 0x54
#define MCHIP_PCI_MCORE_STATUS 0x60 /* see HIC_STATUS */ #define MCHIP_PCI_MCORE_STATUS 0x60 /* see HIC_STATUS */
#define MCHIP_PCI_HOSTUSEREQ_SET 0x64 #define MCHIP_PCI_HOSTUSEREQ_SET 0x64
#define MCHIP_PCI_HOSTUSEREQ_CLR 0x68 #define MCHIP_PCI_HOSTUSEREQ_CLR 0x68
#define MCHIP_PCI_LOWPOWER_SET 0x6c #define MCHIP_PCI_LOWPOWER_SET 0x6c
...@@ -77,7 +77,7 @@ ...@@ -77,7 +77,7 @@
#define MCHIP_MM_INTA_PCI_ERR 0x00000040 /* PCI error */ #define MCHIP_MM_INTA_PCI_ERR 0x00000040 /* PCI error */
#define MCHIP_MM_INTA_PCI_ERR_MASK 0x00004000 #define MCHIP_MM_INTA_PCI_ERR_MASK 0x00004000
#define MCHIP_MM_PT_ADDR 0x08 /* page table address */ #define MCHIP_MM_PT_ADDR 0x08 /* page table address*/
/* n*4kB */ /* n*4kB */
#define MCHIP_NB_PAGES 1024 /* pages for display */ #define MCHIP_NB_PAGES 1024 /* pages for display */
#define MCHIP_NB_PAGES_MJPEG 256 /* pages for mjpeg */ #define MCHIP_NB_PAGES_MJPEG 256 /* pages for mjpeg */
...@@ -288,33 +288,25 @@ struct meye_grab_buffer { ...@@ -288,33 +288,25 @@ struct meye_grab_buffer {
/* Motion Eye device structure */ /* Motion Eye device structure */
struct meye { struct meye {
/* mchip related */
struct pci_dev *mchip_dev; /* pci device */ struct pci_dev *mchip_dev; /* pci device */
u8 mchip_irq; /* irq */ u8 mchip_irq; /* irq */
u8 mchip_mode; /* actual mchip mode: HIC_MODE... */ u8 mchip_mode; /* actual mchip mode: HIC_MODE... */
u8 mchip_fnum; /* current mchip frame number */ u8 mchip_fnum; /* current mchip frame number */
unsigned char *mchip_mmregs; /* mchip: memory mapped registers */ unsigned char *mchip_mmregs; /* mchip: memory mapped registers */
u8 *mchip_ptable[MCHIP_NB_PAGES];/* mchip: ptable */ u8 *mchip_ptable[MCHIP_NB_PAGES];/* mchip: ptable */
dma_addr_t *mchip_ptable_toc; /* mchip: ptable toc */ dma_addr_t *mchip_ptable_toc; /* mchip: ptable toc */
dma_addr_t mchip_dmahandle; /* mchip: dma handle to ptable toc */ dma_addr_t mchip_dmahandle; /* mchip: dma handle to ptable toc */
unsigned char *grab_fbuffer; /* capture framebuffer */ unsigned char *grab_fbuffer; /* capture framebuffer */
unsigned char *grab_temp; /* temporary buffer */ unsigned char *grab_temp; /* temporary buffer */
/* list of buffers */ /* list of buffers */
struct meye_grab_buffer grab_buffer[MEYE_MAX_BUFNBRS]; struct meye_grab_buffer grab_buffer[MEYE_MAX_BUFNBRS];
int vma_use_count[MEYE_MAX_BUFNBRS]; /* mmap count */ int vma_use_count[MEYE_MAX_BUFNBRS]; /* mmap count */
/* other */
struct semaphore lock; /* semaphore for open/mmap... */ struct semaphore lock; /* semaphore for open/mmap... */
struct kfifo *grabq; /* queue for buffers to be grabbed */ struct kfifo *grabq; /* queue for buffers to be grabbed */
spinlock_t grabq_lock; /* lock protecting the queue */ spinlock_t grabq_lock; /* lock protecting the queue */
struct kfifo *doneq; /* queue for grabbed buffers */ struct kfifo *doneq; /* queue for grabbed buffers */
spinlock_t doneq_lock; /* lock protecting the queue */ spinlock_t doneq_lock; /* lock protecting the queue */
wait_queue_head_t proc_list; /* wait queue */ wait_queue_head_t proc_list; /* wait queue */
struct video_device *video_dev; /* video device parameters */ struct video_device *video_dev; /* video device parameters */
struct video_picture picture; /* video picture parameters */ struct video_picture picture; /* video picture parameters */
struct meye_params params; /* additional parameters */ struct meye_params params; /* additional parameters */
......
include/linux/meye.h
View file @ 2d39d7cf
/* /*
* Motion Eye video4linux driver for Sony Vaio PictureBook * Motion Eye video4linux driver for Sony Vaio PictureBook
* *
* Copyright (C) 2001-2003 Stelian Pop <stelian@popies.net> * Copyright (C) 2001-2003 Stelian Pop <stelian@popies.net>
...@@ -8,20 +8,20 @@ ...@@ -8,20 +8,20 @@
* Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com> * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
* *
* Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras. * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
* *
* Some parts borrowed from various video4linux drivers, especially * Some parts borrowed from various video4linux drivers, especially
* bttv-driver.c and zoran.c, see original files for credits. * bttv-driver.c and zoran.c, see original files for credits.
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7