[PATCH] meye: whitespace and coding style cleanups

Signed-off-by: Stelian Pop <stelian@popies.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Documentation/video4linux/meye.txt

 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) 2000 Andrew Tridgell <tridge@samba.org>
 

drivers/media/video/meye.c

 /*
  * 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>
  *
@@ -73,15 +73,16 @@ static struct meye meye;
 /****************************************************************************/
 /* Memory allocation routines (stolen from bttv-driver.c)                   */
 /****************************************************************************/
-static void *rvmalloc(unsigned long size) {
+static void *rvmalloc(unsigned long size)
+{
 	void *mem;
 	unsigned long adr;
 
 	size = PAGE_ALIGN(size);
 	mem = vmalloc_32(size);
 	if (mem) {
-		memset(mem, 0, size); /* Clear the ram out, no junk to the user */
-	        adr = (unsigned long)mem;
+		memset(mem, 0, size);
+		adr = (unsigned long) mem;
 		while (size > 0) {
 			SetPageReserved(vmalloc_to_page((void *)adr));
 			adr += PAGE_SIZE;
@@ -91,7 +92,8 @@ static void *rvmalloc(unsigned long size) {
 	return mem;
 }
 
-static void rvfree(void * mem, unsigned long size) {
+static void rvfree(void * mem, unsigned long size)
+{
 	unsigned long adr;
 
 	if (mem) {
@@ -114,7 +116,8 @@ static void rvfree(void * mem, unsigned long size) {
  * dma_addr_t for correctness but the compilation of this driver is
  * disabled for HIGHMEM64G=y, where sizeof(dma_addr_t) != 4
  */
-static int ptable_alloc(void) {
+static int ptable_alloc(void)
+{
 	dma_addr_t *pt;
 	int i;
 
@@ -157,7 +160,8 @@ static int ptable_alloc(void) {
 	return 0;
 }
 
-static void ptable_free(void) {
+static void ptable_free(void)
+{
 	dma_addr_t *pt;
 	int i;
 
@@ -182,7 +186,8 @@ static void ptable_free(void) {
 }
 
 /* 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;
 
 	for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
@@ -193,14 +198,14 @@ static void ptable_copy(u8 *buf, int start, int size, int pt_pages) {
 	memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
 }
 
-
 /****************************************************************************/
 /* 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 */
-static u16 *jpeg_quantisation_tables(int *size, int quality) {
-	static u16 tables0[] = {
+static u16 *jpeg_quantisation_tables(int *length, int quality)
+{
+	static u16 jpeg_tables[][70] = { {
 		0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 		0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 		0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
@@ -211,8 +216,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		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,
 		0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
@@ -223,8 +228,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		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,
 		0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
@@ -235,8 +240,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
 		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,
 		0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
@@ -247,8 +252,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
 		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,
 		0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
@@ -259,8 +264,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
 		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,
 		0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
@@ -271,8 +276,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
 		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,
 		0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
@@ -283,8 +288,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
 		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,
 		0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
@@ -295,8 +300,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
 		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,
 		0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
@@ -307,8 +312,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
 		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,
 		0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
@@ -319,8 +324,8 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
 		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,
 		0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
@@ -331,52 +336,21 @@ static u16 *jpeg_quantisation_tables(int *size, int quality) {
 		0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 		0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 		0x0101, 0x0101, 0xff01,
-	};
+	} };
 
-	switch (quality) {
-	case 0:
-		*size = sizeof(tables0);
-		return tables0;
-	case 1:
-		*size = sizeof(tables1);
-		return tables1;
-	case 2:
-		*size = sizeof(tables2);
-		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;
+	if (quality < 0 || quality > 10) {
+		printk(KERN_WARNING
+		       "meye: invalid quality level %d - using 8\n", quality);
+		quality = 8;
 	}
-	return NULL;
+
+	*length = ARRAY_SIZE(jpeg_tables[quality]);
+	return jpeg_tables[quality];
 }
 
 /* return a generic set of huffman tables */
-static u16 *jpeg_huffman_tables(int *size) {
+static u16 *jpeg_huffman_tables(int *length)
+{
 	static u16 tables[] = {
 		0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
 		0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
@@ -410,7 +384,7 @@ static u16 *jpeg_huffman_tables(int *size) {
 		0xFF0B
 	};
 
-	*size = sizeof(tables);
+	*length = ARRAY_SIZE(tables);
 	return tables;
 }
 
@@ -419,23 +393,27 @@ static u16 *jpeg_huffman_tables(int *size) {
 /****************************************************************************/
 
 /* returns the horizontal capture size */
-static inline int mchip_hsize(void) {
+static inline int mchip_hsize(void)
+{
 	return meye.params.subsample ? 320 : 640;
 }
 
 /* returns the vertical capture size */
-static inline int mchip_vsize(void) {
+static inline int mchip_vsize(void)
+{
 	return meye.params.subsample ? 240 : 480;
 }
 
 /* waits for a register to be available */
-static void mchip_sync(int reg) {
+static void mchip_sync(int reg)
+{
 	u32 status;
 	int i;
 
 	if (reg == MCHIP_MM_FIFO_DATA) {
 		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)) {
 				printk(KERN_WARNING "meye: fifo not ready\n");
 				return;
@@ -444,8 +422,7 @@ static void mchip_sync(int reg) {
 				return;
 			udelay(1);
 		}
-	}
-	else if (reg > 0x80) {
+	} else if (reg > 0x80) {
 		u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
 					 : MCHIP_HIC_STATUS_VRJ_RDY;
 		for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
@@ -454,26 +431,30 @@ static void mchip_sync(int reg) {
 				return;
 			udelay(1);
 		}
-	}
-	else
+	} else
 		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 */
-static inline void mchip_set(int reg, u32 v) {
+static inline void mchip_set(int reg, u32 v)
+{
 	mchip_sync(reg);
 	writel(v, meye.mchip_mmregs + reg);
 }
 
 /* get the register value */
-static inline u32 mchip_read(int reg) {
+static inline u32 mchip_read(int reg)
+{
 	mchip_sync(reg);
 	return readl(meye.mchip_mmregs + reg);
 }
 
 /* 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;
 	while (--n && mchip_read(reg) != v)
 		udelay(1);
@@ -481,7 +462,8 @@ static inline int mchip_delay(u32 reg, u32 v) {
 }
 
 /* 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_XRANGE, mchip_hsize());
 	mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
@@ -491,29 +473,31 @@ static void mchip_subsample(void) {
 }
 
 /* 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);
 }
 
 /* load some huffman and quantisation tables into the VRJ chip ready
    for JPEG compression */
-static void mchip_load_tables(void) {
+static void mchip_load_tables(void)
+{
 	int i;
-	int size;
+	int length;
 	u16 *tables;
 
-	tables = jpeg_huffman_tables(&size);
-	for (i = 0; i < size / 2; i++)
+	tables = jpeg_huffman_tables(&length);
+	for (i = 0; i < length; i++)
 		writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
 
-	tables = jpeg_quantisation_tables(&size, meye.params.quality);
-	for (i = 0; i < size / 2; i++)
+	tables = jpeg_quantisation_tables(&length, meye.params.quality);
+	for (i = 0; i < length; i++)
 		writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
 }
 
 /* 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_SIGNAL_ACTIVE_LEVEL, 0x1f);
 	mchip_set(MCHIP_VRJ_PDAT_USE, 1);
@@ -536,7 +520,8 @@ static void mchip_vrj_setup(u8 mode) {
 }
 
 /* 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;
 
 	mchip_set(MCHIP_MM_PT_ADDR, dma_addr);
@@ -546,7 +531,8 @@ static void mchip_dma_setup(u32 dma_addr) {
 }
 
 /* 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 (ptable_alloc())
 			return -1;
@@ -554,7 +540,8 @@ static int mchip_dma_alloc(void) {
 }
 
 /* frees the DMA buffer */
-static void mchip_dma_free(void) {
+static void mchip_dma_free(void)
+{
 	if (meye.mchip_dmahandle) {
 		mchip_dma_setup(0);
 		ptable_free();
@@ -563,7 +550,8 @@ static void mchip_dma_free(void) {
 
 /* stop any existing HIC action and wait for any dma to complete then
    reset the dma engine */
-static void mchip_hic_stop(void) {
+static void mchip_hic_stop(void)
+{
 	int i, j;
 
 	meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
@@ -573,7 +561,8 @@ static void mchip_hic_stop(void) {
 		mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
 		mchip_delay(MCHIP_HIC_CMD, 0);
 		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;
 			msleep(1);
 		}
@@ -590,7 +579,8 @@ static void mchip_hic_stop(void) {
 /****************************************************************************/
 
 /* get the next ready frame from the dma engine */
-static u32 mchip_get_frame(void) {
+static u32 mchip_get_frame(void)
+{
 	u32 v;
 
 	v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
@@ -598,7 +588,8 @@ static u32 mchip_get_frame(void) {
 }
 
 /* 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);
 	meye.mchip_fnum++;
 	meye.mchip_fnum %= 4;
@@ -606,17 +597,18 @@ static void mchip_free_frame(void) {
 
 /* read one frame from the framebuffer assuming it was captured using
    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;
 
 	pt_id = (v >> 17) & 0x3FF;
 
 	ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
-
 }
 
 /* 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 fsize;
 	int i;
@@ -639,7 +631,6 @@ static int mchip_comp_read_frame(u32 v, u8 *buf, int size) {
 
 	ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
 
-
 #ifdef MEYE_JPEG_CORRECTION
 
 	/* Some mchip generated jpeg frames are incorrect. In most
@@ -661,7 +652,8 @@ static int mchip_comp_read_frame(u32 v, u8 *buf, int size) {
 }
 
 /* take a picture into SDRAM */
-static void mchip_take_picture(void) {
+static void mchip_take_picture(void)
+{
 	int i;
 
 	mchip_hic_stop();
@@ -681,7 +673,8 @@ static void mchip_take_picture(void) {
 }
 
 /* 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;
 	int i;
 
@@ -694,7 +687,7 @@ static void mchip_get_picture(u8 *buf, int bufsize) {
 			break;
 		msleep(1);
 	}
-	for (i = 0; i < 4 ; ++i) {
+	for (i = 0; i < 4; ++i) {
 		v = mchip_get_frame();
 		if (v & MCHIP_MM_FIR_RDY) {
 			mchip_cont_read_frame(v, buf, bufsize);
@@ -705,7 +698,8 @@ static void mchip_get_picture(u8 *buf, int bufsize) {
 }
 
 /* start continuous dma capture */
-static void mchip_continuous_start(void) {
+static void mchip_continuous_start(void)
+{
 	mchip_hic_stop();
 	mchip_subsample();
 	mchip_set_framerate();
@@ -720,7 +714,8 @@ static void mchip_continuous_start(void) {
 }
 
 /* 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;
 	int len = -1, i;
 
@@ -737,7 +732,7 @@ static int mchip_compress_frame(u8 *buf, int bufsize) {
 		msleep(1);
 	}
 
-	for (i = 0; i < 4 ; ++i) {
+	for (i = 0; i < 4; ++i) {
 		v = mchip_get_frame();
 		if (v & MCHIP_MM_FIR_RDY) {
 			len = mchip_comp_read_frame(v, buf, bufsize);
@@ -750,7 +745,8 @@ static int mchip_compress_frame(u8 *buf, int bufsize) {
 
 #if 0
 /* 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);
 	udelay(50);
 
@@ -764,7 +760,8 @@ static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize) {
 #endif
 
 /* start continuous compressed capture */
-static void mchip_cont_compression_start(void) {
+static void mchip_cont_compression_start(void)
+{
 	mchip_hic_stop();
 	mchip_vrj_setup(0x3f);
 	mchip_subsample();
@@ -782,6 +779,7 @@ static void mchip_cont_compression_start(void) {
 /****************************************************************************/
 /* Interrupt handling                                                       */
 /****************************************************************************/
+
 static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs)
 {
 	u32 v;
@@ -842,10 +840,11 @@ static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs)
 /* 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;
 
-	err = video_exclusive_open(inode,file);
+	err = video_exclusive_open(inode, file);
 	if (err < 0)
 		return err;
 
@@ -853,7 +852,7 @@ static int meye_open(struct inode *inode, struct file *file) {
 
 	if (mchip_dma_alloc()) {
 		printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
-		video_exclusive_release(inode,file);
+		video_exclusive_release(inode, file);
 		return -ENOBUFS;
 	}
 
@@ -861,20 +860,20 @@ static int meye_open(struct inode *inode, struct file *file) {
 		meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
 	kfifo_reset(meye.grabq);
 	kfifo_reset(meye.doneq);
-
 	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_dma_free();
-	video_exclusive_release(inode,file);
+	video_exclusive_release(inode, file);
 	return 0;
 }
 
 static int meye_do_ioctl(struct inode *inode, struct file *file,
-			 unsigned int cmd, void *arg) {
-
+			 unsigned int cmd, void *arg)
+{
 	switch (cmd) {
 
 	case VIDIOCGCAP: {
@@ -988,14 +987,12 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
 				meye.params.subsample = 0;
 				restart = 1;
 			}
-		}
-		else if (vm->width == 320 && vm->height == 240) {
+		} else if (vm->width == 320 && vm->height == 240) {
 			if (!meye.params.subsample) {
 				meye.params.subsample = 1;
 				restart = 1;
 			}
-		}
-		else {
+		} else {
 			up(&meye.lock);
 			return -EINVAL;
 		}
@@ -1695,7 +1692,8 @@ static struct vm_operations_struct meye_vm_ops = {
 	.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 size = vma->vm_end - vma->vm_start;
 	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
@@ -1802,7 +1800,8 @@ static int meye_resume(struct pci_dev *pdev)
 #endif
 
 static int __devinit meye_probe(struct pci_dev *pcidev,
-		                const struct pci_device_id *ent) {
+				const struct pci_device_id *ent)
+{
 	int ret = -EBUSY;
 	unsigned long mchip_adr;
 	u8 revision;
@@ -1897,8 +1896,8 @@ static int __devinit meye_probe(struct pci_dev *pcidev,
 	msleep(1);
 	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");
 		goto outvideoreg;
 	}
@@ -1956,8 +1955,8 @@ static int __devinit meye_probe(struct pci_dev *pcidev,
 	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);
 
 	mchip_hic_stop();
@@ -2010,20 +2009,23 @@ static struct pci_driver meye_driver = {
 #endif
 };
 
-static int __init meye_init(void) {
+static int __init meye_init(void)
+{
 	gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
 	if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
 		gbufsize = MEYE_MAX_BUFSIZE;
 	gbufsize = PAGE_ALIGN(gbufsize);
-	printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
-	       gbuffers, gbufsize/1024, gbuffers*gbufsize/1024);
-	return pci_module_init(&meye_driver);
+	printk(KERN_INFO "meye: using %d buffers with %dk (%dk total)"
+			 "for capture\n",
+			 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);
 }
 
-/* Module entry points */
 module_init(meye_init);
 module_exit(meye_exit);

drivers/media/video/meye.h

 /*
  * 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>
  *
@@ -77,7 +77,7 @@
 #define MCHIP_MM_INTA_PCI_ERR		0x00000040	/* PCI error */
 #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 */
 #define MCHIP_NB_PAGES			1024		/* pages for display */
 #define MCHIP_NB_PAGES_MJPEG		256		/* pages for mjpeg */
@@ -288,33 +288,25 @@ struct meye_grab_buffer {
 
 /* Motion Eye device structure */
 struct meye {
-
-	/* mchip related */
 	struct pci_dev *mchip_dev;	/* pci device */
 	u8 mchip_irq;			/* irq */
 	u8 mchip_mode;			/* actual mchip mode: HIC_MODE... */
 	u8 mchip_fnum;			/* current mchip frame number */
-
 	unsigned char *mchip_mmregs;	/* mchip: memory mapped registers */
 	u8 *mchip_ptable[MCHIP_NB_PAGES];/* mchip: ptable */
 	dma_addr_t *mchip_ptable_toc;	/* mchip: ptable toc */
 	dma_addr_t mchip_dmahandle;	/* mchip: dma handle to ptable toc */
-
 	unsigned char *grab_fbuffer;	/* capture framebuffer */
 	unsigned char *grab_temp;	/* temporary buffer */
 					/* list of buffers */
 	struct meye_grab_buffer grab_buffer[MEYE_MAX_BUFNBRS];
 	int vma_use_count[MEYE_MAX_BUFNBRS]; /* mmap count */
-
-	/* other */
 	struct semaphore lock;		/* semaphore for open/mmap... */
-
 	struct kfifo *grabq;		/* queue for buffers to be grabbed */
 	spinlock_t grabq_lock;		/* lock protecting the queue */
 	struct kfifo *doneq;		/* queue for grabbed buffers */
 	spinlock_t doneq_lock;		/* lock protecting the queue */
 	wait_queue_head_t proc_list;	/* wait queue */
-
 	struct video_device *video_dev;	/* video device parameters */
 	struct video_picture picture;	/* video picture parameters */
 	struct meye_params params;	/* additional parameters */