]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/media/video/meye.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


884a569d60a28d46b3b4dfe1ea21faa3f335b74c
[mirror_ubuntu-bionic-kernel.git] / drivers / media / video / meye.c
1 /*
2 * Motion Eye video4linux driver for Sony Vaio PictureBook
3 *
4 * Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
5 *
6 * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
7 *
8 * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
9 *
10 * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
11 *
12 * Some parts borrowed from various video4linux drivers, especially
13 * bttv-driver.c and zoran.c, see original files for credits.
14 *
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.
19 *
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.
24 *
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.
28 */
29 #include <linux/module.h>
30 #include <linux/pci.h>
31 #include <linux/sched.h>
32 #include <linux/init.h>
33 #include <linux/videodev.h>
34 #include <media/v4l2-common.h>
35 #include <media/v4l2-ioctl.h>
36 #include <asm/uaccess.h>
37 #include <asm/io.h>
38 #include <linux/delay.h>
39 #include <linux/interrupt.h>
40 #include <linux/vmalloc.h>
41 #include <linux/dma-mapping.h>
42
43 #include "meye.h"
44 #include <linux/meye.h>
45
46 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
47 MODULE_DESCRIPTION("v4l2 driver for the MotionEye camera");
48 MODULE_LICENSE("GPL");
49 MODULE_VERSION(MEYE_DRIVER_VERSION);
50
51 /* number of grab buffers */
52 static unsigned int gbuffers = 2;
53 module_param(gbuffers, int, 0444);
54 MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)");
55
56 /* size of a grab buffer */
57 static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
58 module_param(gbufsize, int, 0444);
59 MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 614400"
60 " (will be rounded up to a page multiple)");
61
62 /* /dev/videoX registration number */
63 static int video_nr = -1;
64 module_param(video_nr, int, 0444);
65 MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)");
66
67 /* driver structure - only one possible */
68 static struct meye meye;
69
70 /****************************************************************************/
71 /* Memory allocation routines (stolen from bttv-driver.c) */
72 /****************************************************************************/
73 static void *rvmalloc(unsigned long size)
74 {
75 void *mem;
76 unsigned long adr;
77
78 size = PAGE_ALIGN(size);
79 mem = vmalloc_32(size);
80 if (mem) {
81 memset(mem, 0, size);
82 adr = (unsigned long) mem;
83 while (size > 0) {
84 SetPageReserved(vmalloc_to_page((void *)adr));
85 adr += PAGE_SIZE;
86 size -= PAGE_SIZE;
87 }
88 }
89 return mem;
90 }
91
92 static void rvfree(void * mem, unsigned long size)
93 {
94 unsigned long adr;
95
96 if (mem) {
97 adr = (unsigned long) mem;
98 while ((long) size > 0) {
99 ClearPageReserved(vmalloc_to_page((void *)adr));
100 adr += PAGE_SIZE;
101 size -= PAGE_SIZE;
102 }
103 vfree(mem);
104 }
105 }
106
107 /*
108 * return a page table pointing to N pages of locked memory
109 *
110 * NOTE: The meye device expects DMA addresses on 32 bits, we build
111 * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
112 */
113 static int ptable_alloc(void)
114 {
115 u32 *pt;
116 int i;
117
118 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
119
120 /* give only 32 bit DMA addresses */
121 if (dma_set_mask(&meye.mchip_dev->dev, DMA_BIT_MASK(32)))
122 return -1;
123
124 meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
125 PAGE_SIZE,
126 &meye.mchip_dmahandle,
127 GFP_KERNEL);
128 if (!meye.mchip_ptable_toc) {
129 meye.mchip_dmahandle = 0;
130 return -1;
131 }
132
133 pt = meye.mchip_ptable_toc;
134 for (i = 0; i < MCHIP_NB_PAGES; i++) {
135 dma_addr_t dma;
136 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
137 PAGE_SIZE,
138 &dma,
139 GFP_KERNEL);
140 if (!meye.mchip_ptable[i]) {
141 int j;
142 pt = meye.mchip_ptable_toc;
143 for (j = 0; j < i; ++j) {
144 dma = (dma_addr_t) *pt;
145 dma_free_coherent(&meye.mchip_dev->dev,
146 PAGE_SIZE,
147 meye.mchip_ptable[j], dma);
148 pt++;
149 }
150 dma_free_coherent(&meye.mchip_dev->dev,
151 PAGE_SIZE,
152 meye.mchip_ptable_toc,
153 meye.mchip_dmahandle);
154 meye.mchip_ptable_toc = NULL;
155 meye.mchip_dmahandle = 0;
156 return -1;
157 }
158 *pt = (u32) dma;
159 pt++;
160 }
161 return 0;
162 }
163
164 static void ptable_free(void)
165 {
166 u32 *pt;
167 int i;
168
169 pt = meye.mchip_ptable_toc;
170 for (i = 0; i < MCHIP_NB_PAGES; i++) {
171 dma_addr_t dma = (dma_addr_t) *pt;
172 if (meye.mchip_ptable[i])
173 dma_free_coherent(&meye.mchip_dev->dev,
174 PAGE_SIZE,
175 meye.mchip_ptable[i], dma);
176 pt++;
177 }
178
179 if (meye.mchip_ptable_toc)
180 dma_free_coherent(&meye.mchip_dev->dev,
181 PAGE_SIZE,
182 meye.mchip_ptable_toc,
183 meye.mchip_dmahandle);
184
185 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
186 meye.mchip_ptable_toc = NULL;
187 meye.mchip_dmahandle = 0;
188 }
189
190 /* copy data from ptable into buf */
191 static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
192 {
193 int i;
194
195 for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
196 memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
197 if (start >= pt_pages)
198 start = 0;
199 }
200 memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
201 }
202
203 /****************************************************************************/
204 /* JPEG tables at different qualities to load into the VRJ chip */
205 /****************************************************************************/
206
207 /* return a set of quantisation tables based on a quality from 1 to 10 */
208 static u16 *jpeg_quantisation_tables(int *length, int quality)
209 {
210 static u16 jpeg_tables[][70] = { {
211 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
212 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
213 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
214 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
215 0xffff, 0xffff, 0xffff,
216 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
217 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
218 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
219 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
220 0xffff, 0xffff, 0xffff,
221 },
222 {
223 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
224 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
225 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
226 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
227 0xffff, 0xffff, 0xffff,
228 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
229 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
230 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
231 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
232 0xffff, 0xffff, 0xffff,
233 },
234 {
235 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
236 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
237 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
238 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
239 0xe6ff, 0xfffd, 0xfff8,
240 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
241 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
242 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
243 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
244 0xf8f8, 0xf8f8, 0xfff8,
245 },
246 {
247 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
248 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
249 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
250 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
251 0x99c7, 0xaba8, 0xffa4,
252 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
253 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
254 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
255 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
256 0xa4a4, 0xa4a4, 0xffa4,
257 },
258 {
259 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
260 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
261 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
262 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
263 0x7396, 0x817e, 0xff7c,
264 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
265 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
266 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
267 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
268 0x7c7c, 0x7c7c, 0xff7c,
269 },
270 {
271 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
272 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
273 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
274 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
275 0x5c78, 0x6765, 0xff63,
276 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
277 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
278 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
279 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
280 0x6363, 0x6363, 0xff63,
281 },
282 {
283 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
284 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
285 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
286 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
287 0x4a60, 0x5251, 0xff4f,
288 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
289 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
290 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
291 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
292 0x4f4f, 0x4f4f, 0xff4f,
293 },
294 {
295 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
296 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
297 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
298 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
299 0x3748, 0x3e3d, 0xff3b,
300 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
301 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
302 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
303 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
304 0x3b3b, 0x3b3b, 0xff3b,
305 },
306 {
307 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
308 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
309 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
310 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
311 0x2530, 0x2928, 0xff28,
312 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
313 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
314 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
315 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
316 0x2828, 0x2828, 0xff28,
317 },
318 {
319 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
320 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
321 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
322 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
323 0x1218, 0x1514, 0xff14,
324 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
325 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
326 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
327 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
328 0x1414, 0x1414, 0xff14,
329 },
330 {
331 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
332 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
333 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
334 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
335 0x0101, 0x0101, 0xff01,
336 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
337 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
338 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
339 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
340 0x0101, 0x0101, 0xff01,
341 } };
342
343 if (quality < 0 || quality > 10) {
344 printk(KERN_WARNING
345 "meye: invalid quality level %d - using 8\n", quality);
346 quality = 8;
347 }
348
349 *length = ARRAY_SIZE(jpeg_tables[quality]);
350 return jpeg_tables[quality];
351 }
352
353 /* return a generic set of huffman tables */
354 static u16 *jpeg_huffman_tables(int *length)
355 {
356 static u16 tables[] = {
357 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
358 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
359 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
360 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
361 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
362 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
363 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
364 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
365 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
366 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
367 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
368 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
369 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
370 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
371 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
372 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
373 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
374 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
375 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
376 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
377 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
378 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
379 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
380 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
381 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
382 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
383 0xFF0B,
384 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
385 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
386 0xFF0B
387 };
388
389 *length = ARRAY_SIZE(tables);
390 return tables;
391 }
392
393 /****************************************************************************/
394 /* MCHIP low-level functions */
395 /****************************************************************************/
396
397 /* returns the horizontal capture size */
398 static inline int mchip_hsize(void)
399 {
400 return meye.params.subsample ? 320 : 640;
401 }
402
403 /* returns the vertical capture size */
404 static inline int mchip_vsize(void)
405 {
406 return meye.params.subsample ? 240 : 480;
407 }
408
409 /* waits for a register to be available */
410 static void mchip_sync(int reg)
411 {
412 u32 status;
413 int i;
414
415 if (reg == MCHIP_MM_FIFO_DATA) {
416 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
417 status = readl(meye.mchip_mmregs +
418 MCHIP_MM_FIFO_STATUS);
419 if (!(status & MCHIP_MM_FIFO_WAIT)) {
420 printk(KERN_WARNING "meye: fifo not ready\n");
421 return;
422 }
423 if (status & MCHIP_MM_FIFO_READY)
424 return;
425 udelay(1);
426 }
427 } else if (reg > 0x80) {
428 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
429 : MCHIP_HIC_STATUS_VRJ_RDY;
430 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
431 status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
432 if (status & mask)
433 return;
434 udelay(1);
435 }
436 } else
437 return;
438 printk(KERN_WARNING
439 "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
440 reg, status);
441 }
442
443 /* sets a value into the register */
444 static inline void mchip_set(int reg, u32 v)
445 {
446 mchip_sync(reg);
447 writel(v, meye.mchip_mmregs + reg);
448 }
449
450 /* get the register value */
451 static inline u32 mchip_read(int reg)
452 {
453 mchip_sync(reg);
454 return readl(meye.mchip_mmregs + reg);
455 }
456
457 /* wait for a register to become a particular value */
458 static inline int mchip_delay(u32 reg, u32 v)
459 {
460 int n = 10;
461 while (--n && mchip_read(reg) != v)
462 udelay(1);
463 return n;
464 }
465
466 /* setup subsampling */
467 static void mchip_subsample(void)
468 {
469 mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
470 mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
471 mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
472 mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
473 mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
474 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
475 }
476
477 /* set the framerate into the mchip */
478 static void mchip_set_framerate(void)
479 {
480 mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
481 }
482
483 /* load some huffman and quantisation tables into the VRJ chip ready
484 for JPEG compression */
485 static void mchip_load_tables(void)
486 {
487 int i;
488 int length;
489 u16 *tables;
490
491 tables = jpeg_huffman_tables(&length);
492 for (i = 0; i < length; i++)
493 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
494
495 tables = jpeg_quantisation_tables(&length, meye.params.quality);
496 for (i = 0; i < length; i++)
497 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
498 }
499
500 /* setup the VRJ parameters in the chip */
501 static void mchip_vrj_setup(u8 mode)
502 {
503 mchip_set(MCHIP_VRJ_BUS_MODE, 5);
504 mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
505 mchip_set(MCHIP_VRJ_PDAT_USE, 1);
506 mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
507 mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
508 mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
509 mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
510 mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
511 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
512 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
513 mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
514 mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
515 mchip_set(MCHIP_VRJ_SOF1, 0x601);
516 mchip_set(MCHIP_VRJ_SOF2, 0x1502);
517 mchip_set(MCHIP_VRJ_SOF3, 0x1503);
518 mchip_set(MCHIP_VRJ_SOF4, 0x1596);
519 mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
520
521 mchip_load_tables();
522 }
523
524 /* sets the DMA parameters into the chip */
525 static void mchip_dma_setup(dma_addr_t dma_addr)
526 {
527 int i;
528
529 mchip_set(MCHIP_MM_PT_ADDR, (u32)dma_addr);
530 for (i = 0; i < 4; i++)
531 mchip_set(MCHIP_MM_FIR(i), 0);
532 meye.mchip_fnum = 0;
533 }
534
535 /* setup for DMA transfers - also zeros the framebuffer */
536 static int mchip_dma_alloc(void)
537 {
538 if (!meye.mchip_dmahandle)
539 if (ptable_alloc())
540 return -1;
541 return 0;
542 }
543
544 /* frees the DMA buffer */
545 static void mchip_dma_free(void)
546 {
547 if (meye.mchip_dmahandle) {
548 mchip_dma_setup(0);
549 ptable_free();
550 }
551 }
552
553 /* stop any existing HIC action and wait for any dma to complete then
554 reset the dma engine */
555 static void mchip_hic_stop(void)
556 {
557 int i, j;
558
559 meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
560 if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
561 return;
562 for (i = 0; i < 20; ++i) {
563 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
564 mchip_delay(MCHIP_HIC_CMD, 0);
565 for (j = 0; j < 100; ++j) {
566 if (mchip_delay(MCHIP_HIC_STATUS,
567 MCHIP_HIC_STATUS_IDLE))
568 return;
569 msleep(1);
570 }
571 printk(KERN_ERR "meye: need to reset HIC!\n");
572
573 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
574 msleep(250);
575 }
576 printk(KERN_ERR "meye: resetting HIC hanged!\n");
577 }
578
579 /****************************************************************************/
580 /* MCHIP frame processing functions */
581 /****************************************************************************/
582
583 /* get the next ready frame from the dma engine */
584 static u32 mchip_get_frame(void)
585 {
586 u32 v;
587
588 v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
589 return v;
590 }
591
592 /* frees the current frame from the dma engine */
593 static void mchip_free_frame(void)
594 {
595 mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
596 meye.mchip_fnum++;
597 meye.mchip_fnum %= 4;
598 }
599
600 /* read one frame from the framebuffer assuming it was captured using
601 a uncompressed transfer */
602 static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
603 {
604 int pt_id;
605
606 pt_id = (v >> 17) & 0x3FF;
607
608 ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
609 }
610
611 /* read a compressed frame from the framebuffer */
612 static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
613 {
614 int pt_start, pt_end, trailer;
615 int fsize;
616 int i;
617
618 pt_start = (v >> 19) & 0xFF;
619 pt_end = (v >> 11) & 0xFF;
620 trailer = (v >> 1) & 0x3FF;
621
622 if (pt_end < pt_start)
623 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
624 pt_end * PAGE_SIZE + trailer * 4;
625 else
626 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
627
628 if (fsize > size) {
629 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
630 fsize);
631 return -1;
632 }
633
634 ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
635
636 #ifdef MEYE_JPEG_CORRECTION
637
638 /* Some mchip generated jpeg frames are incorrect. In most
639 * (all ?) of those cases, the final EOI (0xff 0xd9) marker
640 * is not present at the end of the frame.
641 *
642 * Since adding the final marker is not enough to restore
643 * the jpeg integrity, we drop the frame.
644 */
645
646 for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
647
648 if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
649 return -1;
650
651 #endif
652
653 return fsize;
654 }
655
656 /* take a picture into SDRAM */
657 static void mchip_take_picture(void)
658 {
659 int i;
660
661 mchip_hic_stop();
662 mchip_subsample();
663 mchip_dma_setup(meye.mchip_dmahandle);
664
665 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
666 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
667
668 mchip_delay(MCHIP_HIC_CMD, 0);
669
670 for (i = 0; i < 100; ++i) {
671 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
672 break;
673 msleep(1);
674 }
675 }
676
677 /* dma a previously taken picture into a buffer */
678 static void mchip_get_picture(u8 *buf, int bufsize)
679 {
680 u32 v;
681 int i;
682
683 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
684 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
685
686 mchip_delay(MCHIP_HIC_CMD, 0);
687 for (i = 0; i < 100; ++i) {
688 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
689 break;
690 msleep(1);
691 }
692 for (i = 0; i < 4; ++i) {
693 v = mchip_get_frame();
694 if (v & MCHIP_MM_FIR_RDY) {
695 mchip_cont_read_frame(v, buf, bufsize);
696 break;
697 }
698 mchip_free_frame();
699 }
700 }
701
702 /* start continuous dma capture */
703 static void mchip_continuous_start(void)
704 {
705 mchip_hic_stop();
706 mchip_subsample();
707 mchip_set_framerate();
708 mchip_dma_setup(meye.mchip_dmahandle);
709
710 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
711
712 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
713 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
714
715 mchip_delay(MCHIP_HIC_CMD, 0);
716 }
717
718 /* compress one frame into a buffer */
719 static int mchip_compress_frame(u8 *buf, int bufsize)
720 {
721 u32 v;
722 int len = -1, i;
723
724 mchip_vrj_setup(0x3f);
725 udelay(50);
726
727 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
728 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
729
730 mchip_delay(MCHIP_HIC_CMD, 0);
731 for (i = 0; i < 100; ++i) {
732 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
733 break;
734 msleep(1);
735 }
736
737 for (i = 0; i < 4; ++i) {
738 v = mchip_get_frame();
739 if (v & MCHIP_MM_FIR_RDY) {
740 len = mchip_comp_read_frame(v, buf, bufsize);
741 break;
742 }
743 mchip_free_frame();
744 }
745 return len;
746 }
747
748 #if 0
749 /* uncompress one image into a buffer */
750 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
751 {
752 mchip_vrj_setup(0x3f);
753 udelay(50);
754
755 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
756 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
757
758 mchip_delay(MCHIP_HIC_CMD, 0);
759
760 return mchip_comp_read_frame(buf, bufsize);
761 }
762 #endif
763
764 /* start continuous compressed capture */
765 static void mchip_cont_compression_start(void)
766 {
767 mchip_hic_stop();
768 mchip_vrj_setup(0x3f);
769 mchip_subsample();
770 mchip_set_framerate();
771 mchip_dma_setup(meye.mchip_dmahandle);
772
773 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
774
775 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
776 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
777
778 mchip_delay(MCHIP_HIC_CMD, 0);
779 }
780
781 /****************************************************************************/
782 /* Interrupt handling */
783 /****************************************************************************/
784
785 static irqreturn_t meye_irq(int irq, void *dev_id)
786 {
787 u32 v;
788 int reqnr;
789 static int sequence;
790
791 v = mchip_read(MCHIP_MM_INTA);
792
793 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
794 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
795 return IRQ_NONE;
796
797 again:
798 v = mchip_get_frame();
799 if (!(v & MCHIP_MM_FIR_RDY))
800 return IRQ_HANDLED;
801
802 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
803 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
804 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
805 mchip_free_frame();
806 return IRQ_HANDLED;
807 }
808 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
809 mchip_hsize() * mchip_vsize() * 2);
810 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
811 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
812 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
813 meye.grab_buffer[reqnr].sequence = sequence++;
814 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
815 sizeof(int), &meye.doneq_lock);
816 wake_up_interruptible(&meye.proc_list);
817 } else {
818 int size;
819 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
820 if (size == -1) {
821 mchip_free_frame();
822 goto again;
823 }
824 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
825 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
826 mchip_free_frame();
827 goto again;
828 }
829 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
830 size);
831 meye.grab_buffer[reqnr].size = size;
832 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
833 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
834 meye.grab_buffer[reqnr].sequence = sequence++;
835 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
836 sizeof(int), &meye.doneq_lock);
837 wake_up_interruptible(&meye.proc_list);
838 }
839 mchip_free_frame();
840 goto again;
841 }
842
843 /****************************************************************************/
844 /* video4linux integration */
845 /****************************************************************************/
846
847 static int meye_open(struct file *file)
848 {
849 int i;
850
851 if (test_and_set_bit(0, &meye.in_use))
852 return -EBUSY;
853
854 mchip_hic_stop();
855
856 if (mchip_dma_alloc()) {
857 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
858 clear_bit(0, &meye.in_use);
859 return -ENOBUFS;
860 }
861
862 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
863 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
864 kfifo_reset(&meye.grabq);
865 kfifo_reset(&meye.doneq);
866 return 0;
867 }
868
869 static int meye_release(struct file *file)
870 {
871 mchip_hic_stop();
872 mchip_dma_free();
873 clear_bit(0, &meye.in_use);
874 return 0;
875 }
876
877 static int meyeioc_g_params(struct meye_params *p)
878 {
879 *p = meye.params;
880 return 0;
881 }
882
883 static int meyeioc_s_params(struct meye_params *jp)
884 {
885 if (jp->subsample > 1)
886 return -EINVAL;
887
888 if (jp->quality > 10)
889 return -EINVAL;
890
891 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
892 return -EINVAL;
893
894 if (jp->framerate > 31)
895 return -EINVAL;
896
897 mutex_lock(&meye.lock);
898
899 if (meye.params.subsample != jp->subsample ||
900 meye.params.quality != jp->quality)
901 mchip_hic_stop(); /* need restart */
902
903 meye.params = *jp;
904 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
905 meye.params.sharpness);
906 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
907 meye.params.agc);
908 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
909 meye.params.picture);
910 mutex_unlock(&meye.lock);
911
912 return 0;
913 }
914
915 static int meyeioc_qbuf_capt(int *nb)
916 {
917 if (!meye.grab_fbuffer)
918 return -EINVAL;
919
920 if (*nb >= gbuffers)
921 return -EINVAL;
922
923 if (*nb < 0) {
924 /* stop capture */
925 mchip_hic_stop();
926 return 0;
927 }
928
929 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
930 return -EBUSY;
931
932 mutex_lock(&meye.lock);
933
934 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
935 mchip_cont_compression_start();
936
937 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
938 kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
939 &meye.grabq_lock);
940 mutex_unlock(&meye.lock);
941
942 return 0;
943 }
944
945 static int meyeioc_sync(struct file *file, void *fh, int *i)
946 {
947 int unused;
948
949 if (*i < 0 || *i >= gbuffers)
950 return -EINVAL;
951
952 mutex_lock(&meye.lock);
953 switch (meye.grab_buffer[*i].state) {
954
955 case MEYE_BUF_UNUSED:
956 mutex_unlock(&meye.lock);
957 return -EINVAL;
958 case MEYE_BUF_USING:
959 if (file->f_flags & O_NONBLOCK) {
960 mutex_unlock(&meye.lock);
961 return -EAGAIN;
962 }
963 if (wait_event_interruptible(meye.proc_list,
964 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
965 mutex_unlock(&meye.lock);
966 return -EINTR;
967 }
968 /* fall through */
969 case MEYE_BUF_DONE:
970 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
971 kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
972 sizeof(int), &meye.doneq_lock);
973 }
974 *i = meye.grab_buffer[*i].size;
975 mutex_unlock(&meye.lock);
976 return 0;
977 }
978
979 static int meyeioc_stillcapt(void)
980 {
981 if (!meye.grab_fbuffer)
982 return -EINVAL;
983
984 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
985 return -EBUSY;
986
987 mutex_lock(&meye.lock);
988 meye.grab_buffer[0].state = MEYE_BUF_USING;
989 mchip_take_picture();
990
991 mchip_get_picture(meye.grab_fbuffer,
992 mchip_hsize() * mchip_vsize() * 2);
993
994 meye.grab_buffer[0].state = MEYE_BUF_DONE;
995 mutex_unlock(&meye.lock);
996
997 return 0;
998 }
999
1000 static int meyeioc_stilljcapt(int *len)
1001 {
1002 if (!meye.grab_fbuffer)
1003 return -EINVAL;
1004
1005 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1006 return -EBUSY;
1007
1008 mutex_lock(&meye.lock);
1009 meye.grab_buffer[0].state = MEYE_BUF_USING;
1010 *len = -1;
1011
1012 while (*len == -1) {
1013 mchip_take_picture();
1014 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1015 }
1016
1017 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1018 mutex_unlock(&meye.lock);
1019 return 0;
1020 }
1021
1022 static int vidioc_querycap(struct file *file, void *fh,
1023 struct v4l2_capability *cap)
1024 {
1025 strcpy(cap->driver, "meye");
1026 strcpy(cap->card, "meye");
1027 sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1028
1029 cap->version = (MEYE_DRIVER_MAJORVERSION << 8) +
1030 MEYE_DRIVER_MINORVERSION;
1031
1032 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1033 V4L2_CAP_STREAMING;
1034
1035 return 0;
1036 }
1037
1038 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1039 {
1040 if (i->index != 0)
1041 return -EINVAL;
1042
1043 strcpy(i->name, "Camera");
1044 i->type = V4L2_INPUT_TYPE_CAMERA;
1045
1046 return 0;
1047 }
1048
1049 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1050 {
1051 *i = 0;
1052 return 0;
1053 }
1054
1055 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1056 {
1057 if (i != 0)
1058 return -EINVAL;
1059
1060 return 0;
1061 }
1062
1063 static int vidioc_queryctrl(struct file *file, void *fh,
1064 struct v4l2_queryctrl *c)
1065 {
1066 switch (c->id) {
1067
1068 case V4L2_CID_BRIGHTNESS:
1069 c->type = V4L2_CTRL_TYPE_INTEGER;
1070 strcpy(c->name, "Brightness");
1071 c->minimum = 0;
1072 c->maximum = 63;
1073 c->step = 1;
1074 c->default_value = 32;
1075 c->flags = 0;
1076 break;
1077 case V4L2_CID_HUE:
1078 c->type = V4L2_CTRL_TYPE_INTEGER;
1079 strcpy(c->name, "Hue");
1080 c->minimum = 0;
1081 c->maximum = 63;
1082 c->step = 1;
1083 c->default_value = 32;
1084 c->flags = 0;
1085 break;
1086 case V4L2_CID_CONTRAST:
1087 c->type = V4L2_CTRL_TYPE_INTEGER;
1088 strcpy(c->name, "Contrast");
1089 c->minimum = 0;
1090 c->maximum = 63;
1091 c->step = 1;
1092 c->default_value = 32;
1093 c->flags = 0;
1094 break;
1095 case V4L2_CID_SATURATION:
1096 c->type = V4L2_CTRL_TYPE_INTEGER;
1097 strcpy(c->name, "Saturation");
1098 c->minimum = 0;
1099 c->maximum = 63;
1100 c->step = 1;
1101 c->default_value = 32;
1102 c->flags = 0;
1103 break;
1104 case V4L2_CID_AGC:
1105 c->type = V4L2_CTRL_TYPE_INTEGER;
1106 strcpy(c->name, "Agc");
1107 c->minimum = 0;
1108 c->maximum = 63;
1109 c->step = 1;
1110 c->default_value = 48;
1111 c->flags = 0;
1112 break;
1113 case V4L2_CID_MEYE_SHARPNESS:
1114 case V4L2_CID_SHARPNESS:
1115 c->type = V4L2_CTRL_TYPE_INTEGER;
1116 strcpy(c->name, "Sharpness");
1117 c->minimum = 0;
1118 c->maximum = 63;
1119 c->step = 1;
1120 c->default_value = 32;
1121
1122 /* Continue to report legacy private SHARPNESS ctrl but
1123 * say it is disabled in preference to ctrl in the spec
1124 */
1125 c->flags = (c->id == V4L2_CID_SHARPNESS) ? 0 :
1126 V4L2_CTRL_FLAG_DISABLED;
1127 break;
1128 case V4L2_CID_PICTURE:
1129 c->type = V4L2_CTRL_TYPE_INTEGER;
1130 strcpy(c->name, "Picture");
1131 c->minimum = 0;
1132 c->maximum = 63;
1133 c->step = 1;
1134 c->default_value = 0;
1135 c->flags = 0;
1136 break;
1137 case V4L2_CID_JPEGQUAL:
1138 c->type = V4L2_CTRL_TYPE_INTEGER;
1139 strcpy(c->name, "JPEG quality");
1140 c->minimum = 0;
1141 c->maximum = 10;
1142 c->step = 1;
1143 c->default_value = 8;
1144 c->flags = 0;
1145 break;
1146 case V4L2_CID_FRAMERATE:
1147 c->type = V4L2_CTRL_TYPE_INTEGER;
1148 strcpy(c->name, "Framerate");
1149 c->minimum = 0;
1150 c->maximum = 31;
1151 c->step = 1;
1152 c->default_value = 0;
1153 c->flags = 0;
1154 break;
1155 default:
1156 return -EINVAL;
1157 }
1158
1159 return 0;
1160 }
1161
1162 static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1163 {
1164 mutex_lock(&meye.lock);
1165 switch (c->id) {
1166 case V4L2_CID_BRIGHTNESS:
1167 sony_pic_camera_command(
1168 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, c->value);
1169 meye.picture.brightness = c->value << 10;
1170 break;
1171 case V4L2_CID_HUE:
1172 sony_pic_camera_command(
1173 SONY_PIC_COMMAND_SETCAMERAHUE, c->value);
1174 meye.picture.hue = c->value << 10;
1175 break;
1176 case V4L2_CID_CONTRAST:
1177 sony_pic_camera_command(
1178 SONY_PIC_COMMAND_SETCAMERACONTRAST, c->value);
1179 meye.picture.contrast = c->value << 10;
1180 break;
1181 case V4L2_CID_SATURATION:
1182 sony_pic_camera_command(
1183 SONY_PIC_COMMAND_SETCAMERACOLOR, c->value);
1184 meye.picture.colour = c->value << 10;
1185 break;
1186 case V4L2_CID_AGC:
1187 sony_pic_camera_command(
1188 SONY_PIC_COMMAND_SETCAMERAAGC, c->value);
1189 meye.params.agc = c->value;
1190 break;
1191 case V4L2_CID_SHARPNESS:
1192 case V4L2_CID_MEYE_SHARPNESS:
1193 sony_pic_camera_command(
1194 SONY_PIC_COMMAND_SETCAMERASHARPNESS, c->value);
1195 meye.params.sharpness = c->value;
1196 break;
1197 case V4L2_CID_PICTURE:
1198 sony_pic_camera_command(
1199 SONY_PIC_COMMAND_SETCAMERAPICTURE, c->value);
1200 meye.params.picture = c->value;
1201 break;
1202 case V4L2_CID_JPEGQUAL:
1203 meye.params.quality = c->value;
1204 break;
1205 case V4L2_CID_FRAMERATE:
1206 meye.params.framerate = c->value;
1207 break;
1208 default:
1209 mutex_unlock(&meye.lock);
1210 return -EINVAL;
1211 }
1212 mutex_unlock(&meye.lock);
1213
1214 return 0;
1215 }
1216
1217 static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1218 {
1219 mutex_lock(&meye.lock);
1220 switch (c->id) {
1221 case V4L2_CID_BRIGHTNESS:
1222 c->value = meye.picture.brightness >> 10;
1223 break;
1224 case V4L2_CID_HUE:
1225 c->value = meye.picture.hue >> 10;
1226 break;
1227 case V4L2_CID_CONTRAST:
1228 c->value = meye.picture.contrast >> 10;
1229 break;
1230 case V4L2_CID_SATURATION:
1231 c->value = meye.picture.colour >> 10;
1232 break;
1233 case V4L2_CID_AGC:
1234 c->value = meye.params.agc;
1235 break;
1236 case V4L2_CID_SHARPNESS:
1237 case V4L2_CID_MEYE_SHARPNESS:
1238 c->value = meye.params.sharpness;
1239 break;
1240 case V4L2_CID_PICTURE:
1241 c->value = meye.params.picture;
1242 break;
1243 case V4L2_CID_JPEGQUAL:
1244 c->value = meye.params.quality;
1245 break;
1246 case V4L2_CID_FRAMERATE:
1247 c->value = meye.params.framerate;
1248 break;
1249 default:
1250 mutex_unlock(&meye.lock);
1251 return -EINVAL;
1252 }
1253 mutex_unlock(&meye.lock);
1254
1255 return 0;
1256 }
1257
1258 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1259 struct v4l2_fmtdesc *f)
1260 {
1261 if (f->index > 1)
1262 return -EINVAL;
1263
1264 if (f->index == 0) {
1265 /* standard YUV 422 capture */
1266 f->flags = 0;
1267 strcpy(f->description, "YUV422");
1268 f->pixelformat = V4L2_PIX_FMT_YUYV;
1269 } else {
1270 /* compressed MJPEG capture */
1271 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1272 strcpy(f->description, "MJPEG");
1273 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1274 }
1275
1276 return 0;
1277 }
1278
1279 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1280 struct v4l2_format *f)
1281 {
1282 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1283 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1284 return -EINVAL;
1285
1286 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1287 f->fmt.pix.field != V4L2_FIELD_NONE)
1288 return -EINVAL;
1289
1290 f->fmt.pix.field = V4L2_FIELD_NONE;
1291
1292 if (f->fmt.pix.width <= 320) {
1293 f->fmt.pix.width = 320;
1294 f->fmt.pix.height = 240;
1295 } else {
1296 f->fmt.pix.width = 640;
1297 f->fmt.pix.height = 480;
1298 }
1299
1300 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1301 f->fmt.pix.sizeimage = f->fmt.pix.height *
1302 f->fmt.pix.bytesperline;
1303 f->fmt.pix.colorspace = 0;
1304 f->fmt.pix.priv = 0;
1305
1306 return 0;
1307 }
1308
1309 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1310 struct v4l2_format *f)
1311 {
1312 switch (meye.mchip_mode) {
1313 case MCHIP_HIC_MODE_CONT_OUT:
1314 default:
1315 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1316 break;
1317 case MCHIP_HIC_MODE_CONT_COMP:
1318 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1319 break;
1320 }
1321
1322 f->fmt.pix.field = V4L2_FIELD_NONE;
1323 f->fmt.pix.width = mchip_hsize();
1324 f->fmt.pix.height = mchip_vsize();
1325 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1326 f->fmt.pix.sizeimage = f->fmt.pix.height *
1327 f->fmt.pix.bytesperline;
1328
1329 return 0;
1330 }
1331
1332 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1333 struct v4l2_format *f)
1334 {
1335 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1336 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1337 return -EINVAL;
1338
1339 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1340 f->fmt.pix.field != V4L2_FIELD_NONE)
1341 return -EINVAL;
1342
1343 f->fmt.pix.field = V4L2_FIELD_NONE;
1344 mutex_lock(&meye.lock);
1345
1346 if (f->fmt.pix.width <= 320) {
1347 f->fmt.pix.width = 320;
1348 f->fmt.pix.height = 240;
1349 meye.params.subsample = 1;
1350 } else {
1351 f->fmt.pix.width = 640;
1352 f->fmt.pix.height = 480;
1353 meye.params.subsample = 0;
1354 }
1355
1356 switch (f->fmt.pix.pixelformat) {
1357 case V4L2_PIX_FMT_YUYV:
1358 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1359 break;
1360 case V4L2_PIX_FMT_MJPEG:
1361 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1362 break;
1363 }
1364
1365 mutex_unlock(&meye.lock);
1366 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1367 f->fmt.pix.sizeimage = f->fmt.pix.height *
1368 f->fmt.pix.bytesperline;
1369 f->fmt.pix.colorspace = 0;
1370 f->fmt.pix.priv = 0;
1371
1372 return 0;
1373 }
1374
1375 static int vidioc_reqbufs(struct file *file, void *fh,
1376 struct v4l2_requestbuffers *req)
1377 {
1378 int i;
1379
1380 if (req->memory != V4L2_MEMORY_MMAP)
1381 return -EINVAL;
1382
1383 if (meye.grab_fbuffer && req->count == gbuffers) {
1384 /* already allocated, no modifications */
1385 return 0;
1386 }
1387
1388 mutex_lock(&meye.lock);
1389 if (meye.grab_fbuffer) {
1390 for (i = 0; i < gbuffers; i++)
1391 if (meye.vma_use_count[i]) {
1392 mutex_unlock(&meye.lock);
1393 return -EINVAL;
1394 }
1395 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1396 meye.grab_fbuffer = NULL;
1397 }
1398
1399 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1400 req->count = gbuffers;
1401 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1402
1403 if (!meye.grab_fbuffer) {
1404 printk(KERN_ERR "meye: v4l framebuffer allocation"
1405 " failed\n");
1406 mutex_unlock(&meye.lock);
1407 return -ENOMEM;
1408 }
1409
1410 for (i = 0; i < gbuffers; i++)
1411 meye.vma_use_count[i] = 0;
1412
1413 mutex_unlock(&meye.lock);
1414
1415 return 0;
1416 }
1417
1418 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1419 {
1420 unsigned int index = buf->index;
1421
1422 if (index >= gbuffers)
1423 return -EINVAL;
1424
1425 buf->bytesused = meye.grab_buffer[index].size;
1426 buf->flags = V4L2_BUF_FLAG_MAPPED;
1427
1428 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1429 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1430
1431 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1432 buf->flags |= V4L2_BUF_FLAG_DONE;
1433
1434 buf->field = V4L2_FIELD_NONE;
1435 buf->timestamp = meye.grab_buffer[index].timestamp;
1436 buf->sequence = meye.grab_buffer[index].sequence;
1437 buf->memory = V4L2_MEMORY_MMAP;
1438 buf->m.offset = index * gbufsize;
1439 buf->length = gbufsize;
1440
1441 return 0;
1442 }
1443
1444 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1445 {
1446 if (buf->memory != V4L2_MEMORY_MMAP)
1447 return -EINVAL;
1448
1449 if (buf->index >= gbuffers)
1450 return -EINVAL;
1451
1452 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1453 return -EINVAL;
1454
1455 mutex_lock(&meye.lock);
1456 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1457 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1458 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1459 kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
1460 sizeof(int), &meye.grabq_lock);
1461 mutex_unlock(&meye.lock);
1462
1463 return 0;
1464 }
1465
1466 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1467 {
1468 int reqnr;
1469
1470 if (buf->memory != V4L2_MEMORY_MMAP)
1471 return -EINVAL;
1472
1473 mutex_lock(&meye.lock);
1474
1475 if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1476 mutex_unlock(&meye.lock);
1477 return -EAGAIN;
1478 }
1479
1480 if (wait_event_interruptible(meye.proc_list,
1481 kfifo_len(&meye.doneq) != 0) < 0) {
1482 mutex_unlock(&meye.lock);
1483 return -EINTR;
1484 }
1485
1486 if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
1487 sizeof(int), &meye.doneq_lock)) {
1488 mutex_unlock(&meye.lock);
1489 return -EBUSY;
1490 }
1491
1492 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1493 mutex_unlock(&meye.lock);
1494 return -EINVAL;
1495 }
1496
1497 buf->index = reqnr;
1498 buf->bytesused = meye.grab_buffer[reqnr].size;
1499 buf->flags = V4L2_BUF_FLAG_MAPPED;
1500 buf->field = V4L2_FIELD_NONE;
1501 buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1502 buf->sequence = meye.grab_buffer[reqnr].sequence;
1503 buf->memory = V4L2_MEMORY_MMAP;
1504 buf->m.offset = reqnr * gbufsize;
1505 buf->length = gbufsize;
1506 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1507 mutex_unlock(&meye.lock);
1508
1509 return 0;
1510 }
1511
1512 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1513 {
1514 mutex_lock(&meye.lock);
1515
1516 switch (meye.mchip_mode) {
1517 case MCHIP_HIC_MODE_CONT_OUT:
1518 mchip_continuous_start();
1519 break;
1520 case MCHIP_HIC_MODE_CONT_COMP:
1521 mchip_cont_compression_start();
1522 break;
1523 default:
1524 mutex_unlock(&meye.lock);
1525 return -EINVAL;
1526 }
1527
1528 mutex_unlock(&meye.lock);
1529
1530 return 0;
1531 }
1532
1533 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1534 {
1535 mutex_lock(&meye.lock);
1536 mchip_hic_stop();
1537 kfifo_reset(&meye.grabq);
1538 kfifo_reset(&meye.doneq);
1539
1540 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1541 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1542
1543 mutex_unlock(&meye.lock);
1544 return 0;
1545 }
1546
1547 static long vidioc_default(struct file *file, void *fh, int cmd, void *arg)
1548 {
1549 switch (cmd) {
1550 case MEYEIOC_G_PARAMS:
1551 return meyeioc_g_params((struct meye_params *) arg);
1552
1553 case MEYEIOC_S_PARAMS:
1554 return meyeioc_s_params((struct meye_params *) arg);
1555
1556 case MEYEIOC_QBUF_CAPT:
1557 return meyeioc_qbuf_capt((int *) arg);
1558
1559 case MEYEIOC_SYNC:
1560 return meyeioc_sync(file, fh, (int *) arg);
1561
1562 case MEYEIOC_STILLCAPT:
1563 return meyeioc_stillcapt();
1564
1565 case MEYEIOC_STILLJCAPT:
1566 return meyeioc_stilljcapt((int *) arg);
1567
1568 default:
1569 return -EINVAL;
1570 }
1571
1572 }
1573
1574 static unsigned int meye_poll(struct file *file, poll_table *wait)
1575 {
1576 unsigned int res = 0;
1577
1578 mutex_lock(&meye.lock);
1579 poll_wait(file, &meye.proc_list, wait);
1580 if (kfifo_len(&meye.doneq))
1581 res = POLLIN | POLLRDNORM;
1582 mutex_unlock(&meye.lock);
1583 return res;
1584 }
1585
1586 static void meye_vm_open(struct vm_area_struct *vma)
1587 {
1588 long idx = (long)vma->vm_private_data;
1589 meye.vma_use_count[idx]++;
1590 }
1591
1592 static void meye_vm_close(struct vm_area_struct *vma)
1593 {
1594 long idx = (long)vma->vm_private_data;
1595 meye.vma_use_count[idx]--;
1596 }
1597
1598 static const struct vm_operations_struct meye_vm_ops = {
1599 .open = meye_vm_open,
1600 .close = meye_vm_close,
1601 };
1602
1603 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1604 {
1605 unsigned long start = vma->vm_start;
1606 unsigned long size = vma->vm_end - vma->vm_start;
1607 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1608 unsigned long page, pos;
1609
1610 mutex_lock(&meye.lock);
1611 if (size > gbuffers * gbufsize) {
1612 mutex_unlock(&meye.lock);
1613 return -EINVAL;
1614 }
1615 if (!meye.grab_fbuffer) {
1616 int i;
1617
1618 /* lazy allocation */
1619 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1620 if (!meye.grab_fbuffer) {
1621 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1622 mutex_unlock(&meye.lock);
1623 return -ENOMEM;
1624 }
1625 for (i = 0; i < gbuffers; i++)
1626 meye.vma_use_count[i] = 0;
1627 }
1628 pos = (unsigned long)meye.grab_fbuffer + offset;
1629
1630 while (size > 0) {
1631 page = vmalloc_to_pfn((void *)pos);
1632 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1633 mutex_unlock(&meye.lock);
1634 return -EAGAIN;
1635 }
1636 start += PAGE_SIZE;
1637 pos += PAGE_SIZE;
1638 if (size > PAGE_SIZE)
1639 size -= PAGE_SIZE;
1640 else
1641 size = 0;
1642 }
1643
1644 vma->vm_ops = &meye_vm_ops;
1645 vma->vm_flags &= ~VM_IO; /* not I/O memory */
1646 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1647 vma->vm_private_data = (void *) (offset / gbufsize);
1648 meye_vm_open(vma);
1649
1650 mutex_unlock(&meye.lock);
1651 return 0;
1652 }
1653
1654 static const struct v4l2_file_operations meye_fops = {
1655 .owner = THIS_MODULE,
1656 .open = meye_open,
1657 .release = meye_release,
1658 .mmap = meye_mmap,
1659 .ioctl = video_ioctl2,
1660 .poll = meye_poll,
1661 };
1662
1663 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1664 .vidioc_querycap = vidioc_querycap,
1665 .vidioc_enum_input = vidioc_enum_input,
1666 .vidioc_g_input = vidioc_g_input,
1667 .vidioc_s_input = vidioc_s_input,
1668 .vidioc_queryctrl = vidioc_queryctrl,
1669 .vidioc_s_ctrl = vidioc_s_ctrl,
1670 .vidioc_g_ctrl = vidioc_g_ctrl,
1671 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1672 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1673 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1674 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1675 .vidioc_reqbufs = vidioc_reqbufs,
1676 .vidioc_querybuf = vidioc_querybuf,
1677 .vidioc_qbuf = vidioc_qbuf,
1678 .vidioc_dqbuf = vidioc_dqbuf,
1679 .vidioc_streamon = vidioc_streamon,
1680 .vidioc_streamoff = vidioc_streamoff,
1681 .vidioc_default = vidioc_default,
1682 };
1683
1684 static struct video_device meye_template = {
1685 .name = "meye",
1686 .fops = &meye_fops,
1687 .ioctl_ops = &meye_ioctl_ops,
1688 .release = video_device_release,
1689 };
1690
1691 #ifdef CONFIG_PM
1692 static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1693 {
1694 pci_save_state(pdev);
1695 meye.pm_mchip_mode = meye.mchip_mode;
1696 mchip_hic_stop();
1697 mchip_set(MCHIP_MM_INTA, 0x0);
1698 return 0;
1699 }
1700
1701 static int meye_resume(struct pci_dev *pdev)
1702 {
1703 pci_restore_state(pdev);
1704 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1705
1706 mchip_delay(MCHIP_HIC_CMD, 0);
1707 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1708 msleep(1);
1709 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1710 msleep(1);
1711 mchip_set(MCHIP_MM_PCI_MODE, 5);
1712 msleep(1);
1713 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1714
1715 switch (meye.pm_mchip_mode) {
1716 case MCHIP_HIC_MODE_CONT_OUT:
1717 mchip_continuous_start();
1718 break;
1719 case MCHIP_HIC_MODE_CONT_COMP:
1720 mchip_cont_compression_start();
1721 break;
1722 }
1723 return 0;
1724 }
1725 #endif
1726
1727 static int __devinit meye_probe(struct pci_dev *pcidev,
1728 const struct pci_device_id *ent)
1729 {
1730 int ret = -EBUSY;
1731 unsigned long mchip_adr;
1732
1733 if (meye.mchip_dev != NULL) {
1734 printk(KERN_ERR "meye: only one device allowed!\n");
1735 goto outnotdev;
1736 }
1737
1738 ret = -ENOMEM;
1739 meye.mchip_dev = pcidev;
1740 meye.video_dev = video_device_alloc();
1741 if (!meye.video_dev) {
1742 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1743 goto outnotdev;
1744 }
1745
1746 meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1747 if (!meye.grab_temp) {
1748 printk(KERN_ERR "meye: grab buffer allocation failed\n");
1749 goto outvmalloc;
1750 }
1751
1752 spin_lock_init(&meye.grabq_lock);
1753 if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1754 GFP_KERNEL)) {
1755 printk(KERN_ERR "meye: fifo allocation failed\n");
1756 goto outkfifoalloc1;
1757 }
1758 spin_lock_init(&meye.doneq_lock);
1759 if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1760 GFP_KERNEL)) {
1761 printk(KERN_ERR "meye: fifo allocation failed\n");
1762 goto outkfifoalloc2;
1763 }
1764
1765 memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
1766 meye.video_dev->parent = &meye.mchip_dev->dev;
1767
1768 ret = -EIO;
1769 if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
1770 printk(KERN_ERR "meye: unable to power on the camera\n");
1771 printk(KERN_ERR "meye: did you enable the camera in "
1772 "sonypi using the module options ?\n");
1773 goto outsonypienable;
1774 }
1775
1776 if ((ret = pci_enable_device(meye.mchip_dev))) {
1777 printk(KERN_ERR "meye: pci_enable_device failed\n");
1778 goto outenabledev;
1779 }
1780
1781 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1782 if (!mchip_adr) {
1783 printk(KERN_ERR "meye: mchip has no device base address\n");
1784 goto outregions;
1785 }
1786 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1787 pci_resource_len(meye.mchip_dev, 0),
1788 "meye")) {
1789 printk(KERN_ERR "meye: request_mem_region failed\n");
1790 goto outregions;
1791 }
1792 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1793 if (!meye.mchip_mmregs) {
1794 printk(KERN_ERR "meye: ioremap failed\n");
1795 goto outremap;
1796 }
1797
1798 meye.mchip_irq = pcidev->irq;
1799 if (request_irq(meye.mchip_irq, meye_irq,
1800 IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) {
1801 printk(KERN_ERR "meye: request_irq failed\n");
1802 goto outreqirq;
1803 }
1804
1805 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1806 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1807
1808 pci_set_master(meye.mchip_dev);
1809
1810 /* Ask the camera to perform a soft reset. */
1811 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1812
1813 mchip_delay(MCHIP_HIC_CMD, 0);
1814 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1815
1816 msleep(1);
1817 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1818
1819 msleep(1);
1820 mchip_set(MCHIP_MM_PCI_MODE, 5);
1821
1822 msleep(1);
1823 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1824
1825 if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER,
1826 video_nr) < 0) {
1827 printk(KERN_ERR "meye: video_register_device failed\n");
1828 goto outvideoreg;
1829 }
1830
1831 mutex_init(&meye.lock);
1832 init_waitqueue_head(&meye.proc_list);
1833 meye.picture.depth = 16;
1834 meye.picture.palette = VIDEO_PALETTE_YUV422;
1835 meye.picture.brightness = 32 << 10;
1836 meye.picture.hue = 32 << 10;
1837 meye.picture.colour = 32 << 10;
1838 meye.picture.contrast = 32 << 10;
1839 meye.picture.whiteness = 0;
1840 meye.params.subsample = 0;
1841 meye.params.quality = 8;
1842 meye.params.sharpness = 32;
1843 meye.params.agc = 48;
1844 meye.params.picture = 0;
1845 meye.params.framerate = 0;
1846
1847 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32);
1848 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32);
1849 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32);
1850 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32);
1851 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32);
1852 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1853 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
1854
1855 printk(KERN_INFO "meye: Motion Eye Camera Driver v%s.\n",
1856 MEYE_DRIVER_VERSION);
1857 printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1858 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1859
1860 return 0;
1861
1862 outvideoreg:
1863 free_irq(meye.mchip_irq, meye_irq);
1864 outreqirq:
1865 iounmap(meye.mchip_mmregs);
1866 outremap:
1867 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1868 pci_resource_len(meye.mchip_dev, 0));
1869 outregions:
1870 pci_disable_device(meye.mchip_dev);
1871 outenabledev:
1872 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1873 outsonypienable:
1874 kfifo_free(&meye.doneq);
1875 outkfifoalloc2:
1876 kfifo_free(&meye.grabq);
1877 outkfifoalloc1:
1878 vfree(meye.grab_temp);
1879 outvmalloc:
1880 video_device_release(meye.video_dev);
1881 outnotdev:
1882 return ret;
1883 }
1884
1885 static void __devexit meye_remove(struct pci_dev *pcidev)
1886 {
1887 video_unregister_device(meye.video_dev);
1888
1889 mchip_hic_stop();
1890
1891 mchip_dma_free();
1892
1893 /* disable interrupts */
1894 mchip_set(MCHIP_MM_INTA, 0x0);
1895
1896 free_irq(meye.mchip_irq, meye_irq);
1897
1898 iounmap(meye.mchip_mmregs);
1899
1900 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1901 pci_resource_len(meye.mchip_dev, 0));
1902
1903 pci_disable_device(meye.mchip_dev);
1904
1905 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1906
1907 kfifo_free(&meye.doneq);
1908 kfifo_free(&meye.grabq);
1909
1910 vfree(meye.grab_temp);
1911
1912 if (meye.grab_fbuffer) {
1913 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1914 meye.grab_fbuffer = NULL;
1915 }
1916
1917 printk(KERN_INFO "meye: removed\n");
1918 }
1919
1920 static struct pci_device_id meye_pci_tbl[] = {
1921 { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1922 { }
1923 };
1924
1925 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1926
1927 static struct pci_driver meye_driver = {
1928 .name = "meye",
1929 .id_table = meye_pci_tbl,
1930 .probe = meye_probe,
1931 .remove = __devexit_p(meye_remove),
1932 #ifdef CONFIG_PM
1933 .suspend = meye_suspend,
1934 .resume = meye_resume,
1935 #endif
1936 };
1937
1938 static int __init meye_init(void)
1939 {
1940 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1941 if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1942 gbufsize = MEYE_MAX_BUFSIZE;
1943 gbufsize = PAGE_ALIGN(gbufsize);
1944 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) "
1945 "for capture\n",
1946 gbuffers,
1947 gbufsize / 1024, gbuffers * gbufsize / 1024);
1948 return pci_register_driver(&meye_driver);
1949 }
1950
1951 static void __exit meye_exit(void)
1952 {
1953 pci_unregister_driver(&meye_driver);
1954 }
1955
1956 module_init(meye_init);
1957 module_exit(meye_exit);
ubuntu-bionic-kernel mirror