2 * Motion Eye video4linux driver for Sony Vaio PictureBook
4 * Copyright (C) 2001-2004 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/module.h>
30 #include <linux/pci.h>
31 #include <linux/sched.h>
32 #include <linux/init.h>
33 #include <linux/gfp.h>
34 #include <linux/videodev2.h>
35 #include <media/v4l2-common.h>
36 #include <media/v4l2-device.h>
37 #include <media/v4l2-ioctl.h>
38 #include <asm/uaccess.h>
40 #include <linux/delay.h>
41 #include <linux/interrupt.h>
42 #include <linux/vmalloc.h>
43 #include <linux/dma-mapping.h>
46 #include <linux/meye.h>
48 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
49 MODULE_DESCRIPTION("v4l2 driver for the MotionEye camera");
50 MODULE_LICENSE("GPL");
51 MODULE_VERSION(MEYE_DRIVER_VERSION
);
53 /* number of grab buffers */
54 static unsigned int gbuffers
= 2;
55 module_param(gbuffers
, int, 0444);
56 MODULE_PARM_DESC(gbuffers
, "number of capture buffers, default is 2 (32 max)");
58 /* size of a grab buffer */
59 static unsigned int gbufsize
= MEYE_MAX_BUFSIZE
;
60 module_param(gbufsize
, int, 0444);
61 MODULE_PARM_DESC(gbufsize
, "size of the capture buffers, default is 614400"
62 " (will be rounded up to a page multiple)");
64 /* /dev/videoX registration number */
65 static int video_nr
= -1;
66 module_param(video_nr
, int, 0444);
67 MODULE_PARM_DESC(video_nr
, "video device to register (0=/dev/video0, etc)");
69 /* driver structure - only one possible */
70 static struct meye meye
;
72 /****************************************************************************/
73 /* Memory allocation routines (stolen from bttv-driver.c) */
74 /****************************************************************************/
75 static void *rvmalloc(unsigned long size
)
80 size
= PAGE_ALIGN(size
);
81 mem
= vmalloc_32(size
);
84 adr
= (unsigned long) mem
;
86 SetPageReserved(vmalloc_to_page((void *)adr
));
94 static void rvfree(void * mem
, unsigned long size
)
99 adr
= (unsigned long) mem
;
100 while ((long) size
> 0) {
101 ClearPageReserved(vmalloc_to_page((void *)adr
));
110 * return a page table pointing to N pages of locked memory
112 * NOTE: The meye device expects DMA addresses on 32 bits, we build
113 * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
115 static int ptable_alloc(void)
120 memset(meye
.mchip_ptable
, 0, sizeof(meye
.mchip_ptable
));
122 /* give only 32 bit DMA addresses */
123 if (dma_set_mask(&meye
.mchip_dev
->dev
, DMA_BIT_MASK(32)))
126 meye
.mchip_ptable_toc
= dma_alloc_coherent(&meye
.mchip_dev
->dev
,
128 &meye
.mchip_dmahandle
,
130 if (!meye
.mchip_ptable_toc
) {
131 meye
.mchip_dmahandle
= 0;
135 pt
= meye
.mchip_ptable_toc
;
136 for (i
= 0; i
< MCHIP_NB_PAGES
; i
++) {
138 meye
.mchip_ptable
[i
] = dma_alloc_coherent(&meye
.mchip_dev
->dev
,
142 if (!meye
.mchip_ptable
[i
]) {
144 pt
= meye
.mchip_ptable_toc
;
145 for (j
= 0; j
< i
; ++j
) {
146 dma
= (dma_addr_t
) *pt
;
147 dma_free_coherent(&meye
.mchip_dev
->dev
,
149 meye
.mchip_ptable
[j
], dma
);
152 dma_free_coherent(&meye
.mchip_dev
->dev
,
154 meye
.mchip_ptable_toc
,
155 meye
.mchip_dmahandle
);
156 meye
.mchip_ptable_toc
= NULL
;
157 meye
.mchip_dmahandle
= 0;
166 static void ptable_free(void)
171 pt
= meye
.mchip_ptable_toc
;
172 for (i
= 0; i
< MCHIP_NB_PAGES
; i
++) {
173 dma_addr_t dma
= (dma_addr_t
) *pt
;
174 if (meye
.mchip_ptable
[i
])
175 dma_free_coherent(&meye
.mchip_dev
->dev
,
177 meye
.mchip_ptable
[i
], dma
);
181 if (meye
.mchip_ptable_toc
)
182 dma_free_coherent(&meye
.mchip_dev
->dev
,
184 meye
.mchip_ptable_toc
,
185 meye
.mchip_dmahandle
);
187 memset(meye
.mchip_ptable
, 0, sizeof(meye
.mchip_ptable
));
188 meye
.mchip_ptable_toc
= NULL
;
189 meye
.mchip_dmahandle
= 0;
192 /* copy data from ptable into buf */
193 static void ptable_copy(u8
*buf
, int start
, int size
, int pt_pages
)
197 for (i
= 0; i
< (size
/ PAGE_SIZE
) * PAGE_SIZE
; i
+= PAGE_SIZE
) {
198 memcpy(buf
+ i
, meye
.mchip_ptable
[start
++], PAGE_SIZE
);
199 if (start
>= pt_pages
)
202 memcpy(buf
+ i
, meye
.mchip_ptable
[start
], size
% PAGE_SIZE
);
205 /****************************************************************************/
206 /* JPEG tables at different qualities to load into the VRJ chip */
207 /****************************************************************************/
209 /* return a set of quantisation tables based on a quality from 1 to 10 */
210 static u16
*jpeg_quantisation_tables(int *length
, int quality
)
212 static u16 jpeg_tables
[][70] = { {
213 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
214 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
215 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
216 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
217 0xffff, 0xffff, 0xffff,
218 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
219 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
220 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
221 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
222 0xffff, 0xffff, 0xffff,
225 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
226 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
227 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
228 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
229 0xffff, 0xffff, 0xffff,
230 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
231 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
232 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
233 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
234 0xffff, 0xffff, 0xffff,
237 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
238 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
239 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
240 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
241 0xe6ff, 0xfffd, 0xfff8,
242 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
243 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
244 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
245 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
246 0xf8f8, 0xf8f8, 0xfff8,
249 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
250 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
251 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
252 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
253 0x99c7, 0xaba8, 0xffa4,
254 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
255 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
256 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
257 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
258 0xa4a4, 0xa4a4, 0xffa4,
261 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
262 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
263 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
264 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
265 0x7396, 0x817e, 0xff7c,
266 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
267 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
268 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
269 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
270 0x7c7c, 0x7c7c, 0xff7c,
273 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
274 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
275 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
276 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
277 0x5c78, 0x6765, 0xff63,
278 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
279 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
280 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
281 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
282 0x6363, 0x6363, 0xff63,
285 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
286 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
287 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
288 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
289 0x4a60, 0x5251, 0xff4f,
290 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
291 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
292 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
293 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
294 0x4f4f, 0x4f4f, 0xff4f,
297 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
298 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
299 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
300 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
301 0x3748, 0x3e3d, 0xff3b,
302 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
303 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
304 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
305 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
306 0x3b3b, 0x3b3b, 0xff3b,
309 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
310 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
311 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
312 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
313 0x2530, 0x2928, 0xff28,
314 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
315 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
316 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
317 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
318 0x2828, 0x2828, 0xff28,
321 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
322 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
323 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
324 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
325 0x1218, 0x1514, 0xff14,
326 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
327 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
328 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
329 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
330 0x1414, 0x1414, 0xff14,
333 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
334 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
335 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
336 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
337 0x0101, 0x0101, 0xff01,
338 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
339 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
340 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
341 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
342 0x0101, 0x0101, 0xff01,
345 if (quality
< 0 || quality
> 10) {
347 "meye: invalid quality level %d - using 8\n", quality
);
351 *length
= ARRAY_SIZE(jpeg_tables
[quality
]);
352 return jpeg_tables
[quality
];
355 /* return a generic set of huffman tables */
356 static u16
*jpeg_huffman_tables(int *length
)
358 static u16 tables
[] = {
359 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
360 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
361 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
362 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
363 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
364 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
365 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
366 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
367 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
368 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
369 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
370 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
371 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
372 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
373 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
374 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
375 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
376 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
377 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
378 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
379 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
380 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
381 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
382 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
383 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
384 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
386 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
387 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
391 *length
= ARRAY_SIZE(tables
);
395 /****************************************************************************/
396 /* MCHIP low-level functions */
397 /****************************************************************************/
399 /* returns the horizontal capture size */
400 static inline int mchip_hsize(void)
402 return meye
.params
.subsample
? 320 : 640;
405 /* returns the vertical capture size */
406 static inline int mchip_vsize(void)
408 return meye
.params
.subsample
? 240 : 480;
411 /* waits for a register to be available */
412 static void mchip_sync(int reg
)
417 if (reg
== MCHIP_MM_FIFO_DATA
) {
418 for (i
= 0; i
< MCHIP_REG_TIMEOUT
; i
++) {
419 status
= readl(meye
.mchip_mmregs
+
420 MCHIP_MM_FIFO_STATUS
);
421 if (!(status
& MCHIP_MM_FIFO_WAIT
)) {
422 printk(KERN_WARNING
"meye: fifo not ready\n");
425 if (status
& MCHIP_MM_FIFO_READY
)
429 } else if (reg
> 0x80) {
430 u32 mask
= (reg
< 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
431 : MCHIP_HIC_STATUS_VRJ_RDY
;
432 for (i
= 0; i
< MCHIP_REG_TIMEOUT
; i
++) {
433 status
= readl(meye
.mchip_mmregs
+ MCHIP_HIC_STATUS
);
441 "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
445 /* sets a value into the register */
446 static inline void mchip_set(int reg
, u32 v
)
449 writel(v
, meye
.mchip_mmregs
+ reg
);
452 /* get the register value */
453 static inline u32
mchip_read(int reg
)
456 return readl(meye
.mchip_mmregs
+ reg
);
459 /* wait for a register to become a particular value */
460 static inline int mchip_delay(u32 reg
, u32 v
)
463 while (--n
&& mchip_read(reg
) != v
)
468 /* setup subsampling */
469 static void mchip_subsample(void)
471 mchip_set(MCHIP_MCC_R_SAMPLING
, meye
.params
.subsample
);
472 mchip_set(MCHIP_MCC_R_XRANGE
, mchip_hsize());
473 mchip_set(MCHIP_MCC_R_YRANGE
, mchip_vsize());
474 mchip_set(MCHIP_MCC_B_XRANGE
, mchip_hsize());
475 mchip_set(MCHIP_MCC_B_YRANGE
, mchip_vsize());
476 mchip_delay(MCHIP_HIC_STATUS
, MCHIP_HIC_STATUS_IDLE
);
479 /* set the framerate into the mchip */
480 static void mchip_set_framerate(void)
482 mchip_set(MCHIP_HIC_S_RATE
, meye
.params
.framerate
);
485 /* load some huffman and quantisation tables into the VRJ chip ready
486 for JPEG compression */
487 static void mchip_load_tables(void)
493 tables
= jpeg_huffman_tables(&length
);
494 for (i
= 0; i
< length
; i
++)
495 writel(tables
[i
], meye
.mchip_mmregs
+ MCHIP_VRJ_TABLE_DATA
);
497 tables
= jpeg_quantisation_tables(&length
, meye
.params
.quality
);
498 for (i
= 0; i
< length
; i
++)
499 writel(tables
[i
], meye
.mchip_mmregs
+ MCHIP_VRJ_TABLE_DATA
);
502 /* setup the VRJ parameters in the chip */
503 static void mchip_vrj_setup(u8 mode
)
505 mchip_set(MCHIP_VRJ_BUS_MODE
, 5);
506 mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL
, 0x1f);
507 mchip_set(MCHIP_VRJ_PDAT_USE
, 1);
508 mchip_set(MCHIP_VRJ_IRQ_FLAG
, 0xa0);
509 mchip_set(MCHIP_VRJ_MODE_SPECIFY
, mode
);
510 mchip_set(MCHIP_VRJ_NUM_LINES
, mchip_vsize());
511 mchip_set(MCHIP_VRJ_NUM_PIXELS
, mchip_hsize());
512 mchip_set(MCHIP_VRJ_NUM_COMPONENTS
, 0x1b);
513 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO
, 0xFFFF);
514 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI
, 0xFFFF);
515 mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT
, 0xC);
516 mchip_set(MCHIP_VRJ_RESTART_INTERVAL
, 0);
517 mchip_set(MCHIP_VRJ_SOF1
, 0x601);
518 mchip_set(MCHIP_VRJ_SOF2
, 0x1502);
519 mchip_set(MCHIP_VRJ_SOF3
, 0x1503);
520 mchip_set(MCHIP_VRJ_SOF4
, 0x1596);
521 mchip_set(MCHIP_VRJ_SOS
, 0x0ed0);
526 /* sets the DMA parameters into the chip */
527 static void mchip_dma_setup(dma_addr_t dma_addr
)
531 mchip_set(MCHIP_MM_PT_ADDR
, (u32
)dma_addr
);
532 for (i
= 0; i
< 4; i
++)
533 mchip_set(MCHIP_MM_FIR(i
), 0);
537 /* setup for DMA transfers - also zeros the framebuffer */
538 static int mchip_dma_alloc(void)
540 if (!meye
.mchip_dmahandle
)
546 /* frees the DMA buffer */
547 static void mchip_dma_free(void)
549 if (meye
.mchip_dmahandle
) {
555 /* stop any existing HIC action and wait for any dma to complete then
556 reset the dma engine */
557 static void mchip_hic_stop(void)
561 meye
.mchip_mode
= MCHIP_HIC_MODE_NOOP
;
562 if (!(mchip_read(MCHIP_HIC_STATUS
) & MCHIP_HIC_STATUS_BUSY
))
564 for (i
= 0; i
< 20; ++i
) {
565 mchip_set(MCHIP_HIC_CMD
, MCHIP_HIC_CMD_STOP
);
566 mchip_delay(MCHIP_HIC_CMD
, 0);
567 for (j
= 0; j
< 100; ++j
) {
568 if (mchip_delay(MCHIP_HIC_STATUS
,
569 MCHIP_HIC_STATUS_IDLE
))
573 printk(KERN_ERR
"meye: need to reset HIC!\n");
575 mchip_set(MCHIP_HIC_CTL
, MCHIP_HIC_CTL_SOFT_RESET
);
578 printk(KERN_ERR
"meye: resetting HIC hanged!\n");
581 /****************************************************************************/
582 /* MCHIP frame processing functions */
583 /****************************************************************************/
585 /* get the next ready frame from the dma engine */
586 static u32
mchip_get_frame(void)
590 v
= mchip_read(MCHIP_MM_FIR(meye
.mchip_fnum
));
594 /* frees the current frame from the dma engine */
595 static void mchip_free_frame(void)
597 mchip_set(MCHIP_MM_FIR(meye
.mchip_fnum
), 0);
599 meye
.mchip_fnum
%= 4;
602 /* read one frame from the framebuffer assuming it was captured using
603 a uncompressed transfer */
604 static void mchip_cont_read_frame(u32 v
, u8
*buf
, int size
)
608 pt_id
= (v
>> 17) & 0x3FF;
610 ptable_copy(buf
, pt_id
, size
, MCHIP_NB_PAGES
);
613 /* read a compressed frame from the framebuffer */
614 static int mchip_comp_read_frame(u32 v
, u8
*buf
, int size
)
616 int pt_start
, pt_end
, trailer
;
620 pt_start
= (v
>> 19) & 0xFF;
621 pt_end
= (v
>> 11) & 0xFF;
622 trailer
= (v
>> 1) & 0x3FF;
624 if (pt_end
< pt_start
)
625 fsize
= (MCHIP_NB_PAGES_MJPEG
- pt_start
) * PAGE_SIZE
+
626 pt_end
* PAGE_SIZE
+ trailer
* 4;
628 fsize
= (pt_end
- pt_start
) * PAGE_SIZE
+ trailer
* 4;
631 printk(KERN_WARNING
"meye: oversized compressed frame %d\n",
636 ptable_copy(buf
, pt_start
, fsize
, MCHIP_NB_PAGES_MJPEG
);
638 #ifdef MEYE_JPEG_CORRECTION
640 /* Some mchip generated jpeg frames are incorrect. In most
641 * (all ?) of those cases, the final EOI (0xff 0xd9) marker
642 * is not present at the end of the frame.
644 * Since adding the final marker is not enough to restore
645 * the jpeg integrity, we drop the frame.
648 for (i
= fsize
- 1; i
> 0 && buf
[i
] == 0xff; i
--) ;
650 if (i
< 2 || buf
[i
- 1] != 0xff || buf
[i
] != 0xd9)
658 /* take a picture into SDRAM */
659 static void mchip_take_picture(void)
665 mchip_dma_setup(meye
.mchip_dmahandle
);
667 mchip_set(MCHIP_HIC_MODE
, MCHIP_HIC_MODE_STILL_CAP
);
668 mchip_set(MCHIP_HIC_CMD
, MCHIP_HIC_CMD_START
);
670 mchip_delay(MCHIP_HIC_CMD
, 0);
672 for (i
= 0; i
< 100; ++i
) {
673 if (mchip_delay(MCHIP_HIC_STATUS
, MCHIP_HIC_STATUS_IDLE
))
679 /* dma a previously taken picture into a buffer */
680 static void mchip_get_picture(u8
*buf
, int bufsize
)
685 mchip_set(MCHIP_HIC_MODE
, MCHIP_HIC_MODE_STILL_OUT
);
686 mchip_set(MCHIP_HIC_CMD
, MCHIP_HIC_CMD_START
);
688 mchip_delay(MCHIP_HIC_CMD
, 0);
689 for (i
= 0; i
< 100; ++i
) {
690 if (mchip_delay(MCHIP_HIC_STATUS
, MCHIP_HIC_STATUS_IDLE
))
694 for (i
= 0; i
< 4; ++i
) {
695 v
= mchip_get_frame();
696 if (v
& MCHIP_MM_FIR_RDY
) {
697 mchip_cont_read_frame(v
, buf
, bufsize
);
704 /* start continuous dma capture */
705 static void mchip_continuous_start(void)
709 mchip_set_framerate();
710 mchip_dma_setup(meye
.mchip_dmahandle
);
712 meye
.mchip_mode
= MCHIP_HIC_MODE_CONT_OUT
;
714 mchip_set(MCHIP_HIC_MODE
, MCHIP_HIC_MODE_CONT_OUT
);
715 mchip_set(MCHIP_HIC_CMD
, MCHIP_HIC_CMD_START
);
717 mchip_delay(MCHIP_HIC_CMD
, 0);
720 /* compress one frame into a buffer */
721 static int mchip_compress_frame(u8
*buf
, int bufsize
)
726 mchip_vrj_setup(0x3f);
729 mchip_set(MCHIP_HIC_MODE
, MCHIP_HIC_MODE_STILL_COMP
);
730 mchip_set(MCHIP_HIC_CMD
, MCHIP_HIC_CMD_START
);
732 mchip_delay(MCHIP_HIC_CMD
, 0);
733 for (i
= 0; i
< 100; ++i
) {
734 if (mchip_delay(MCHIP_HIC_STATUS
, MCHIP_HIC_STATUS_IDLE
))
739 for (i
= 0; i
< 4; ++i
) {
740 v
= mchip_get_frame();
741 if (v
& MCHIP_MM_FIR_RDY
) {
742 len
= mchip_comp_read_frame(v
, buf
, bufsize
);
751 /* start continuous compressed capture */
752 static void mchip_cont_compression_start(void)
755 mchip_vrj_setup(0x3f);
757 mchip_set_framerate();
758 mchip_dma_setup(meye
.mchip_dmahandle
);
760 meye
.mchip_mode
= MCHIP_HIC_MODE_CONT_COMP
;
762 mchip_set(MCHIP_HIC_MODE
, MCHIP_HIC_MODE_CONT_COMP
);
763 mchip_set(MCHIP_HIC_CMD
, MCHIP_HIC_CMD_START
);
765 mchip_delay(MCHIP_HIC_CMD
, 0);
768 /****************************************************************************/
769 /* Interrupt handling */
770 /****************************************************************************/
772 static irqreturn_t
meye_irq(int irq
, void *dev_id
)
778 v
= mchip_read(MCHIP_MM_INTA
);
780 if (meye
.mchip_mode
!= MCHIP_HIC_MODE_CONT_OUT
&&
781 meye
.mchip_mode
!= MCHIP_HIC_MODE_CONT_COMP
)
785 v
= mchip_get_frame();
786 if (!(v
& MCHIP_MM_FIR_RDY
))
789 if (meye
.mchip_mode
== MCHIP_HIC_MODE_CONT_OUT
) {
790 if (kfifo_out_locked(&meye
.grabq
, (unsigned char *)&reqnr
,
791 sizeof(int), &meye
.grabq_lock
) != sizeof(int)) {
795 mchip_cont_read_frame(v
, meye
.grab_fbuffer
+ gbufsize
* reqnr
,
796 mchip_hsize() * mchip_vsize() * 2);
797 meye
.grab_buffer
[reqnr
].size
= mchip_hsize() * mchip_vsize() * 2;
798 meye
.grab_buffer
[reqnr
].state
= MEYE_BUF_DONE
;
799 do_gettimeofday(&meye
.grab_buffer
[reqnr
].timestamp
);
800 meye
.grab_buffer
[reqnr
].sequence
= sequence
++;
801 kfifo_in_locked(&meye
.doneq
, (unsigned char *)&reqnr
,
802 sizeof(int), &meye
.doneq_lock
);
803 wake_up_interruptible(&meye
.proc_list
);
806 size
= mchip_comp_read_frame(v
, meye
.grab_temp
, gbufsize
);
811 if (kfifo_out_locked(&meye
.grabq
, (unsigned char *)&reqnr
,
812 sizeof(int), &meye
.grabq_lock
) != sizeof(int)) {
816 memcpy(meye
.grab_fbuffer
+ gbufsize
* reqnr
, meye
.grab_temp
,
818 meye
.grab_buffer
[reqnr
].size
= size
;
819 meye
.grab_buffer
[reqnr
].state
= MEYE_BUF_DONE
;
820 do_gettimeofday(&meye
.grab_buffer
[reqnr
].timestamp
);
821 meye
.grab_buffer
[reqnr
].sequence
= sequence
++;
822 kfifo_in_locked(&meye
.doneq
, (unsigned char *)&reqnr
,
823 sizeof(int), &meye
.doneq_lock
);
824 wake_up_interruptible(&meye
.proc_list
);
830 /****************************************************************************/
831 /* video4linux integration */
832 /****************************************************************************/
834 static int meye_open(struct file
*file
)
838 if (test_and_set_bit(0, &meye
.in_use
))
843 if (mchip_dma_alloc()) {
844 printk(KERN_ERR
"meye: mchip framebuffer allocation failed\n");
845 clear_bit(0, &meye
.in_use
);
849 for (i
= 0; i
< MEYE_MAX_BUFNBRS
; i
++)
850 meye
.grab_buffer
[i
].state
= MEYE_BUF_UNUSED
;
851 kfifo_reset(&meye
.grabq
);
852 kfifo_reset(&meye
.doneq
);
856 static int meye_release(struct file
*file
)
860 clear_bit(0, &meye
.in_use
);
864 static int meyeioc_g_params(struct meye_params
*p
)
870 static int meyeioc_s_params(struct meye_params
*jp
)
872 if (jp
->subsample
> 1)
875 if (jp
->quality
> 10)
878 if (jp
->sharpness
> 63 || jp
->agc
> 63 || jp
->picture
> 63)
881 if (jp
->framerate
> 31)
884 mutex_lock(&meye
.lock
);
886 if (meye
.params
.subsample
!= jp
->subsample
||
887 meye
.params
.quality
!= jp
->quality
)
888 mchip_hic_stop(); /* need restart */
891 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS
,
892 meye
.params
.sharpness
);
893 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC
,
895 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE
,
896 meye
.params
.picture
);
897 mutex_unlock(&meye
.lock
);
902 static int meyeioc_qbuf_capt(int *nb
)
904 if (!meye
.grab_fbuffer
)
916 if (meye
.grab_buffer
[*nb
].state
!= MEYE_BUF_UNUSED
)
919 mutex_lock(&meye
.lock
);
921 if (meye
.mchip_mode
!= MCHIP_HIC_MODE_CONT_COMP
)
922 mchip_cont_compression_start();
924 meye
.grab_buffer
[*nb
].state
= MEYE_BUF_USING
;
925 kfifo_in_locked(&meye
.grabq
, (unsigned char *)nb
, sizeof(int),
927 mutex_unlock(&meye
.lock
);
932 static int meyeioc_sync(struct file
*file
, void *fh
, int *i
)
936 if (*i
< 0 || *i
>= gbuffers
)
939 mutex_lock(&meye
.lock
);
940 switch (meye
.grab_buffer
[*i
].state
) {
942 case MEYE_BUF_UNUSED
:
943 mutex_unlock(&meye
.lock
);
946 if (file
->f_flags
& O_NONBLOCK
) {
947 mutex_unlock(&meye
.lock
);
950 if (wait_event_interruptible(meye
.proc_list
,
951 (meye
.grab_buffer
[*i
].state
!= MEYE_BUF_USING
))) {
952 mutex_unlock(&meye
.lock
);
957 meye
.grab_buffer
[*i
].state
= MEYE_BUF_UNUSED
;
958 if (kfifo_out_locked(&meye
.doneq
, (unsigned char *)&unused
,
959 sizeof(int), &meye
.doneq_lock
) != sizeof(int))
962 *i
= meye
.grab_buffer
[*i
].size
;
963 mutex_unlock(&meye
.lock
);
967 static int meyeioc_stillcapt(void)
969 if (!meye
.grab_fbuffer
)
972 if (meye
.grab_buffer
[0].state
!= MEYE_BUF_UNUSED
)
975 mutex_lock(&meye
.lock
);
976 meye
.grab_buffer
[0].state
= MEYE_BUF_USING
;
977 mchip_take_picture();
979 mchip_get_picture(meye
.grab_fbuffer
,
980 mchip_hsize() * mchip_vsize() * 2);
982 meye
.grab_buffer
[0].state
= MEYE_BUF_DONE
;
983 mutex_unlock(&meye
.lock
);
988 static int meyeioc_stilljcapt(int *len
)
990 if (!meye
.grab_fbuffer
)
993 if (meye
.grab_buffer
[0].state
!= MEYE_BUF_UNUSED
)
996 mutex_lock(&meye
.lock
);
997 meye
.grab_buffer
[0].state
= MEYE_BUF_USING
;
1000 while (*len
== -1) {
1001 mchip_take_picture();
1002 *len
= mchip_compress_frame(meye
.grab_fbuffer
, gbufsize
);
1005 meye
.grab_buffer
[0].state
= MEYE_BUF_DONE
;
1006 mutex_unlock(&meye
.lock
);
1010 static int vidioc_querycap(struct file
*file
, void *fh
,
1011 struct v4l2_capability
*cap
)
1013 strcpy(cap
->driver
, "meye");
1014 strcpy(cap
->card
, "meye");
1015 sprintf(cap
->bus_info
, "PCI:%s", pci_name(meye
.mchip_dev
));
1017 cap
->version
= (MEYE_DRIVER_MAJORVERSION
<< 8) +
1018 MEYE_DRIVER_MINORVERSION
;
1020 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
|
1026 static int vidioc_enum_input(struct file
*file
, void *fh
, struct v4l2_input
*i
)
1031 strcpy(i
->name
, "Camera");
1032 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1037 static int vidioc_g_input(struct file
*file
, void *fh
, unsigned int *i
)
1043 static int vidioc_s_input(struct file
*file
, void *fh
, unsigned int i
)
1051 static int vidioc_queryctrl(struct file
*file
, void *fh
,
1052 struct v4l2_queryctrl
*c
)
1056 case V4L2_CID_BRIGHTNESS
:
1057 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
1058 strcpy(c
->name
, "Brightness");
1062 c
->default_value
= 32;
1066 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
1067 strcpy(c
->name
, "Hue");
1071 c
->default_value
= 32;
1074 case V4L2_CID_CONTRAST
:
1075 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
1076 strcpy(c
->name
, "Contrast");
1080 c
->default_value
= 32;
1083 case V4L2_CID_SATURATION
:
1084 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
1085 strcpy(c
->name
, "Saturation");
1089 c
->default_value
= 32;
1093 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
1094 strcpy(c
->name
, "Agc");
1098 c
->default_value
= 48;
1101 case V4L2_CID_MEYE_SHARPNESS
:
1102 case V4L2_CID_SHARPNESS
:
1103 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
1104 strcpy(c
->name
, "Sharpness");
1108 c
->default_value
= 32;
1110 /* Continue to report legacy private SHARPNESS ctrl but
1111 * say it is disabled in preference to ctrl in the spec
1113 c
->flags
= (c
->id
== V4L2_CID_SHARPNESS
) ? 0 :
1114 V4L2_CTRL_FLAG_DISABLED
;
1116 case V4L2_CID_PICTURE
:
1117 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
1118 strcpy(c
->name
, "Picture");
1122 c
->default_value
= 0;
1125 case V4L2_CID_JPEGQUAL
:
1126 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
1127 strcpy(c
->name
, "JPEG quality");
1131 c
->default_value
= 8;
1134 case V4L2_CID_FRAMERATE
:
1135 c
->type
= V4L2_CTRL_TYPE_INTEGER
;
1136 strcpy(c
->name
, "Framerate");
1140 c
->default_value
= 0;
1150 static int vidioc_s_ctrl(struct file
*file
, void *fh
, struct v4l2_control
*c
)
1152 mutex_lock(&meye
.lock
);
1154 case V4L2_CID_BRIGHTNESS
:
1155 sony_pic_camera_command(
1156 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS
, c
->value
);
1157 meye
.brightness
= c
->value
<< 10;
1160 sony_pic_camera_command(
1161 SONY_PIC_COMMAND_SETCAMERAHUE
, c
->value
);
1162 meye
.hue
= c
->value
<< 10;
1164 case V4L2_CID_CONTRAST
:
1165 sony_pic_camera_command(
1166 SONY_PIC_COMMAND_SETCAMERACONTRAST
, c
->value
);
1167 meye
.contrast
= c
->value
<< 10;
1169 case V4L2_CID_SATURATION
:
1170 sony_pic_camera_command(
1171 SONY_PIC_COMMAND_SETCAMERACOLOR
, c
->value
);
1172 meye
.colour
= c
->value
<< 10;
1175 sony_pic_camera_command(
1176 SONY_PIC_COMMAND_SETCAMERAAGC
, c
->value
);
1177 meye
.params
.agc
= c
->value
;
1179 case V4L2_CID_SHARPNESS
:
1180 case V4L2_CID_MEYE_SHARPNESS
:
1181 sony_pic_camera_command(
1182 SONY_PIC_COMMAND_SETCAMERASHARPNESS
, c
->value
);
1183 meye
.params
.sharpness
= c
->value
;
1185 case V4L2_CID_PICTURE
:
1186 sony_pic_camera_command(
1187 SONY_PIC_COMMAND_SETCAMERAPICTURE
, c
->value
);
1188 meye
.params
.picture
= c
->value
;
1190 case V4L2_CID_JPEGQUAL
:
1191 meye
.params
.quality
= c
->value
;
1193 case V4L2_CID_FRAMERATE
:
1194 meye
.params
.framerate
= c
->value
;
1197 mutex_unlock(&meye
.lock
);
1200 mutex_unlock(&meye
.lock
);
1205 static int vidioc_g_ctrl(struct file
*file
, void *fh
, struct v4l2_control
*c
)
1207 mutex_lock(&meye
.lock
);
1209 case V4L2_CID_BRIGHTNESS
:
1210 c
->value
= meye
.brightness
>> 10;
1213 c
->value
= meye
.hue
>> 10;
1215 case V4L2_CID_CONTRAST
:
1216 c
->value
= meye
.contrast
>> 10;
1218 case V4L2_CID_SATURATION
:
1219 c
->value
= meye
.colour
>> 10;
1222 c
->value
= meye
.params
.agc
;
1224 case V4L2_CID_SHARPNESS
:
1225 case V4L2_CID_MEYE_SHARPNESS
:
1226 c
->value
= meye
.params
.sharpness
;
1228 case V4L2_CID_PICTURE
:
1229 c
->value
= meye
.params
.picture
;
1231 case V4L2_CID_JPEGQUAL
:
1232 c
->value
= meye
.params
.quality
;
1234 case V4L2_CID_FRAMERATE
:
1235 c
->value
= meye
.params
.framerate
;
1238 mutex_unlock(&meye
.lock
);
1241 mutex_unlock(&meye
.lock
);
1246 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *fh
,
1247 struct v4l2_fmtdesc
*f
)
1252 if (f
->index
== 0) {
1253 /* standard YUV 422 capture */
1255 strcpy(f
->description
, "YUV422");
1256 f
->pixelformat
= V4L2_PIX_FMT_YUYV
;
1258 /* compressed MJPEG capture */
1259 f
->flags
= V4L2_FMT_FLAG_COMPRESSED
;
1260 strcpy(f
->description
, "MJPEG");
1261 f
->pixelformat
= V4L2_PIX_FMT_MJPEG
;
1267 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *fh
,
1268 struct v4l2_format
*f
)
1270 if (f
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_YUYV
&&
1271 f
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_MJPEG
)
1274 if (f
->fmt
.pix
.field
!= V4L2_FIELD_ANY
&&
1275 f
->fmt
.pix
.field
!= V4L2_FIELD_NONE
)
1278 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
1280 if (f
->fmt
.pix
.width
<= 320) {
1281 f
->fmt
.pix
.width
= 320;
1282 f
->fmt
.pix
.height
= 240;
1284 f
->fmt
.pix
.width
= 640;
1285 f
->fmt
.pix
.height
= 480;
1288 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
1289 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
*
1290 f
->fmt
.pix
.bytesperline
;
1291 f
->fmt
.pix
.colorspace
= 0;
1292 f
->fmt
.pix
.priv
= 0;
1297 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *fh
,
1298 struct v4l2_format
*f
)
1300 switch (meye
.mchip_mode
) {
1301 case MCHIP_HIC_MODE_CONT_OUT
:
1303 f
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_YUYV
;
1305 case MCHIP_HIC_MODE_CONT_COMP
:
1306 f
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_MJPEG
;
1310 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
1311 f
->fmt
.pix
.width
= mchip_hsize();
1312 f
->fmt
.pix
.height
= mchip_vsize();
1313 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
1314 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
*
1315 f
->fmt
.pix
.bytesperline
;
1320 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *fh
,
1321 struct v4l2_format
*f
)
1323 if (f
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_YUYV
&&
1324 f
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_MJPEG
)
1327 if (f
->fmt
.pix
.field
!= V4L2_FIELD_ANY
&&
1328 f
->fmt
.pix
.field
!= V4L2_FIELD_NONE
)
1331 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
1332 mutex_lock(&meye
.lock
);
1334 if (f
->fmt
.pix
.width
<= 320) {
1335 f
->fmt
.pix
.width
= 320;
1336 f
->fmt
.pix
.height
= 240;
1337 meye
.params
.subsample
= 1;
1339 f
->fmt
.pix
.width
= 640;
1340 f
->fmt
.pix
.height
= 480;
1341 meye
.params
.subsample
= 0;
1344 switch (f
->fmt
.pix
.pixelformat
) {
1345 case V4L2_PIX_FMT_YUYV
:
1346 meye
.mchip_mode
= MCHIP_HIC_MODE_CONT_OUT
;
1348 case V4L2_PIX_FMT_MJPEG
:
1349 meye
.mchip_mode
= MCHIP_HIC_MODE_CONT_COMP
;
1353 mutex_unlock(&meye
.lock
);
1354 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
1355 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
*
1356 f
->fmt
.pix
.bytesperline
;
1357 f
->fmt
.pix
.colorspace
= 0;
1358 f
->fmt
.pix
.priv
= 0;
1363 static int vidioc_reqbufs(struct file
*file
, void *fh
,
1364 struct v4l2_requestbuffers
*req
)
1368 if (req
->memory
!= V4L2_MEMORY_MMAP
)
1371 if (meye
.grab_fbuffer
&& req
->count
== gbuffers
) {
1372 /* already allocated, no modifications */
1376 mutex_lock(&meye
.lock
);
1377 if (meye
.grab_fbuffer
) {
1378 for (i
= 0; i
< gbuffers
; i
++)
1379 if (meye
.vma_use_count
[i
]) {
1380 mutex_unlock(&meye
.lock
);
1383 rvfree(meye
.grab_fbuffer
, gbuffers
* gbufsize
);
1384 meye
.grab_fbuffer
= NULL
;
1387 gbuffers
= max(2, min((int)req
->count
, MEYE_MAX_BUFNBRS
));
1388 req
->count
= gbuffers
;
1389 meye
.grab_fbuffer
= rvmalloc(gbuffers
* gbufsize
);
1391 if (!meye
.grab_fbuffer
) {
1392 printk(KERN_ERR
"meye: v4l framebuffer allocation"
1394 mutex_unlock(&meye
.lock
);
1398 for (i
= 0; i
< gbuffers
; i
++)
1399 meye
.vma_use_count
[i
] = 0;
1401 mutex_unlock(&meye
.lock
);
1406 static int vidioc_querybuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
1408 unsigned int index
= buf
->index
;
1410 if (index
>= gbuffers
)
1413 buf
->bytesused
= meye
.grab_buffer
[index
].size
;
1414 buf
->flags
= V4L2_BUF_FLAG_MAPPED
;
1416 if (meye
.grab_buffer
[index
].state
== MEYE_BUF_USING
)
1417 buf
->flags
|= V4L2_BUF_FLAG_QUEUED
;
1419 if (meye
.grab_buffer
[index
].state
== MEYE_BUF_DONE
)
1420 buf
->flags
|= V4L2_BUF_FLAG_DONE
;
1422 buf
->field
= V4L2_FIELD_NONE
;
1423 buf
->timestamp
= meye
.grab_buffer
[index
].timestamp
;
1424 buf
->sequence
= meye
.grab_buffer
[index
].sequence
;
1425 buf
->memory
= V4L2_MEMORY_MMAP
;
1426 buf
->m
.offset
= index
* gbufsize
;
1427 buf
->length
= gbufsize
;
1432 static int vidioc_qbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
1434 if (buf
->memory
!= V4L2_MEMORY_MMAP
)
1437 if (buf
->index
>= gbuffers
)
1440 if (meye
.grab_buffer
[buf
->index
].state
!= MEYE_BUF_UNUSED
)
1443 mutex_lock(&meye
.lock
);
1444 buf
->flags
|= V4L2_BUF_FLAG_QUEUED
;
1445 buf
->flags
&= ~V4L2_BUF_FLAG_DONE
;
1446 meye
.grab_buffer
[buf
->index
].state
= MEYE_BUF_USING
;
1447 kfifo_in_locked(&meye
.grabq
, (unsigned char *)&buf
->index
,
1448 sizeof(int), &meye
.grabq_lock
);
1449 mutex_unlock(&meye
.lock
);
1454 static int vidioc_dqbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
1458 if (buf
->memory
!= V4L2_MEMORY_MMAP
)
1461 mutex_lock(&meye
.lock
);
1463 if (kfifo_len(&meye
.doneq
) == 0 && file
->f_flags
& O_NONBLOCK
) {
1464 mutex_unlock(&meye
.lock
);
1468 if (wait_event_interruptible(meye
.proc_list
,
1469 kfifo_len(&meye
.doneq
) != 0) < 0) {
1470 mutex_unlock(&meye
.lock
);
1474 if (!kfifo_out_locked(&meye
.doneq
, (unsigned char *)&reqnr
,
1475 sizeof(int), &meye
.doneq_lock
)) {
1476 mutex_unlock(&meye
.lock
);
1480 if (meye
.grab_buffer
[reqnr
].state
!= MEYE_BUF_DONE
) {
1481 mutex_unlock(&meye
.lock
);
1486 buf
->bytesused
= meye
.grab_buffer
[reqnr
].size
;
1487 buf
->flags
= V4L2_BUF_FLAG_MAPPED
;
1488 buf
->field
= V4L2_FIELD_NONE
;
1489 buf
->timestamp
= meye
.grab_buffer
[reqnr
].timestamp
;
1490 buf
->sequence
= meye
.grab_buffer
[reqnr
].sequence
;
1491 buf
->memory
= V4L2_MEMORY_MMAP
;
1492 buf
->m
.offset
= reqnr
* gbufsize
;
1493 buf
->length
= gbufsize
;
1494 meye
.grab_buffer
[reqnr
].state
= MEYE_BUF_UNUSED
;
1495 mutex_unlock(&meye
.lock
);
1500 static int vidioc_streamon(struct file
*file
, void *fh
, enum v4l2_buf_type i
)
1502 mutex_lock(&meye
.lock
);
1504 switch (meye
.mchip_mode
) {
1505 case MCHIP_HIC_MODE_CONT_OUT
:
1506 mchip_continuous_start();
1508 case MCHIP_HIC_MODE_CONT_COMP
:
1509 mchip_cont_compression_start();
1512 mutex_unlock(&meye
.lock
);
1516 mutex_unlock(&meye
.lock
);
1521 static int vidioc_streamoff(struct file
*file
, void *fh
, enum v4l2_buf_type i
)
1523 mutex_lock(&meye
.lock
);
1525 kfifo_reset(&meye
.grabq
);
1526 kfifo_reset(&meye
.doneq
);
1528 for (i
= 0; i
< MEYE_MAX_BUFNBRS
; i
++)
1529 meye
.grab_buffer
[i
].state
= MEYE_BUF_UNUSED
;
1531 mutex_unlock(&meye
.lock
);
1535 static long vidioc_default(struct file
*file
, void *fh
, int cmd
, void *arg
)
1538 case MEYEIOC_G_PARAMS
:
1539 return meyeioc_g_params((struct meye_params
*) arg
);
1541 case MEYEIOC_S_PARAMS
:
1542 return meyeioc_s_params((struct meye_params
*) arg
);
1544 case MEYEIOC_QBUF_CAPT
:
1545 return meyeioc_qbuf_capt((int *) arg
);
1548 return meyeioc_sync(file
, fh
, (int *) arg
);
1550 case MEYEIOC_STILLCAPT
:
1551 return meyeioc_stillcapt();
1553 case MEYEIOC_STILLJCAPT
:
1554 return meyeioc_stilljcapt((int *) arg
);
1562 static unsigned int meye_poll(struct file
*file
, poll_table
*wait
)
1564 unsigned int res
= 0;
1566 mutex_lock(&meye
.lock
);
1567 poll_wait(file
, &meye
.proc_list
, wait
);
1568 if (kfifo_len(&meye
.doneq
))
1569 res
= POLLIN
| POLLRDNORM
;
1570 mutex_unlock(&meye
.lock
);
1574 static void meye_vm_open(struct vm_area_struct
*vma
)
1576 long idx
= (long)vma
->vm_private_data
;
1577 meye
.vma_use_count
[idx
]++;
1580 static void meye_vm_close(struct vm_area_struct
*vma
)
1582 long idx
= (long)vma
->vm_private_data
;
1583 meye
.vma_use_count
[idx
]--;
1586 static const struct vm_operations_struct meye_vm_ops
= {
1587 .open
= meye_vm_open
,
1588 .close
= meye_vm_close
,
1591 static int meye_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1593 unsigned long start
= vma
->vm_start
;
1594 unsigned long size
= vma
->vm_end
- vma
->vm_start
;
1595 unsigned long offset
= vma
->vm_pgoff
<< PAGE_SHIFT
;
1596 unsigned long page
, pos
;
1598 mutex_lock(&meye
.lock
);
1599 if (size
> gbuffers
* gbufsize
) {
1600 mutex_unlock(&meye
.lock
);
1603 if (!meye
.grab_fbuffer
) {
1606 /* lazy allocation */
1607 meye
.grab_fbuffer
= rvmalloc(gbuffers
*gbufsize
);
1608 if (!meye
.grab_fbuffer
) {
1609 printk(KERN_ERR
"meye: v4l framebuffer allocation failed\n");
1610 mutex_unlock(&meye
.lock
);
1613 for (i
= 0; i
< gbuffers
; i
++)
1614 meye
.vma_use_count
[i
] = 0;
1616 pos
= (unsigned long)meye
.grab_fbuffer
+ offset
;
1619 page
= vmalloc_to_pfn((void *)pos
);
1620 if (remap_pfn_range(vma
, start
, page
, PAGE_SIZE
, PAGE_SHARED
)) {
1621 mutex_unlock(&meye
.lock
);
1626 if (size
> PAGE_SIZE
)
1632 vma
->vm_ops
= &meye_vm_ops
;
1633 vma
->vm_flags
&= ~VM_IO
; /* not I/O memory */
1634 vma
->vm_flags
|= VM_RESERVED
; /* avoid to swap out this VMA */
1635 vma
->vm_private_data
= (void *) (offset
/ gbufsize
);
1638 mutex_unlock(&meye
.lock
);
1642 static const struct v4l2_file_operations meye_fops
= {
1643 .owner
= THIS_MODULE
,
1645 .release
= meye_release
,
1647 .ioctl
= video_ioctl2
,
1651 static const struct v4l2_ioctl_ops meye_ioctl_ops
= {
1652 .vidioc_querycap
= vidioc_querycap
,
1653 .vidioc_enum_input
= vidioc_enum_input
,
1654 .vidioc_g_input
= vidioc_g_input
,
1655 .vidioc_s_input
= vidioc_s_input
,
1656 .vidioc_queryctrl
= vidioc_queryctrl
,
1657 .vidioc_s_ctrl
= vidioc_s_ctrl
,
1658 .vidioc_g_ctrl
= vidioc_g_ctrl
,
1659 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1660 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1661 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1662 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1663 .vidioc_reqbufs
= vidioc_reqbufs
,
1664 .vidioc_querybuf
= vidioc_querybuf
,
1665 .vidioc_qbuf
= vidioc_qbuf
,
1666 .vidioc_dqbuf
= vidioc_dqbuf
,
1667 .vidioc_streamon
= vidioc_streamon
,
1668 .vidioc_streamoff
= vidioc_streamoff
,
1669 .vidioc_default
= vidioc_default
,
1672 static struct video_device meye_template
= {
1675 .ioctl_ops
= &meye_ioctl_ops
,
1676 .release
= video_device_release
,
1680 static int meye_suspend(struct pci_dev
*pdev
, pm_message_t state
)
1682 pci_save_state(pdev
);
1683 meye
.pm_mchip_mode
= meye
.mchip_mode
;
1685 mchip_set(MCHIP_MM_INTA
, 0x0);
1689 static int meye_resume(struct pci_dev
*pdev
)
1691 pci_restore_state(pdev
);
1692 pci_write_config_word(meye
.mchip_dev
, MCHIP_PCI_SOFTRESET_SET
, 1);
1694 mchip_delay(MCHIP_HIC_CMD
, 0);
1695 mchip_delay(MCHIP_HIC_STATUS
, MCHIP_HIC_STATUS_IDLE
);
1697 mchip_set(MCHIP_VRJ_SOFT_RESET
, 1);
1699 mchip_set(MCHIP_MM_PCI_MODE
, 5);
1701 mchip_set(MCHIP_MM_INTA
, MCHIP_MM_INTA_HIC_1_MASK
);
1703 switch (meye
.pm_mchip_mode
) {
1704 case MCHIP_HIC_MODE_CONT_OUT
:
1705 mchip_continuous_start();
1707 case MCHIP_HIC_MODE_CONT_COMP
:
1708 mchip_cont_compression_start();
1715 static int __devinit
meye_probe(struct pci_dev
*pcidev
,
1716 const struct pci_device_id
*ent
)
1718 struct v4l2_device
*v4l2_dev
= &meye
.v4l2_dev
;
1720 unsigned long mchip_adr
;
1722 if (meye
.mchip_dev
!= NULL
) {
1723 printk(KERN_ERR
"meye: only one device allowed!\n");
1727 ret
= v4l2_device_register(&pcidev
->dev
, v4l2_dev
);
1729 v4l2_err(v4l2_dev
, "Could not register v4l2_device\n");
1733 meye
.mchip_dev
= pcidev
;
1734 meye
.vdev
= video_device_alloc();
1736 v4l2_err(v4l2_dev
, "video_device_alloc() failed!\n");
1740 meye
.grab_temp
= vmalloc(MCHIP_NB_PAGES_MJPEG
* PAGE_SIZE
);
1741 if (!meye
.grab_temp
) {
1742 v4l2_err(v4l2_dev
, "grab buffer allocation failed\n");
1746 spin_lock_init(&meye
.grabq_lock
);
1747 if (kfifo_alloc(&meye
.grabq
, sizeof(int) * MEYE_MAX_BUFNBRS
,
1749 v4l2_err(v4l2_dev
, "fifo allocation failed\n");
1750 goto outkfifoalloc1
;
1752 spin_lock_init(&meye
.doneq_lock
);
1753 if (kfifo_alloc(&meye
.doneq
, sizeof(int) * MEYE_MAX_BUFNBRS
,
1755 v4l2_err(v4l2_dev
, "fifo allocation failed\n");
1756 goto outkfifoalloc2
;
1759 memcpy(meye
.vdev
, &meye_template
, sizeof(meye_template
));
1760 meye
.vdev
->v4l2_dev
= &meye
.v4l2_dev
;
1763 if ((ret
= sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA
, 1))) {
1764 v4l2_err(v4l2_dev
, "meye: unable to power on the camera\n");
1765 v4l2_err(v4l2_dev
, "meye: did you enable the camera in "
1766 "sonypi using the module options ?\n");
1767 goto outsonypienable
;
1770 if ((ret
= pci_enable_device(meye
.mchip_dev
))) {
1771 v4l2_err(v4l2_dev
, "meye: pci_enable_device failed\n");
1775 mchip_adr
= pci_resource_start(meye
.mchip_dev
,0);
1777 v4l2_err(v4l2_dev
, "meye: mchip has no device base address\n");
1780 if (!request_mem_region(pci_resource_start(meye
.mchip_dev
, 0),
1781 pci_resource_len(meye
.mchip_dev
, 0),
1783 v4l2_err(v4l2_dev
, "meye: request_mem_region failed\n");
1786 meye
.mchip_mmregs
= ioremap(mchip_adr
, MCHIP_MM_REGS
);
1787 if (!meye
.mchip_mmregs
) {
1788 v4l2_err(v4l2_dev
, "meye: ioremap failed\n");
1792 meye
.mchip_irq
= pcidev
->irq
;
1793 if (request_irq(meye
.mchip_irq
, meye_irq
,
1794 IRQF_DISABLED
| IRQF_SHARED
, "meye", meye_irq
)) {
1795 v4l2_err(v4l2_dev
, "request_irq failed\n");
1799 pci_write_config_byte(meye
.mchip_dev
, PCI_CACHE_LINE_SIZE
, 8);
1800 pci_write_config_byte(meye
.mchip_dev
, PCI_LATENCY_TIMER
, 64);
1802 pci_set_master(meye
.mchip_dev
);
1804 /* Ask the camera to perform a soft reset. */
1805 pci_write_config_word(meye
.mchip_dev
, MCHIP_PCI_SOFTRESET_SET
, 1);
1807 mchip_delay(MCHIP_HIC_CMD
, 0);
1808 mchip_delay(MCHIP_HIC_STATUS
, MCHIP_HIC_STATUS_IDLE
);
1811 mchip_set(MCHIP_VRJ_SOFT_RESET
, 1);
1814 mchip_set(MCHIP_MM_PCI_MODE
, 5);
1817 mchip_set(MCHIP_MM_INTA
, MCHIP_MM_INTA_HIC_1_MASK
);
1819 if (video_register_device(meye
.vdev
, VFL_TYPE_GRABBER
,
1821 v4l2_err(v4l2_dev
, "video_register_device failed\n");
1825 mutex_init(&meye
.lock
);
1826 init_waitqueue_head(&meye
.proc_list
);
1827 meye
.brightness
= 32 << 10;
1828 meye
.hue
= 32 << 10;
1829 meye
.colour
= 32 << 10;
1830 meye
.contrast
= 32 << 10;
1831 meye
.params
.subsample
= 0;
1832 meye
.params
.quality
= 8;
1833 meye
.params
.sharpness
= 32;
1834 meye
.params
.agc
= 48;
1835 meye
.params
.picture
= 0;
1836 meye
.params
.framerate
= 0;
1838 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS
, 32);
1839 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE
, 32);
1840 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR
, 32);
1841 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST
, 32);
1842 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS
, 32);
1843 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE
, 0);
1844 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC
, 48);
1846 v4l2_info(v4l2_dev
, "Motion Eye Camera Driver v%s.\n",
1847 MEYE_DRIVER_VERSION
);
1848 v4l2_info(v4l2_dev
, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1849 meye
.mchip_dev
->revision
, mchip_adr
, meye
.mchip_irq
);
1854 free_irq(meye
.mchip_irq
, meye_irq
);
1856 iounmap(meye
.mchip_mmregs
);
1858 release_mem_region(pci_resource_start(meye
.mchip_dev
, 0),
1859 pci_resource_len(meye
.mchip_dev
, 0));
1861 pci_disable_device(meye
.mchip_dev
);
1863 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA
, 0);
1865 kfifo_free(&meye
.doneq
);
1867 kfifo_free(&meye
.grabq
);
1869 vfree(meye
.grab_temp
);
1871 video_device_release(meye
.vdev
);
1876 static void __devexit
meye_remove(struct pci_dev
*pcidev
)
1878 video_unregister_device(meye
.vdev
);
1884 /* disable interrupts */
1885 mchip_set(MCHIP_MM_INTA
, 0x0);
1887 free_irq(meye
.mchip_irq
, meye_irq
);
1889 iounmap(meye
.mchip_mmregs
);
1891 release_mem_region(pci_resource_start(meye
.mchip_dev
, 0),
1892 pci_resource_len(meye
.mchip_dev
, 0));
1894 pci_disable_device(meye
.mchip_dev
);
1896 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA
, 0);
1898 kfifo_free(&meye
.doneq
);
1899 kfifo_free(&meye
.grabq
);
1901 vfree(meye
.grab_temp
);
1903 if (meye
.grab_fbuffer
) {
1904 rvfree(meye
.grab_fbuffer
, gbuffers
*gbufsize
);
1905 meye
.grab_fbuffer
= NULL
;
1908 printk(KERN_INFO
"meye: removed\n");
1911 static struct pci_device_id meye_pci_tbl
[] = {
1912 { PCI_VDEVICE(KAWASAKI
, PCI_DEVICE_ID_MCHIP_KL5A72002
), 0 },
1916 MODULE_DEVICE_TABLE(pci
, meye_pci_tbl
);
1918 static struct pci_driver meye_driver
= {
1920 .id_table
= meye_pci_tbl
,
1921 .probe
= meye_probe
,
1922 .remove
= __devexit_p(meye_remove
),
1924 .suspend
= meye_suspend
,
1925 .resume
= meye_resume
,
1929 static int __init
meye_init(void)
1931 gbuffers
= max(2, min((int)gbuffers
, MEYE_MAX_BUFNBRS
));
1932 if (gbufsize
< 0 || gbufsize
> MEYE_MAX_BUFSIZE
)
1933 gbufsize
= MEYE_MAX_BUFSIZE
;
1934 gbufsize
= PAGE_ALIGN(gbufsize
);
1935 printk(KERN_INFO
"meye: using %d buffers with %dk (%dk total) "
1938 gbufsize
/ 1024, gbuffers
* gbufsize
/ 1024);
1939 return pci_register_driver(&meye_driver
);
1942 static void __exit
meye_exit(void)
1944 pci_unregister_driver(&meye_driver
);
1947 module_init(meye_init
);
1948 module_exit(meye_exit
);