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/config.h>
30 #include <linux/module.h>
31 #include <linux/pci.h>
32 #include <linux/sched.h>
33 #include <linux/init.h>
34 #include <linux/videodev.h>
35 #include <asm/uaccess.h>
36 #include <asm/io.h>
37 #include <linux/delay.h>
38 #include <linux/interrupt.h>
39 #include <linux/vmalloc.h>
40 #include <linux/dma-mapping.h>
41
42 #include "meye.h"
43 #include <linux/meye.h>
44
45 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
46 MODULE_DESCRIPTION("v4l/v4l2 driver for the MotionEye camera");
47 MODULE_LICENSE("GPL");
48 MODULE_VERSION(MEYE_DRIVER_VERSION);
49
50 /* force usage of V4L1 API */
51 static int forcev4l1; /* = 0 */
52 module_param(forcev4l1, int, 0644);
53 MODULE_PARM_DESC(forcev4l1, "force use of V4L1 instead of V4L2");
54
55 /* number of grab buffers */
56 static unsigned int gbuffers = 2;
57 module_param(gbuffers, int, 0444);
58 MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)");
59
60 /* size of a grab buffer */
61 static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
62 module_param(gbufsize, int, 0444);
63 MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 614400"
64 " (will be rounded up to a page multiple)");
65
66 /* /dev/videoX registration number */
67 static int video_nr = -1;
68 module_param(video_nr, int, 0444);
69 MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)");
70
71 /* driver structure - only one possible */
72 static struct meye meye;
73
74 /****************************************************************************/
75 /* Memory allocation routines (stolen from bttv-driver.c) */
76 /****************************************************************************/
77 static void *rvmalloc(unsigned long size)
78 {
79 void *mem;
80 unsigned long adr;
81
82 size = PAGE_ALIGN(size);
83 mem = vmalloc_32(size);
84 if (mem) {
85 memset(mem, 0, size);
86 adr = (unsigned long) mem;
87 while (size > 0) {
88 SetPageReserved(vmalloc_to_page((void *)adr));
89 adr += PAGE_SIZE;
90 size -= PAGE_SIZE;
91 }
92 }
93 return mem;
94 }
95
96 static void rvfree(void * mem, unsigned long size)
97 {
98 unsigned long adr;
99
100 if (mem) {
101 adr = (unsigned long) mem;
102 while ((long) size > 0) {
103 ClearPageReserved(vmalloc_to_page((void *)adr));
104 adr += PAGE_SIZE;
105 size -= PAGE_SIZE;
106 }
107 vfree(mem);
108 }
109 }
110
111 /*
112 * return a page table pointing to N pages of locked memory
113 *
114 * NOTE: The meye device expects DMA addresses on 32 bits, we build
115 * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
116 */
117 static int ptable_alloc(void)
118 {
119 u32 *pt;
120 int i;
121
122 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
123
124 /* give only 32 bit DMA addresses */
125 if (dma_set_mask(&meye.mchip_dev->dev, DMA_32BIT_MASK))
126 return -1;
127
128 meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
129 PAGE_SIZE,
130 &meye.mchip_dmahandle,
131 GFP_KERNEL);
132 if (!meye.mchip_ptable_toc) {
133 meye.mchip_dmahandle = 0;
134 return -1;
135 }
136
137 pt = meye.mchip_ptable_toc;
138 for (i = 0; i < MCHIP_NB_PAGES; i++) {
139 dma_addr_t dma;
140 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
141 PAGE_SIZE,
142 &dma,
143 GFP_KERNEL);
144 if (!meye.mchip_ptable[i]) {
145 int j;
146 pt = meye.mchip_ptable_toc;
147 for (j = 0; j < i; ++j) {
148 dma = (dma_addr_t) *pt;
149 dma_free_coherent(&meye.mchip_dev->dev,
150 PAGE_SIZE,
151 meye.mchip_ptable[j], dma);
152 pt++;
153 }
154 dma_free_coherent(&meye.mchip_dev->dev,
155 PAGE_SIZE,
156 meye.mchip_ptable_toc,
157 meye.mchip_dmahandle);
158 meye.mchip_ptable_toc = NULL;
159 meye.mchip_dmahandle = 0;
160 return -1;
161 }
162 *pt = (u32) dma;
163 pt++;
164 }
165 return 0;
166 }
167
168 static void ptable_free(void)
169 {
170 u32 *pt;
171 int i;
172
173 pt = meye.mchip_ptable_toc;
174 for (i = 0; i < MCHIP_NB_PAGES; i++) {
175 dma_addr_t dma = (dma_addr_t) *pt;
176 if (meye.mchip_ptable[i])
177 dma_free_coherent(&meye.mchip_dev->dev,
178 PAGE_SIZE,
179 meye.mchip_ptable[i], dma);
180 pt++;
181 }
182
183 if (meye.mchip_ptable_toc)
184 dma_free_coherent(&meye.mchip_dev->dev,
185 PAGE_SIZE,
186 meye.mchip_ptable_toc,
187 meye.mchip_dmahandle);
188
189 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
190 meye.mchip_ptable_toc = NULL;
191 meye.mchip_dmahandle = 0;
192 }
193
194 /* copy data from ptable into buf */
195 static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
196 {
197 int i;
198
199 for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
200 memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
201 if (start >= pt_pages)
202 start = 0;
203 }
204 memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
205 }
206
207 /****************************************************************************/
208 /* JPEG tables at different qualities to load into the VRJ chip */
209 /****************************************************************************/
210
211 /* return a set of quantisation tables based on a quality from 1 to 10 */
212 static u16 *jpeg_quantisation_tables(int *length, int quality)
213 {
214 static u16 jpeg_tables[][70] = { {
215 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
216 0xffff, 0xffff, 0xffff, 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,
220 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
221 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
222 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
223 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
224 0xffff, 0xffff, 0xffff,
225 },
226 {
227 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
228 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
229 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
230 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
231 0xffff, 0xffff, 0xffff,
232 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
233 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
234 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
235 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
236 0xffff, 0xffff, 0xffff,
237 },
238 {
239 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
240 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
241 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
242 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
243 0xe6ff, 0xfffd, 0xfff8,
244 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
245 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
246 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
247 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
248 0xf8f8, 0xf8f8, 0xfff8,
249 },
250 {
251 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
252 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
253 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
254 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
255 0x99c7, 0xaba8, 0xffa4,
256 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
257 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
258 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
259 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
260 0xa4a4, 0xa4a4, 0xffa4,
261 },
262 {
263 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
264 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
265 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
266 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
267 0x7396, 0x817e, 0xff7c,
268 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
269 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
270 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
271 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
272 0x7c7c, 0x7c7c, 0xff7c,
273 },
274 {
275 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
276 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
277 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
278 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
279 0x5c78, 0x6765, 0xff63,
280 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
281 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
282 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
283 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
284 0x6363, 0x6363, 0xff63,
285 },
286 {
287 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
288 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
289 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
290 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
291 0x4a60, 0x5251, 0xff4f,
292 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
293 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
294 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
295 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
296 0x4f4f, 0x4f4f, 0xff4f,
297 },
298 {
299 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
300 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
301 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
302 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
303 0x3748, 0x3e3d, 0xff3b,
304 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
305 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
306 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
307 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
308 0x3b3b, 0x3b3b, 0xff3b,
309 },
310 {
311 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
312 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
313 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
314 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
315 0x2530, 0x2928, 0xff28,
316 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
317 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
318 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
319 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
320 0x2828, 0x2828, 0xff28,
321 },
322 {
323 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
324 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
325 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
326 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
327 0x1218, 0x1514, 0xff14,
328 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
329 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
330 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
331 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
332 0x1414, 0x1414, 0xff14,
333 },
334 {
335 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
336 0x0101, 0x0101, 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, 0xff01,
340 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
341 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
342 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
343 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
344 0x0101, 0x0101, 0xff01,
345 } };
346
347 if (quality < 0 || quality > 10) {
348 printk(KERN_WARNING
349 "meye: invalid quality level %d - using 8\n", quality);
350 quality = 8;
351 }
352
353 *length = ARRAY_SIZE(jpeg_tables[quality]);
354 return jpeg_tables[quality];
355 }
356
357 /* return a generic set of huffman tables */
358 static u16 *jpeg_huffman_tables(int *length)
359 {
360 static u16 tables[] = {
361 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
362 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
363 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
364 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
365 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
366 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
367 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
368 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
369 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
370 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
371 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
372 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
373 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
374 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
375 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
376 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
377 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
378 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
379 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
380 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
381 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
382 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
383 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
384 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
385 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
386 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
387 0xFF0B,
388 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
389 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
390 0xFF0B
391 };
392
393 *length = ARRAY_SIZE(tables);
394 return tables;
395 }
396
397 /****************************************************************************/
398 /* MCHIP low-level functions */
399 /****************************************************************************/
400
401 /* returns the horizontal capture size */
402 static inline int mchip_hsize(void)
403 {
404 return meye.params.subsample ? 320 : 640;
405 }
406
407 /* returns the vertical capture size */
408 static inline int mchip_vsize(void)
409 {
410 return meye.params.subsample ? 240 : 480;
411 }
412
413 /* waits for a register to be available */
414 static void mchip_sync(int reg)
415 {
416 u32 status;
417 int i;
418
419 if (reg == MCHIP_MM_FIFO_DATA) {
420 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
421 status = readl(meye.mchip_mmregs +
422 MCHIP_MM_FIFO_STATUS);
423 if (!(status & MCHIP_MM_FIFO_WAIT)) {
424 printk(KERN_WARNING "meye: fifo not ready\n");
425 return;
426 }
427 if (status & MCHIP_MM_FIFO_READY)
428 return;
429 udelay(1);
430 }
431 } else if (reg > 0x80) {
432 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
433 : MCHIP_HIC_STATUS_VRJ_RDY;
434 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
435 status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
436 if (status & mask)
437 return;
438 udelay(1);
439 }
440 } else
441 return;
442 printk(KERN_WARNING
443 "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
444 reg, status);
445 }
446
447 /* sets a value into the register */
448 static inline void mchip_set(int reg, u32 v)
449 {
450 mchip_sync(reg);
451 writel(v, meye.mchip_mmregs + reg);
452 }
453
454 /* get the register value */
455 static inline u32 mchip_read(int reg)
456 {
457 mchip_sync(reg);
458 return readl(meye.mchip_mmregs + reg);
459 }
460
461 /* wait for a register to become a particular value */
462 static inline int mchip_delay(u32 reg, u32 v)
463 {
464 int n = 10;
465 while (--n && mchip_read(reg) != v)
466 udelay(1);
467 return n;
468 }
469
470 /* setup subsampling */
471 static void mchip_subsample(void)
472 {
473 mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
474 mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
475 mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
476 mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
477 mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
478 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
479 }
480
481 /* set the framerate into the mchip */
482 static void mchip_set_framerate(void)
483 {
484 mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
485 }
486
487 /* load some huffman and quantisation tables into the VRJ chip ready
488 for JPEG compression */
489 static void mchip_load_tables(void)
490 {
491 int i;
492 int length;
493 u16 *tables;
494
495 tables = jpeg_huffman_tables(&length);
496 for (i = 0; i < length; i++)
497 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
498
499 tables = jpeg_quantisation_tables(&length, meye.params.quality);
500 for (i = 0; i < length; i++)
501 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
502 }
503
504 /* setup the VRJ parameters in the chip */
505 static void mchip_vrj_setup(u8 mode)
506 {
507 mchip_set(MCHIP_VRJ_BUS_MODE, 5);
508 mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
509 mchip_set(MCHIP_VRJ_PDAT_USE, 1);
510 mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
511 mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
512 mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
513 mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
514 mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
515 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
516 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
517 mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
518 mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
519 mchip_set(MCHIP_VRJ_SOF1, 0x601);
520 mchip_set(MCHIP_VRJ_SOF2, 0x1502);
521 mchip_set(MCHIP_VRJ_SOF3, 0x1503);
522 mchip_set(MCHIP_VRJ_SOF4, 0x1596);
523 mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
524
525 mchip_load_tables();
526 }
527
528 /* sets the DMA parameters into the chip */
529 static void mchip_dma_setup(dma_addr_t dma_addr)
530 {
531 int i;
532
533 mchip_set(MCHIP_MM_PT_ADDR, (u32)dma_addr);
534 for (i = 0; i < 4; i++)
535 mchip_set(MCHIP_MM_FIR(i), 0);
536 meye.mchip_fnum = 0;
537 }
538
539 /* setup for DMA transfers - also zeros the framebuffer */
540 static int mchip_dma_alloc(void)
541 {
542 if (!meye.mchip_dmahandle)
543 if (ptable_alloc())
544 return -1;
545 return 0;
546 }
547
548 /* frees the DMA buffer */
549 static void mchip_dma_free(void)
550 {
551 if (meye.mchip_dmahandle) {
552 mchip_dma_setup(0);
553 ptable_free();
554 }
555 }
556
557 /* stop any existing HIC action and wait for any dma to complete then
558 reset the dma engine */
559 static void mchip_hic_stop(void)
560 {
561 int i, j;
562
563 meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
564 if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
565 return;
566 for (i = 0; i < 20; ++i) {
567 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
568 mchip_delay(MCHIP_HIC_CMD, 0);
569 for (j = 0; j < 100; ++j) {
570 if (mchip_delay(MCHIP_HIC_STATUS,
571 MCHIP_HIC_STATUS_IDLE))
572 return;
573 msleep(1);
574 }
575 printk(KERN_ERR "meye: need to reset HIC!\n");
576
577 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
578 msleep(250);
579 }
580 printk(KERN_ERR "meye: resetting HIC hanged!\n");
581 }
582
583 /****************************************************************************/
584 /* MCHIP frame processing functions */
585 /****************************************************************************/
586
587 /* get the next ready frame from the dma engine */
588 static u32 mchip_get_frame(void)
589 {
590 u32 v;
591
592 v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
593 return v;
594 }
595
596 /* frees the current frame from the dma engine */
597 static void mchip_free_frame(void)
598 {
599 mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
600 meye.mchip_fnum++;
601 meye.mchip_fnum %= 4;
602 }
603
604 /* read one frame from the framebuffer assuming it was captured using
605 a uncompressed transfer */
606 static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
607 {
608 int pt_id;
609
610 pt_id = (v >> 17) & 0x3FF;
611
612 ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
613 }
614
615 /* read a compressed frame from the framebuffer */
616 static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
617 {
618 int pt_start, pt_end, trailer;
619 int fsize;
620 int i;
621
622 pt_start = (v >> 19) & 0xFF;
623 pt_end = (v >> 11) & 0xFF;
624 trailer = (v >> 1) & 0x3FF;
625
626 if (pt_end < pt_start)
627 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
628 pt_end * PAGE_SIZE + trailer * 4;
629 else
630 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
631
632 if (fsize > size) {
633 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
634 fsize);
635 return -1;
636 }
637
638 ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
639
640 #ifdef MEYE_JPEG_CORRECTION
641
642 /* Some mchip generated jpeg frames are incorrect. In most
643 * (all ?) of those cases, the final EOI (0xff 0xd9) marker
644 * is not present at the end of the frame.
645 *
646 * Since adding the final marker is not enough to restore
647 * the jpeg integrity, we drop the frame.
648 */
649
650 for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
651
652 if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
653 return -1;
654
655 #endif
656
657 return fsize;
658 }
659
660 /* take a picture into SDRAM */
661 static void mchip_take_picture(void)
662 {
663 int i;
664
665 mchip_hic_stop();
666 mchip_subsample();
667 mchip_dma_setup(meye.mchip_dmahandle);
668
669 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
670 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
671
672 mchip_delay(MCHIP_HIC_CMD, 0);
673
674 for (i = 0; i < 100; ++i) {
675 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
676 break;
677 msleep(1);
678 }
679 }
680
681 /* dma a previously taken picture into a buffer */
682 static void mchip_get_picture(u8 *buf, int bufsize)
683 {
684 u32 v;
685 int i;
686
687 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
688 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
689
690 mchip_delay(MCHIP_HIC_CMD, 0);
691 for (i = 0; i < 100; ++i) {
692 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
693 break;
694 msleep(1);
695 }
696 for (i = 0; i < 4; ++i) {
697 v = mchip_get_frame();
698 if (v & MCHIP_MM_FIR_RDY) {
699 mchip_cont_read_frame(v, buf, bufsize);
700 break;
701 }
702 mchip_free_frame();
703 }
704 }
705
706 /* start continuous dma capture */
707 static void mchip_continuous_start(void)
708 {
709 mchip_hic_stop();
710 mchip_subsample();
711 mchip_set_framerate();
712 mchip_dma_setup(meye.mchip_dmahandle);
713
714 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
715
716 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
717 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
718
719 mchip_delay(MCHIP_HIC_CMD, 0);
720 }
721
722 /* compress one frame into a buffer */
723 static int mchip_compress_frame(u8 *buf, int bufsize)
724 {
725 u32 v;
726 int len = -1, i;
727
728 mchip_vrj_setup(0x3f);
729 udelay(50);
730
731 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
732 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
733
734 mchip_delay(MCHIP_HIC_CMD, 0);
735 for (i = 0; i < 100; ++i) {
736 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
737 break;
738 msleep(1);
739 }
740
741 for (i = 0; i < 4; ++i) {
742 v = mchip_get_frame();
743 if (v & MCHIP_MM_FIR_RDY) {
744 len = mchip_comp_read_frame(v, buf, bufsize);
745 break;
746 }
747 mchip_free_frame();
748 }
749 return len;
750 }
751
752 #if 0
753 /* uncompress one image into a buffer */
754 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
755 {
756 mchip_vrj_setup(0x3f);
757 udelay(50);
758
759 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
760 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
761
762 mchip_delay(MCHIP_HIC_CMD, 0);
763
764 return mchip_comp_read_frame(buf, bufsize);
765 }
766 #endif
767
768 /* start continuous compressed capture */
769 static void mchip_cont_compression_start(void)
770 {
771 mchip_hic_stop();
772 mchip_vrj_setup(0x3f);
773 mchip_subsample();
774 mchip_set_framerate();
775 mchip_dma_setup(meye.mchip_dmahandle);
776
777 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
778
779 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
780 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
781
782 mchip_delay(MCHIP_HIC_CMD, 0);
783 }
784
785 /****************************************************************************/
786 /* Interrupt handling */
787 /****************************************************************************/
788
789 static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs)
790 {
791 u32 v;
792 int reqnr;
793 static int sequence = 0;
794
795 v = mchip_read(MCHIP_MM_INTA);
796
797 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
798 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
799 return IRQ_NONE;
800
801 again:
802 v = mchip_get_frame();
803 if (!(v & MCHIP_MM_FIR_RDY))
804 return IRQ_HANDLED;
805
806 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
807 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
808 sizeof(int)) != sizeof(int)) {
809 mchip_free_frame();
810 return IRQ_HANDLED;
811 }
812 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
813 mchip_hsize() * mchip_vsize() * 2);
814 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
815 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
816 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
817 meye.grab_buffer[reqnr].sequence = sequence++;
818 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
819 wake_up_interruptible(&meye.proc_list);
820 } else {
821 int size;
822 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
823 if (size == -1) {
824 mchip_free_frame();
825 goto again;
826 }
827 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
828 sizeof(int)) != sizeof(int)) {
829 mchip_free_frame();
830 goto again;
831 }
832 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
833 size);
834 meye.grab_buffer[reqnr].size = size;
835 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
836 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
837 meye.grab_buffer[reqnr].sequence = sequence++;
838 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
839 wake_up_interruptible(&meye.proc_list);
840 }
841 mchip_free_frame();
842 goto again;
843 }
844
845 /****************************************************************************/
846 /* video4linux integration */
847 /****************************************************************************/
848
849 static int meye_open(struct inode *inode, struct file *file)
850 {
851 int i, err;
852
853 err = video_exclusive_open(inode, file);
854 if (err < 0)
855 return err;
856
857 mchip_hic_stop();
858
859 if (mchip_dma_alloc()) {
860 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
861 video_exclusive_release(inode, file);
862 return -ENOBUFS;
863 }
864
865 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
866 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
867 kfifo_reset(meye.grabq);
868 kfifo_reset(meye.doneq);
869 return 0;
870 }
871
872 static int meye_release(struct inode *inode, struct file *file)
873 {
874 mchip_hic_stop();
875 mchip_dma_free();
876 video_exclusive_release(inode, file);
877 return 0;
878 }
879
880 static int meye_do_ioctl(struct inode *inode, struct file *file,
881 unsigned int cmd, void *arg)
882 {
883 switch (cmd) {
884
885 case VIDIOCGCAP: {
886 struct video_capability *b = arg;
887 strcpy(b->name,meye.video_dev->name);
888 b->type = VID_TYPE_CAPTURE;
889 b->channels = 1;
890 b->audios = 0;
891 b->maxwidth = 640;
892 b->maxheight = 480;
893 b->minwidth = 320;
894 b->minheight = 240;
895 break;
896 }
897
898 case VIDIOCGCHAN: {
899 struct video_channel *v = arg;
900 v->flags = 0;
901 v->tuners = 0;
902 v->type = VIDEO_TYPE_CAMERA;
903 if (v->channel != 0)
904 return -EINVAL;
905 strcpy(v->name,"Camera");
906 break;
907 }
908
909 case VIDIOCSCHAN: {
910 struct video_channel *v = arg;
911 if (v->channel != 0)
912 return -EINVAL;
913 break;
914 }
915
916 case VIDIOCGPICT: {
917 struct video_picture *p = arg;
918 *p = meye.picture;
919 break;
920 }
921
922 case VIDIOCSPICT: {
923 struct video_picture *p = arg;
924 if (p->depth != 16)
925 return -EINVAL;
926 if (p->palette != VIDEO_PALETTE_YUV422)
927 return -EINVAL;
928 mutex_lock(&meye.lock);
929 sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS,
930 p->brightness >> 10);
931 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE,
932 p->hue >> 10);
933 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR,
934 p->colour >> 10);
935 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST,
936 p->contrast >> 10);
937 meye.picture = *p;
938 mutex_unlock(&meye.lock);
939 break;
940 }
941
942 case VIDIOCSYNC: {
943 int *i = arg;
944 int unused;
945
946 if (*i < 0 || *i >= gbuffers)
947 return -EINVAL;
948
949 mutex_lock(&meye.lock);
950
951 switch (meye.grab_buffer[*i].state) {
952
953 case MEYE_BUF_UNUSED:
954 mutex_unlock(&meye.lock);
955 return -EINVAL;
956 case MEYE_BUF_USING: