2 * Motion Eye video4linux driver for Sony Vaio PictureBook
4 * Copyright (C) 2001-2003 Stelian Pop <stelian@popies.net>
6 * Copyright (C) 2001-2002 AlcĂ´ve <www.alcove.com>
8 * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
10 * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
12 * Some parts borrowed from various video4linux drivers, especially
13 * bttv-driver.c and zoran.c, see original files for credits.
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 #include <linux/config.h>
30 #include <linux/module.h>
31 #include <linux/pci.h>
32 #include <linux/sched.h>
33 #include <linux/init.h>
34 #include <linux/videodev.h>
35 #include <asm/uaccess.h>
37 #include <linux/delay.h>
38 #include <linux/interrupt.h>
39 #include <linux/vmalloc.h>
42 #include "linux/meye.h"
44 /* driver structure - only one possible */
45 static struct meye meye;
46 /* number of grab buffers */
47 static unsigned int gbuffers = 2;
48 /* size of a grab buffer */
49 static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
50 /* /dev/videoX registration number */
51 static int video_nr = -1;
53 /****************************************************************************/
55 /****************************************************************************/
58 static inline void meye_initq(struct meye_queue *queue) {
59 queue->head = queue->tail = 0;
61 queue->s_lock = (spinlock_t)SPIN_LOCK_UNLOCKED;
62 init_waitqueue_head(&queue->proc_list);
65 /* Pulls an element from the queue */
66 static inline int meye_pullq(struct meye_queue *queue) {
70 spin_lock_irqsave(&queue->s_lock, flags);
72 spin_unlock_irqrestore(&queue->s_lock, flags);
75 result = queue->buf[queue->head];
77 queue->head &= (MEYE_QUEUE_SIZE - 1);
79 spin_unlock_irqrestore(&queue->s_lock, flags);
83 /* Pushes an element into the queue */
84 static inline void meye_pushq(struct meye_queue *queue, int element) {
87 spin_lock_irqsave(&queue->s_lock, flags);
88 if (queue->len == MEYE_QUEUE_SIZE) {
89 /* remove the first element */
91 queue->head &= (MEYE_QUEUE_SIZE - 1);
94 queue->buf[queue->tail] = element;
96 queue->tail &= (MEYE_QUEUE_SIZE - 1);
99 spin_unlock_irqrestore(&queue->s_lock, flags);
102 /* Tests if the queue is empty */
103 static inline int meye_emptyq(struct meye_queue *queue, int *elem) {
107 spin_lock_irqsave(&queue->s_lock, flags);
108 result = (queue->len == 0);
110 *elem = queue->buf[queue->head];
111 spin_unlock_irqrestore(&queue->s_lock, flags);
115 /****************************************************************************/
116 /* Memory allocation routines (stolen from bttv-driver.c) */
117 /****************************************************************************/
119 /* Here we want the physical address of the memory.
120 * This is used when initializing the contents of the area.
122 static inline unsigned long kvirt_to_pa(unsigned long adr) {
123 unsigned long kva, ret;
125 kva = (unsigned long) page_address(vmalloc_to_page((void *)adr));
126 kva |= adr & (PAGE_SIZE-1); /* restore the offset */
131 static void *rvmalloc(unsigned long size) {
135 size = PAGE_ALIGN(size);
136 mem = vmalloc_32(size);
138 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
139 adr = (unsigned long)mem;
141 SetPageReserved(vmalloc_to_page((void *)adr));
149 static void rvfree(void * mem, unsigned long size) {
153 adr = (unsigned long) mem;
154 while ((long) size > 0) {
155 ClearPageReserved(vmalloc_to_page((void *)adr));
164 * return a page table pointing to N pages of locked memory
166 * NOTE: The meye device expects dma_addr_t size to be 32 bits
167 * (the toc must be exactly 1024 entries each of them being 4 bytes
168 * in size, the whole result being 4096 bytes). We're using here
169 * dma_addr_t for correctness but the compilation of this driver is
170 * disabled for HIGHMEM64G=y, where sizeof(dma_addr_t) != 4
172 static int ptable_alloc(void) {
176 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
178 meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
180 &meye.mchip_dmahandle,
182 if (!meye.mchip_ptable_toc) {
183 meye.mchip_dmahandle = 0;
187 pt = meye.mchip_ptable_toc;
188 for (i = 0; i < MCHIP_NB_PAGES; i++) {
189 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
193 if (!meye.mchip_ptable[i]) {
195 pt = meye.mchip_ptable_toc;
196 for (j = 0; j < i; ++j) {
197 dma_free_coherent(&meye.mchip_dev->dev,
199 meye.mchip_ptable[j], *pt);
202 dma_free_coherent(&meye.mchip_dev->dev,
204 meye.mchip_ptable_toc,
205 meye.mchip_dmahandle);
206 meye.mchip_ptable_toc = NULL;
207 meye.mchip_dmahandle = 0;
215 static void ptable_free(void) {
219 pt = meye.mchip_ptable_toc;
220 for (i = 0; i < MCHIP_NB_PAGES; i++) {
221 if (meye.mchip_ptable[i])
222 dma_free_coherent(&meye.mchip_dev->dev,
224 meye.mchip_ptable[i], *pt);
228 if (meye.mchip_ptable_toc)
229 dma_free_coherent(&meye.mchip_dev->dev,
231 meye.mchip_ptable_toc,
232 meye.mchip_dmahandle);
234 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
235 meye.mchip_ptable_toc = NULL;
236 meye.mchip_dmahandle = 0;
239 /* copy data from ptable into buf */
240 static void ptable_copy(u8 *buf, int start, int size, int pt_pages) {
243 for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
244 memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
245 if (start >= pt_pages)
248 memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
252 /****************************************************************************/
253 /* JPEG tables at different qualities to load into the VRJ chip */
254 /****************************************************************************/
256 /* return a set of quantisation tables based on a quality from 1 to 10 */
257 static u16 *jpeg_quantisation_tables(int *size, int quality) {
258 static u16 tables0[] = {
259 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
260 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
261 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
262 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
263 0xffff, 0xffff, 0xffff,
264 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
265 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
266 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
267 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
268 0xffff, 0xffff, 0xffff,
270 static u16 tables1[] = {
271 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
272 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
273 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
274 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
275 0xffff, 0xffff, 0xffff,
276 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
277 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
278 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
279 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
280 0xffff, 0xffff, 0xffff,
282 static u16 tables2[] = {
283 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
284 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
285 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
286 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
287 0xe6ff, 0xfffd, 0xfff8,
288 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
289 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
290 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
291 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
292 0xf8f8, 0xf8f8, 0xfff8,
294 static u16 tables3[] = {
295 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
296 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
297 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
298 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
299 0x99c7, 0xaba8, 0xffa4,
300 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
301 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
302 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
303 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
304 0xa4a4, 0xa4a4, 0xffa4,
306 static u16 tables4[] = {
307 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
308 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
309 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
310 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
311 0x7396, 0x817e, 0xff7c,
312 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
313 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
314 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
315 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
316 0x7c7c, 0x7c7c, 0xff7c,
318 static u16 tables5[] = {
319 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
320 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
321 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
322 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
323 0x5c78, 0x6765, 0xff63,
324 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
325 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
326 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
327 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
328 0x6363, 0x6363, 0xff63,
330 static u16 tables6[] = {
331 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
332 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
333 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
334 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
335 0x4a60, 0x5251, 0xff4f,
336 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
337 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
338 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
339 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
340 0x4f4f, 0x4f4f, 0xff4f,
342 static u16 tables7[] = {
343 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
344 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
345 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
346 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
347 0x3748, 0x3e3d, 0xff3b,
348 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
349 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
350 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
351 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
352 0x3b3b, 0x3b3b, 0xff3b,
354 static u16 tables8[] = {
355 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
356 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
357 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
358 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
359 0x2530, 0x2928, 0xff28,
360 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
361 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
362 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
363 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
364 0x2828, 0x2828, 0xff28,
366 static u16 tables9[] = {
367 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
368 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
369 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
370 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
371 0x1218, 0x1514, 0xff14,
372 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
373 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
374 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
375 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
376 0x1414, 0x1414, 0xff14,
378 static u16 tables10[] = {
379 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
380 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
381 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
382 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
383 0x0101, 0x0101, 0xff01,
384 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
385 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
386 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
387 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
388 0x0101, 0x0101, 0xff01,
393 *size = sizeof(tables0);
396 *size = sizeof(tables1);
399 *size = sizeof(tables2);
402 *size = sizeof(tables3);
405 *size = sizeof(tables4);
408 *size = sizeof(tables5);
411 *size = sizeof(tables6);
414 *size = sizeof(tables7);
417 *size = sizeof(tables8);
420 *size = sizeof(tables9);
423 *size = sizeof(tables10);
426 printk(KERN_WARNING "meye: invalid quality level %d - using 8\n", quality);
427 *size = sizeof(tables8);
433 /* return a generic set of huffman tables */
434 static u16 *jpeg_huffman_tables(int *size) {
435 static u16 tables[] = {
436 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
437 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
438 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
439 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
440 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
441 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
442 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
443 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
444 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
445 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
446 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
447 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
448 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
449 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
450 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
451 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
452 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
453 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
454 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
455 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
456 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
457 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
458 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
459 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
460 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
461 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
463 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
464 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
468 *size = sizeof(tables);
472 /****************************************************************************/
473 /* MCHIP low-level functions */
474 /****************************************************************************/
476 /* returns the horizontal capture size */
477 static inline int mchip_hsize(void) {
478 return meye.params.subsample ? 320 : 640;
481 /* returns the vertical capture size */
482 static inline int mchip_vsize(void) {
483 return meye.params.subsample ? 240 : 480;
486 /* waits for a register to be available */
487 static void mchip_sync(int reg) {
491 if (reg == MCHIP_MM_FIFO_DATA) {
492 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
493 status = readl(meye.mchip_mmregs + MCHIP_MM_FIFO_STATUS);
494 if (!(status & MCHIP_MM_FIFO_WAIT)) {
495 printk(KERN_WARNING "meye: fifo not ready\n");
498 if (status & MCHIP_MM_FIFO_READY)
503 else if (reg > 0x80) {
504 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
505 : MCHIP_HIC_STATUS_VRJ_RDY;
506 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
507 status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
515 printk(KERN_WARNING "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n", reg, status);
518 /* sets a value into the register */
519 static inline void mchip_set(int reg, u32 v) {
521 writel(v, meye.mchip_mmregs + reg);
524 /* get the register value */
525 static inline u32 mchip_read(int reg) {
527 return readl(meye.mchip_mmregs + reg);
530 /* wait for a register to become a particular value */
531 static inline int mchip_delay(u32 reg, u32 v) {
533 while (--n && mchip_read(reg) != v)
538 /* setup subsampling */
539 static void mchip_subsample(void) {
540 mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
541 mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
542 mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
543 mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
544 mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
545 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
548 /* set the framerate into the mchip */
549 static void mchip_set_framerate(void) {
550 mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
553 /* load some huffman and quantisation tables into the VRJ chip ready
554 for JPEG compression */
555 static void mchip_load_tables(void) {
560 tables = jpeg_huffman_tables(&size);
561 for (i = 0; i < size / 2; i++)
562 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
564 tables = jpeg_quantisation_tables(&size, meye.params.quality);
565 for (i = 0; i < size / 2; i++)
566 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
569 /* setup the VRJ parameters in the chip */
570 static void mchip_vrj_setup(u8 mode) {
572 mchip_set(MCHIP_VRJ_BUS_MODE, 5);
573 mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
574 mchip_set(MCHIP_VRJ_PDAT_USE, 1);
575 mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
576 mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
577 mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
578 mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
579 mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
580 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
581 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
582 mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
583 mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
584 mchip_set(MCHIP_VRJ_SOF1, 0x601);
585 mchip_set(MCHIP_VRJ_SOF2, 0x1502);
586 mchip_set(MCHIP_VRJ_SOF3, 0x1503);
587 mchip_set(MCHIP_VRJ_SOF4, 0x1596);
588 mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
593 /* sets the DMA parameters into the chip */
594 static void mchip_dma_setup(u32 dma_addr) {
597 mchip_set(MCHIP_MM_PT_ADDR, dma_addr);
598 for (i = 0; i < 4; i++)
599 mchip_set(MCHIP_MM_FIR(i), 0);
603 /* setup for DMA transfers - also zeros the framebuffer */
604 static int mchip_dma_alloc(void) {
605 if (!meye.mchip_dmahandle)
611 /* frees the DMA buffer */
612 static void mchip_dma_free(void) {
613 if (meye.mchip_dmahandle) {
619 /* stop any existing HIC action and wait for any dma to complete then
620 reset the dma engine */
621 static void mchip_hic_stop(void) {
624 meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
625 if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
627 for (i = 0; i < 20; ++i) {
628 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
629 mchip_delay(MCHIP_HIC_CMD, 0);
630 for (j = 0; j < 100; ++j) {
631 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
635 printk(KERN_ERR "meye: need to reset HIC!\n");
637 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
640 printk(KERN_ERR "meye: resetting HIC hanged!\n");
643 /****************************************************************************/
644 /* MCHIP frame processing functions */
645 /****************************************************************************/
647 /* get the next ready frame from the dma engine */
648 static u32 mchip_get_frame(void) {
651 v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
655 /* frees the current frame from the dma engine */
656 static void mchip_free_frame(void) {
657 mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
659 meye.mchip_fnum %= 4;
662 /* read one frame from the framebuffer assuming it was captured using
663 a uncompressed transfer */
664 static void mchip_cont_read_frame(u32 v, u8 *buf, int size) {
667 pt_id = (v >> 17) & 0x3FF;
669 ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
673 /* read a compressed frame from the framebuffer */
674 static int mchip_comp_read_frame(u32 v, u8 *buf, int size) {
675 int pt_start, pt_end, trailer;
679 pt_start = (v >> 19) & 0xFF;
680 pt_end = (v >> 11) & 0xFF;
681 trailer = (v >> 1) & 0x3FF;
683 if (pt_end < pt_start)
684 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
685 pt_end * PAGE_SIZE + trailer * 4;
687 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
690 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
695 ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
698 #ifdef MEYE_JPEG_CORRECTION
700 /* Some mchip generated jpeg frames are incorrect. In most
701 * (all ?) of those cases, the final EOI (0xff 0xd9) marker
702 * is not present at the end of the frame.
704 * Since adding the final marker is not enough to restore
705 * the jpeg integrity, we drop the frame.
708 for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
710 if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
718 /* take a picture into SDRAM */
719 static void mchip_take_picture(void) {
724 mchip_dma_setup(meye.mchip_dmahandle);
726 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
727 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
729 mchip_delay(MCHIP_HIC_CMD, 0);
731 for (i = 0; i < 100; ++i) {
732 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
738 /* dma a previously taken picture into a buffer */
739 static void mchip_get_picture(u8 *buf, int bufsize) {
743 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
744 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
746 mchip_delay(MCHIP_HIC_CMD, 0);
747 for (i = 0; i < 100; ++i) {
748 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
752 for (i = 0; i < 4 ; ++i) {
753 v = mchip_get_frame();
754 if (v & MCHIP_MM_FIR_RDY) {
755 mchip_cont_read_frame(v, buf, bufsize);
762 /* start continuous dma capture */
763 static void mchip_continuous_start(void) {
766 mchip_set_framerate();
767 mchip_dma_setup(meye.mchip_dmahandle);
769 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
771 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
772 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
774 mchip_delay(MCHIP_HIC_CMD, 0);
777 /* compress one frame into a buffer */
778 static int mchip_compress_frame(u8 *buf, int bufsize) {
782 mchip_vrj_setup(0x3f);
785 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
786 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
788 mchip_delay(MCHIP_HIC_CMD, 0);
789 for (i = 0; i < 100; ++i) {
790 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
795 for (i = 0; i < 4 ; ++i) {
796 v = mchip_get_frame();
797 if (v & MCHIP_MM_FIR_RDY) {
798 len = mchip_comp_read_frame(v, buf, bufsize);
807 /* uncompress one image into a buffer */
808 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize) {
809 mchip_vrj_setup(0x3f);
812 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
813 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
815 mchip_delay(MCHIP_HIC_CMD, 0);
817 return mchip_comp_read_frame(buf, bufsize);
821 /* start continuous compressed capture */
822 static void mchip_cont_compression_start(void) {
824 mchip_vrj_setup(0x3f);
826 mchip_set_framerate();
827 mchip_dma_setup(meye.mchip_dmahandle);
829 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
831 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
832 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
834 mchip_delay(MCHIP_HIC_CMD, 0);
837 /****************************************************************************/
838 /* Interrupt handling */
839 /****************************************************************************/
841 static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs) {
844 v = mchip_read(MCHIP_MM_INTA);
847 v = mchip_get_frame();
848 if (!(v & MCHIP_MM_FIR_RDY))
850 switch (meye.mchip_mode) {
852 case MCHIP_HIC_MODE_CONT_OUT:
853 if (!meye_emptyq(&meye.grabq, NULL)) {
854 int nr = meye_pullq(&meye.grabq);
855 mchip_cont_read_frame(
857 meye.grab_fbuffer + gbufsize * nr,
858 mchip_hsize() * mchip_vsize() * 2);
859 meye.grab_buffer[nr].state = MEYE_BUF_DONE;
860 wake_up_interruptible(&meye.grabq.proc_list);
864 case MCHIP_HIC_MODE_CONT_COMP:
865 if (!meye_emptyq(&meye.grabq, &reqnr)) {
867 size = mchip_comp_read_frame(
869 meye.grab_fbuffer + gbufsize * reqnr,
873 reqnr = meye_pullq(&meye.grabq);
874 meye.grab_buffer[reqnr].size = size;
875 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
876 wake_up_interruptible(&meye.grabq.proc_list);
881 /* do not free frame, since it can be a snap */
890 /****************************************************************************/
891 /* video4linux integration */
892 /****************************************************************************/
894 static int meye_open(struct inode *inode, struct file *file) {
897 err = video_exclusive_open(inode,file);
901 if (mchip_dma_alloc()) {
902 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
903 video_exclusive_release(inode,file);
907 meye_initq(&meye.grabq);
908 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
909 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
913 static int meye_release(struct inode *inode, struct file *file) {
916 video_exclusive_release(inode,file);
920 static int meye_do_ioctl(struct inode *inode, struct file *file,
921 unsigned int cmd, void *arg) {
926 struct video_capability *b = arg;
927 strcpy(b->name,meye.video_dev->name);
928 b->type = VID_TYPE_CAPTURE;
939 struct video_channel *v = arg;
942 v->type = VIDEO_TYPE_CAMERA;
945 strcpy(v->name,"Camera");
950 struct video_channel *v = arg;
957 struct video_picture *p = arg;
963 struct video_picture *p = arg;
966 if (p->palette != VIDEO_PALETTE_YUV422)
969 sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS,
970 p->brightness >> 10);
971 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE,
973 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR,
975 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST,
985 if (*i < 0 || *i >= gbuffers)
988 switch (meye.grab_buffer[*i].state) {
990 case MEYE_BUF_UNUSED:
993 if (wait_event_interruptible(meye.grabq.proc_list,
994 (meye.grab_buffer[*i].state != MEYE_BUF_USING)))
998 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
1003 case VIDIOCMCAPTURE: {
1004 struct video_mmap *vm = arg;
1007 if (vm->frame >= gbuffers || vm->frame < 0)
1009 if (vm->format != VIDEO_PALETTE_YUV422)
1011 if (vm->height * vm->width * 2 > gbufsize)
1013 if (!meye.grab_fbuffer)
1015 if (meye.grab_buffer[vm->frame].state != MEYE_BUF_UNUSED)
1019 if (vm->width == 640 && vm->height == 480) {
1020 if (meye.params.subsample) {
1021 meye.params.subsample = 0;
1025 else if (vm->width == 320 && vm->height == 240) {
1026 if (!meye.params.subsample) {
1027 meye.params.subsample = 1;
1036 if (restart || meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT)
1037 mchip_continuous_start();
1038 meye.grab_buffer[vm->frame].state = MEYE_BUF_USING;
1039 meye_pushq(&meye.grabq, vm->frame);
1045 struct video_mbuf *vm = arg;
1048 memset(vm, 0 , sizeof(*vm));
1049 vm->size = gbufsize * gbuffers;
1050 vm->frames = gbuffers;
1051 for (i = 0; i < gbuffers; i++)
1052 vm->offsets[i] = i * gbufsize;
1056 case MEYEIOC_G_PARAMS: {
1057 struct meye_params *p = arg;
1062 case MEYEIOC_S_PARAMS: {
1063 struct meye_params *jp = arg;
1064 if (jp->subsample > 1)
1066 if (jp->quality > 10)
1068 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
1070 if (jp->framerate > 31)
1073 if (meye.params.subsample != jp->subsample ||
1074 meye.params.quality != jp->quality)
1075 mchip_hic_stop(); /* need restart */
1077 sonypi_camera_command(SONYPI_COMMAND_SETCAMERASHARPNESS,
1078 meye.params.sharpness);
1079 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAAGC,
1081 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAPICTURE,
1082 meye.params.picture);
1087 case MEYEIOC_QBUF_CAPT: {
1090 if (!meye.grab_fbuffer)
1092 if (*nb >= gbuffers)
1099 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
1102 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
1103 mchip_cont_compression_start();
1104 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
1105 meye_pushq(&meye.grabq, *nb);
1110 case MEYEIOC_SYNC: {
1113 if (*i < 0 || *i >= gbuffers)
1116 switch (meye.grab_buffer[*i].state) {
1118 case MEYE_BUF_UNUSED:
1120 case MEYE_BUF_USING:
1121 if (wait_event_interruptible(meye.grabq.proc_list,
1122 (meye.grab_buffer[*i].state != MEYE_BUF_USING)))
1126 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
1128 *i = meye.grab_buffer[*i].size;
1132 case MEYEIOC_STILLCAPT: {
1134 if (!meye.grab_fbuffer)
1136 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1139 meye.grab_buffer[0].state = MEYE_BUF_USING;
1140 mchip_take_picture();
1143 mchip_hsize() * mchip_vsize() * 2);
1144 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1149 case MEYEIOC_STILLJCAPT: {
1152 if (!meye.grab_fbuffer)
1154 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1157 meye.grab_buffer[0].state = MEYE_BUF_USING;
1159 while (*len == -1) {
1160 mchip_take_picture();
1161 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1163 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1169 return -ENOIOCTLCMD;
1176 static int meye_ioctl(struct inode *inode, struct file *file,
1177 unsigned int cmd, unsigned long arg)
1179 return video_usercopy(inode, file, cmd, arg, meye_do_ioctl);
1182 static int meye_mmap(struct file *file, struct vm_area_struct *vma) {
1183 unsigned long start = vma->vm_start;
1184 unsigned long size = vma->vm_end - vma->vm_start;
1185 unsigned long page, pos;
1188 if (size > gbuffers * gbufsize) {
1192 if (!meye.grab_fbuffer) {
1193 /* lazy allocation */
1194 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1195 if (!meye.grab_fbuffer) {
1196 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1201 pos = (unsigned long)meye.grab_fbuffer;
1204 page = kvirt_to_pa(pos);
1205 if (remap_page_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1217 static struct file_operations meye_fops = {
1218 .owner = THIS_MODULE,
1220 .release = meye_release,
1222 .ioctl = meye_ioctl,
1223 .llseek = no_llseek,
1226 static struct video_device meye_template = {
1227 .owner = THIS_MODULE,
1229 .type = VID_TYPE_CAPTURE,
1230 .hardware = VID_HARDWARE_MEYE,
1232 .release = video_device_release,
1237 static int meye_suspend(struct pci_dev *pdev, u32 state)
1239 pci_save_state(pdev, meye.pm_state);
1240 meye.pm_mchip_mode = meye.mchip_mode;
1242 mchip_set(MCHIP_MM_INTA, 0x0);
1246 static int meye_resume(struct pci_dev *pdev)
1248 pci_restore_state(pdev, meye.pm_state);
1249 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1251 mchip_delay(MCHIP_HIC_CMD, 0);
1252 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1254 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1256 mchip_set(MCHIP_MM_PCI_MODE, 5);
1258 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1260 switch (meye.pm_mchip_mode) {
1261 case MCHIP_HIC_MODE_CONT_OUT:
1262 mchip_continuous_start();
1264 case MCHIP_HIC_MODE_CONT_COMP:
1265 mchip_cont_compression_start();
1272 static int __devinit meye_probe(struct pci_dev *pcidev,
1273 const struct pci_device_id *ent) {
1275 unsigned long mchip_adr;
1278 if (meye.mchip_dev != NULL) {
1279 printk(KERN_ERR "meye: only one device allowed!\n");
1284 meye.mchip_dev = pcidev;
1285 meye.video_dev = video_device_alloc();
1286 if (!meye.video_dev) {
1287 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1291 memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
1292 meye.video_dev->dev = &meye.mchip_dev->dev;
1294 sonypi_camera_command(SONYPI_COMMAND_SETCAMERA, 1);
1296 if ((ret = pci_enable_device(meye.mchip_dev))) {
1297 printk(KERN_ERR "meye: pci_enable_device failed\n");
1301 meye.mchip_irq = pcidev->irq;
1302 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1304 printk(KERN_ERR "meye: mchip has no device base address\n");
1308 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1309 pci_resource_len(meye.mchip_dev, 0),
1312 printk(KERN_ERR "meye: request_mem_region failed\n");
1316 pci_read_config_byte(meye.mchip_dev, PCI_REVISION_ID, &revision);
1318 pci_set_master(meye.mchip_dev);
1320 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1321 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1323 if ((ret = request_irq(meye.mchip_irq, meye_irq,
1324 SA_INTERRUPT | SA_SHIRQ, "meye", meye_irq))) {
1325 printk(KERN_ERR "meye: request_irq failed (ret=%d)\n", ret);
1329 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1330 if (!meye.mchip_mmregs) {
1331 printk(KERN_ERR "meye: ioremap failed\n");
1336 /* Ask the camera to perform a soft reset. */
1337 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1339 mchip_delay(MCHIP_HIC_CMD, 0);
1340 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1343 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1346 mchip_set(MCHIP_MM_PCI_MODE, 5);
1349 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1351 if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER, video_nr) < 0) {
1353 printk(KERN_ERR "meye: video_register_device failed\n");
1358 printk(KERN_INFO "meye: Motion Eye Camera Driver v%d.%d.\n",
1359 MEYE_DRIVER_MAJORVERSION,
1360 MEYE_DRIVER_MINORVERSION);
1361 printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1362 revision, mchip_adr, meye.mchip_irq);
1364 /* init all fields */
1365 init_MUTEX(&meye.lock);
1367 meye.picture.depth = 2;
1368 meye.picture.palette = VIDEO_PALETTE_YUV422;
1369 meye.picture.brightness = 32 << 10;
1370 meye.picture.hue = 32 << 10;
1371 meye.picture.colour = 32 << 10;
1372 meye.picture.contrast = 32 << 10;
1373 meye.picture.whiteness = 0;
1374 meye.params.subsample = 0;
1375 meye.params.quality = 7;
1376 meye.params.sharpness = 32;
1377 meye.params.agc = 48;
1378 meye.params.picture = 0;
1379 meye.params.framerate = 0;
1380 sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS, 32);
1381 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE, 32);
1382 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR, 32);
1383 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST, 32);
1384 sonypi_camera_command(SONYPI_COMMAND_SETCAMERASHARPNESS, 32);
1385 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAPICTURE, 0);
1386 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAAGC, 48);
1390 iounmap(meye.mchip_mmregs);
1392 free_irq(meye.mchip_irq, meye_irq);
1394 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1395 pci_resource_len(meye.mchip_dev, 0));
1397 pci_disable_device(meye.mchip_dev);
1399 video_device_release(meye.video_dev);
1400 meye.video_dev = NULL;
1402 sonypi_camera_command(SONYPI_COMMAND_SETCAMERA, 0);
1407 static void __devexit meye_remove(struct pci_dev *pcidev) {
1409 video_unregister_device(meye.video_dev);
1415 /* disable interrupts */
1416 mchip_set(MCHIP_MM_INTA, 0x0);
1418 free_irq(meye.mchip_irq, meye_irq);
1420 iounmap(meye.mchip_mmregs);
1422 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1423 pci_resource_len(meye.mchip_dev, 0));
1425 pci_disable_device(meye.mchip_dev);
1427 if (meye.grab_fbuffer)
1428 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1430 sonypi_camera_command(SONYPI_COMMAND_SETCAMERA, 0);
1432 printk(KERN_INFO "meye: removed\n");
1435 static struct pci_device_id meye_pci_tbl[] = {
1436 { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
1437 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1441 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1443 static struct pci_driver meye_driver = {
1445 .id_table = meye_pci_tbl,
1446 .probe = meye_probe,
1447 .remove = __devexit_p(meye_remove),
1449 .suspend = meye_suspend,
1450 .resume = meye_resume,
1454 static int __init meye_init_module(void) {
1457 if (gbuffers > MEYE_MAX_BUFNBRS)
1458 gbuffers = MEYE_MAX_BUFNBRS;
1459 if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1460 gbufsize = MEYE_MAX_BUFSIZE;
1461 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1462 gbuffers, gbufsize/1024, gbuffers*gbufsize/1024);
1463 return pci_module_init(&meye_driver);
1466 static void __exit meye_cleanup_module(void) {
1467 pci_unregister_driver(&meye_driver);
1471 static int __init meye_setup(char *str) {
1474 str = get_options(str, ARRAY_SIZE(ints), ints);
1488 __setup("meye=", meye_setup);
1491 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
1492 MODULE_DESCRIPTION("video4linux driver for the MotionEye camera");
1493 MODULE_LICENSE("GPL");
1495 MODULE_PARM(gbuffers,"i");
1496 MODULE_PARM_DESC(gbuffers,"number of capture buffers, default is 2 (32 max)");
1497 MODULE_PARM(gbufsize,"i");
1498 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 614400");
1499 MODULE_PARM(video_nr,"i");
1500 MODULE_PARM_DESC(video_nr,"video device to register (0=/dev/video0, etc)");
1502 /* Module entry points */
1503 module_init(meye_init_module);
1504 module_exit(meye_cleanup_module);