aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/pci/meye
diff options
context:
space:
mode:
authorMauro Carvalho Chehab <mchehab@redhat.com>2012-08-14 13:50:53 -0400
committerMauro Carvalho Chehab <mchehab@redhat.com>2012-08-15 15:39:31 -0400
commite5cdf69d36f667d9840ce050abbe4a95c2a6b536 (patch)
treefd11102a155423aaafa3848dba999353f58ff3a0 /drivers/media/pci/meye
parent3e7c99126f1e18379bdac0544255e230d623ab3a (diff)
[media] move the remaining PCI devices to drivers/media/pci
Move meye and sta2x11_vip into the drivers/media/pci subdirs. Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Diffstat (limited to 'drivers/media/pci/meye')
-rw-r--r--drivers/media/pci/meye/Kconfig13
-rw-r--r--drivers/media/pci/meye/Makefile1
-rw-r--r--drivers/media/pci/meye/meye.c1964
-rw-r--r--drivers/media/pci/meye/meye.h324
4 files changed, 2302 insertions, 0 deletions
diff --git a/drivers/media/pci/meye/Kconfig b/drivers/media/pci/meye/Kconfig
new file mode 100644
index 000000000000..b4bf848be5a0
--- /dev/null
+++ b/drivers/media/pci/meye/Kconfig
@@ -0,0 +1,13 @@
1config VIDEO_MEYE
2 tristate "Sony Vaio Picturebook Motion Eye Video For Linux"
3 depends on PCI && SONY_LAPTOP && VIDEO_V4L2
4 ---help---
5 This is the video4linux driver for the Motion Eye camera found
6 in the Vaio Picturebook laptops. Please read the material in
7 <file:Documentation/video4linux/meye.txt> for more information.
8
9 If you say Y or M here, you need to say Y or M to "Sony Laptop
10 Extras" in the misc device section.
11
12 To compile this driver as a module, choose M here: the
13 module will be called meye.
diff --git a/drivers/media/pci/meye/Makefile b/drivers/media/pci/meye/Makefile
new file mode 100644
index 000000000000..49388518cd01
--- /dev/null
+++ b/drivers/media/pci/meye/Makefile
@@ -0,0 +1 @@
obj-$(CONFIG_VIDEO_MEYE) += meye.o
diff --git a/drivers/media/pci/meye/meye.c b/drivers/media/pci/meye/meye.c
new file mode 100644
index 000000000000..7bc775219f97
--- /dev/null
+++ b/drivers/media/pci/meye/meye.c
@@ -0,0 +1,1964 @@
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/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>
39#include <asm/io.h>
40#include <linux/delay.h>
41#include <linux/interrupt.h>
42#include <linux/vmalloc.h>
43#include <linux/dma-mapping.h>
44
45#include "meye.h"
46#include <linux/meye.h>
47
48MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
49MODULE_DESCRIPTION("v4l2 driver for the MotionEye camera");
50MODULE_LICENSE("GPL");
51MODULE_VERSION(MEYE_DRIVER_VERSION);
52
53/* number of grab buffers */
54static unsigned int gbuffers = 2;
55module_param(gbuffers, int, 0444);
56MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)");
57
58/* size of a grab buffer */
59static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
60module_param(gbufsize, int, 0444);
61MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 614400"
62 " (will be rounded up to a page multiple)");
63
64/* /dev/videoX registration number */
65static int video_nr = -1;
66module_param(video_nr, int, 0444);
67MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)");
68
69/* driver structure - only one possible */
70static struct meye meye;
71
72/****************************************************************************/
73/* Memory allocation routines (stolen from bttv-driver.c) */
74/****************************************************************************/
75static void *rvmalloc(unsigned long size)
76{
77 void *mem;
78 unsigned long adr;
79
80 size = PAGE_ALIGN(size);
81 mem = vmalloc_32(size);
82 if (mem) {
83 memset(mem, 0, size);
84 adr = (unsigned long) mem;
85 while (size > 0) {
86 SetPageReserved(vmalloc_to_page((void *)adr));
87 adr += PAGE_SIZE;
88 size -= PAGE_SIZE;
89 }
90 }
91 return mem;
92}
93
94static void rvfree(void * mem, unsigned long size)
95{
96 unsigned long adr;
97
98 if (mem) {
99 adr = (unsigned long) mem;
100 while ((long) size > 0) {
101 ClearPageReserved(vmalloc_to_page((void *)adr));
102 adr += PAGE_SIZE;
103 size -= PAGE_SIZE;
104 }
105 vfree(mem);
106 }
107}
108
109/*
110 * return a page table pointing to N pages of locked memory
111 *
112 * NOTE: The meye device expects DMA addresses on 32 bits, we build
113 * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
114 */
115static int ptable_alloc(void)
116{
117 u32 *pt;
118 int i;
119
120 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
121
122 /* give only 32 bit DMA addresses */
123 if (dma_set_mask(&meye.mchip_dev->dev, DMA_BIT_MASK(32)))
124 return -1;
125
126 meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
127 PAGE_SIZE,
128 &meye.mchip_dmahandle,
129 GFP_KERNEL);
130 if (!meye.mchip_ptable_toc) {
131 meye.mchip_dmahandle = 0;
132 return -1;
133 }
134
135 pt = meye.mchip_ptable_toc;
136 for (i = 0; i < MCHIP_NB_PAGES; i++) {
137 dma_addr_t dma;
138 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
139 PAGE_SIZE,
140 &dma,
141 GFP_KERNEL);
142 if (!meye.mchip_ptable[i]) {
143 int j;
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,
148 PAGE_SIZE,
149 meye.mchip_ptable[j], dma);
150 pt++;
151 }
152 dma_free_coherent(&meye.mchip_dev->dev,
153 PAGE_SIZE,
154 meye.mchip_ptable_toc,
155 meye.mchip_dmahandle);
156 meye.mchip_ptable_toc = NULL;
157 meye.mchip_dmahandle = 0;
158 return -1;
159 }
160 *pt = (u32) dma;
161 pt++;
162 }
163 return 0;
164}
165
166static void ptable_free(void)
167{
168 u32 *pt;
169 int i;
170
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,
176 PAGE_SIZE,
177 meye.mchip_ptable[i], dma);
178 pt++;
179 }
180
181 if (meye.mchip_ptable_toc)
182 dma_free_coherent(&meye.mchip_dev->dev,
183 PAGE_SIZE,
184 meye.mchip_ptable_toc,
185 meye.mchip_dmahandle);
186
187 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
188 meye.mchip_ptable_toc = NULL;
189 meye.mchip_dmahandle = 0;
190}
191
192/* copy data from ptable into buf */
193static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
194{
195 int i;
196
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)
200 start = 0;
201 }
202 memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
203}
204
205/****************************************************************************/
206/* JPEG tables at different qualities to load into the VRJ chip */
207/****************************************************************************/
208
209/* return a set of quantisation tables based on a quality from 1 to 10 */
210static u16 *jpeg_quantisation_tables(int *length, int quality)
211{
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,
223 },
224 {
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,
235 },
236 {
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,
247 },
248 {
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,
259 },
260 {
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,
271 },
272 {
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,
283 },
284 {
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,
295 },
296 {
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,
307 },
308 {
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,
319 },
320 {
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,
331 },
332 {
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,
343 } };
344
345 if (quality < 0 || quality > 10) {
346 printk(KERN_WARNING
347 "meye: invalid quality level %d - using 8\n", quality);
348 quality = 8;
349 }
350
351 *length = ARRAY_SIZE(jpeg_tables[quality]);
352 return jpeg_tables[quality];
353}
354
355/* return a generic set of huffman tables */
356static u16 *jpeg_huffman_tables(int *length)
357{
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,
385 0xFF0B,
386 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
387 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
388 0xFF0B
389 };
390
391 *length = ARRAY_SIZE(tables);
392 return tables;
393}
394
395/****************************************************************************/
396/* MCHIP low-level functions */
397/****************************************************************************/
398
399/* returns the horizontal capture size */
400static inline int mchip_hsize(void)
401{
402 return meye.params.subsample ? 320 : 640;
403}
404
405/* returns the vertical capture size */
406static inline int mchip_vsize(void)
407{
408 return meye.params.subsample ? 240 : 480;
409}
410
411/* waits for a register to be available */
412static void mchip_sync(int reg)
413{
414 u32 status;
415 int i;
416
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");
423 return;
424 }
425 if (status & MCHIP_MM_FIFO_READY)
426 return;
427 udelay(1);
428 }
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);
434 if (status & mask)
435 return;
436 udelay(1);
437 }
438 } else
439 return;
440 printk(KERN_WARNING
441 "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
442 reg, status);
443}
444
445/* sets a value into the register */
446static inline void mchip_set(int reg, u32 v)
447{
448 mchip_sync(reg);
449 writel(v, meye.mchip_mmregs + reg);
450}
451
452/* get the register value */
453static inline u32 mchip_read(int reg)
454{
455 mchip_sync(reg);
456 return readl(meye.mchip_mmregs + reg);
457}
458
459/* wait for a register to become a particular value */
460static inline int mchip_delay(u32 reg, u32 v)
461{
462 int n = 10;
463 while (--n && mchip_read(reg) != v)
464 udelay(1);
465 return n;
466}
467
468/* setup subsampling */
469static void mchip_subsample(void)
470{
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);
477}
478
479/* set the framerate into the mchip */
480static void mchip_set_framerate(void)
481{
482 mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
483}
484
485/* load some huffman and quantisation tables into the VRJ chip ready
486 for JPEG compression */
487static void mchip_load_tables(void)
488{
489 int i;
490 int length;
491 u16 *tables;
492
493 tables = jpeg_huffman_tables(&length);
494 for (i = 0; i < length; i++)
495 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
496
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);
500}
501
502/* setup the VRJ parameters in the chip */
503static void mchip_vrj_setup(u8 mode)
504{
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);
522
523 mchip_load_tables();
524}
525
526/* sets the DMA parameters into the chip */
527static void mchip_dma_setup(dma_addr_t dma_addr)
528{
529 int i;
530
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);
534 meye.mchip_fnum = 0;
535}
536
537/* setup for DMA transfers - also zeros the framebuffer */
538static int mchip_dma_alloc(void)
539{
540 if (!meye.mchip_dmahandle)
541 if (ptable_alloc())
542 return -1;
543 return 0;
544}
545
546/* frees the DMA buffer */
547static void mchip_dma_free(void)
548{
549 if (meye.mchip_dmahandle) {
550 mchip_dma_setup(0);
551 ptable_free();
552 }
553}
554
555/* stop any existing HIC action and wait for any dma to complete then
556 reset the dma engine */
557static void mchip_hic_stop(void)
558{
559 int i, j;
560
561 meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
562 if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
563 return;
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))
570 return;
571 msleep(1);
572 }
573 printk(KERN_ERR "meye: need to reset HIC!\n");
574
575 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
576 msleep(250);
577 }
578 printk(KERN_ERR "meye: resetting HIC hanged!\n");
579}
580
581/****************************************************************************/
582/* MCHIP frame processing functions */
583/****************************************************************************/
584
585/* get the next ready frame from the dma engine */
586static u32 mchip_get_frame(void)
587{
588 u32 v;
589
590 v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
591 return v;
592}
593
594/* frees the current frame from the dma engine */
595static void mchip_free_frame(void)
596{
597 mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
598 meye.mchip_fnum++;
599 meye.mchip_fnum %= 4;
600}
601
602/* read one frame from the framebuffer assuming it was captured using
603 a uncompressed transfer */
604static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
605{
606 int pt_id;
607
608 pt_id = (v >> 17) & 0x3FF;
609
610 ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
611}
612
613/* read a compressed frame from the framebuffer */
614static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
615{
616 int pt_start, pt_end, trailer;
617 int fsize;
618 int i;
619
620 pt_start = (v >> 19) & 0xFF;
621 pt_end = (v >> 11) & 0xFF;
622 trailer = (v >> 1) & 0x3FF;
623
624 if (pt_end < pt_start)
625 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
626 pt_end * PAGE_SIZE + trailer * 4;
627 else
628 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
629
630 if (fsize > size) {
631 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
632 fsize);
633 return -1;
634 }
635
636 ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
637
638#ifdef MEYE_JPEG_CORRECTION
639
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.
643 *
644 * Since adding the final marker is not enough to restore
645 * the jpeg integrity, we drop the frame.
646 */
647
648 for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
649
650 if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
651 return -1;
652
653#endif
654
655 return fsize;
656}
657
658/* take a picture into SDRAM */
659static void mchip_take_picture(void)
660{
661 int i;
662
663 mchip_hic_stop();
664 mchip_subsample();
665 mchip_dma_setup(meye.mchip_dmahandle);
666
667 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
668 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
669
670 mchip_delay(MCHIP_HIC_CMD, 0);
671
672 for (i = 0; i < 100; ++i) {
673 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
674 break;
675 msleep(1);
676 }
677}
678
679/* dma a previously taken picture into a buffer */
680static void mchip_get_picture(u8 *buf, int bufsize)
681{
682 u32 v;
683 int i;
684
685 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
686 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
687
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))
691 break;
692 msleep(1);
693 }
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);
698 break;
699 }
700 mchip_free_frame();
701 }
702}
703
704/* start continuous dma capture */
705static void mchip_continuous_start(void)
706{
707 mchip_hic_stop();
708 mchip_subsample();
709 mchip_set_framerate();
710 mchip_dma_setup(meye.mchip_dmahandle);
711
712 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
713
714 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
715 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
716
717 mchip_delay(MCHIP_HIC_CMD, 0);
718}
719
720/* compress one frame into a buffer */
721static int mchip_compress_frame(u8 *buf, int bufsize)
722{
723 u32 v;
724 int len = -1, i;
725
726 mchip_vrj_setup(0x3f);
727 udelay(50);
728
729 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
730 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
731
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))
735 break;
736 msleep(1);
737 }
738
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);
743 break;
744 }
745 mchip_free_frame();
746 }
747 return len;
748}
749
750#if 0
751/* uncompress one image into a buffer */
752static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
753{
754 mchip_vrj_setup(0x3f);
755 udelay(50);
756
757 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
758 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
759
760 mchip_delay(MCHIP_HIC_CMD, 0);
761
762 return mchip_comp_read_frame(buf, bufsize);
763}
764#endif
765
766/* start continuous compressed capture */
767static void mchip_cont_compression_start(void)
768{
769 mchip_hic_stop();
770 mchip_vrj_setup(0x3f);
771 mchip_subsample();
772 mchip_set_framerate();
773 mchip_dma_setup(meye.mchip_dmahandle);
774
775 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
776
777 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
778 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
779
780 mchip_delay(MCHIP_HIC_CMD, 0);
781}
782
783/****************************************************************************/
784/* Interrupt handling */
785/****************************************************************************/
786
787static irqreturn_t meye_irq(int irq, void *dev_id)
788{
789 u32 v;
790 int reqnr;
791 static int sequence;
792
793 v = mchip_read(MCHIP_MM_INTA);
794
795 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
796 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
797 return IRQ_NONE;
798
799again:
800 v = mchip_get_frame();
801 if (!(v & MCHIP_MM_FIR_RDY))
802 return IRQ_HANDLED;
803
804 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
805 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
806 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
807 mchip_free_frame();
808 return IRQ_HANDLED;
809 }
810 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
811 mchip_hsize() * mchip_vsize() * 2);
812 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
813 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
814 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
815 meye.grab_buffer[reqnr].sequence = sequence++;
816 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
817 sizeof(int), &meye.doneq_lock);
818 wake_up_interruptible(&meye.proc_list);
819 } else {
820 int size;
821 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
822 if (size == -1) {
823 mchip_free_frame();
824 goto again;
825 }
826 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
827 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
828 mchip_free_frame();
829 goto again;
830 }
831 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
832 size);
833 meye.grab_buffer[reqnr].size = size;
834 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
835 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
836 meye.grab_buffer[reqnr].sequence = sequence++;
837 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
838 sizeof(int), &meye.doneq_lock);
839 wake_up_interruptible(&meye.proc_list);
840 }
841 mchip_free_frame();
842 goto again;
843}
844
845/****************************************************************************/
846/* video4linux integration */
847/****************************************************************************/
848
849static int meye_open(struct file *file)
850{
851 int i;
852
853 if (test_and_set_bit(0, &meye.in_use))
854 return -EBUSY;
855
856 mchip_hic_stop();
857
858 if (mchip_dma_alloc()) {
859 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
860 clear_bit(0, &meye.in_use);
861 return -ENOBUFS;
862 }
863
864 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
865 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
866 kfifo_reset(&meye.grabq);
867 kfifo_reset(&meye.doneq);
868 return 0;
869}
870
871static int meye_release(struct file *file)
872{
873 mchip_hic_stop();
874 mchip_dma_free();
875 clear_bit(0, &meye.in_use);
876 return 0;
877}
878
879static int meyeioc_g_params(struct meye_params *p)
880{
881 *p = meye.params;
882 return 0;
883}
884
885static int meyeioc_s_params(struct meye_params *jp)
886{
887 if (jp->subsample > 1)
888 return -EINVAL;
889
890 if (jp->quality > 10)
891 return -EINVAL;
892
893 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
894 return -EINVAL;
895
896 if (jp->framerate > 31)
897 return -EINVAL;
898
899 mutex_lock(&meye.lock);
900
901 if (meye.params.subsample != jp->subsample ||
902 meye.params.quality != jp->quality)
903 mchip_hic_stop(); /* need restart */
904
905 meye.params = *jp;
906 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
907 meye.params.sharpness);
908 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
909 meye.params.agc);
910 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
911 meye.params.picture);
912 mutex_unlock(&meye.lock);
913
914 return 0;
915}
916
917static int meyeioc_qbuf_capt(int *nb)
918{
919 if (!meye.grab_fbuffer)
920 return -EINVAL;
921
922 if (*nb >= gbuffers)
923 return -EINVAL;
924
925 if (*nb < 0) {
926 /* stop capture */
927 mchip_hic_stop();
928 return 0;
929 }
930
931 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
932 return -EBUSY;
933
934 mutex_lock(&meye.lock);
935
936 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
937 mchip_cont_compression_start();
938
939 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
940 kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
941 &meye.grabq_lock);
942 mutex_unlock(&meye.lock);
943
944 return 0;
945}
946
947static int meyeioc_sync(struct file *file, void *fh, int *i)
948{
949 int unused;
950
951 if (*i < 0 || *i >= gbuffers)
952 return -EINVAL;
953
954 mutex_lock(&meye.lock);
955 switch (meye.grab_buffer[*i].state) {
956
957 case MEYE_BUF_UNUSED:
958 mutex_unlock(&meye.lock);
959 return -EINVAL;
960 case MEYE_BUF_USING:
961 if (file->f_flags & O_NONBLOCK) {
962 mutex_unlock(&meye.lock);
963 return -EAGAIN;
964 }
965 if (wait_event_interruptible(meye.proc_list,
966 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
967 mutex_unlock(&meye.lock);
968 return -EINTR;
969 }
970 /* fall through */
971 case MEYE_BUF_DONE:
972 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
973 if (kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
974 sizeof(int), &meye.doneq_lock) != sizeof(int))
975 break;
976 }
977 *i = meye.grab_buffer[*i].size;
978 mutex_unlock(&meye.lock);
979 return 0;
980}
981
982static int meyeioc_stillcapt(void)
983{
984 if (!meye.grab_fbuffer)
985 return -EINVAL;
986
987 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
988 return -EBUSY;
989
990 mutex_lock(&meye.lock);
991 meye.grab_buffer[0].state = MEYE_BUF_USING;
992 mchip_take_picture();
993
994 mchip_get_picture(meye.grab_fbuffer,
995 mchip_hsize() * mchip_vsize() * 2);
996
997 meye.grab_buffer[0].state = MEYE_BUF_DONE;
998 mutex_unlock(&meye.lock);
999
1000 return 0;
1001}
1002
1003static int meyeioc_stilljcapt(int *len)
1004{
1005 if (!meye.grab_fbuffer)
1006 return -EINVAL;
1007
1008 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1009 return -EBUSY;
1010
1011 mutex_lock(&meye.lock);
1012 meye.grab_buffer[0].state = MEYE_BUF_USING;
1013 *len = -1;
1014
1015 while (*len == -1) {
1016 mchip_take_picture();
1017 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1018 }
1019
1020 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1021 mutex_unlock(&meye.lock);
1022 return 0;
1023}
1024
1025static int vidioc_querycap(struct file *file, void *fh,
1026 struct v4l2_capability *cap)
1027{
1028 strcpy(cap->driver, "meye");
1029 strcpy(cap->card, "meye");
1030 sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1031
1032 cap->version = (MEYE_DRIVER_MAJORVERSION << 8) +
1033 MEYE_DRIVER_MINORVERSION;
1034
1035 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1036 V4L2_CAP_STREAMING;
1037
1038 return 0;
1039}
1040
1041static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1042{
1043 if (i->index != 0)
1044 return -EINVAL;
1045
1046 strcpy(i->name, "Camera");
1047 i->type = V4L2_INPUT_TYPE_CAMERA;
1048
1049 return 0;
1050}
1051
1052static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1053{
1054 *i = 0;
1055 return 0;
1056}
1057
1058static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1059{
1060 if (i != 0)
1061 return -EINVAL;
1062
1063 return 0;
1064}
1065
1066static int vidioc_queryctrl(struct file *file, void *fh,
1067 struct v4l2_queryctrl *c)
1068{
1069 switch (c->id) {
1070
1071 case V4L2_CID_BRIGHTNESS:
1072 c->type = V4L2_CTRL_TYPE_INTEGER;
1073 strcpy(c->name, "Brightness");
1074 c->minimum = 0;
1075 c->maximum = 63;
1076 c->step = 1;
1077 c->default_value = 32;
1078 c->flags = 0;
1079 break;
1080 case V4L2_CID_HUE:
1081 c->type = V4L2_CTRL_TYPE_INTEGER;
1082 strcpy(c->name, "Hue");
1083 c->minimum = 0;
1084 c->maximum = 63;
1085 c->step = 1;
1086 c->default_value = 32;
1087 c->flags = 0;
1088 break;
1089 case V4L2_CID_CONTRAST:
1090 c->type = V4L2_CTRL_TYPE_INTEGER;
1091 strcpy(c->name, "Contrast");
1092 c->minimum = 0;
1093 c->maximum = 63;
1094 c->step = 1;
1095 c->default_value = 32;
1096 c->flags = 0;
1097 break;
1098 case V4L2_CID_SATURATION:
1099 c->type = V4L2_CTRL_TYPE_INTEGER;
1100 strcpy(c->name, "Saturation");
1101 c->minimum = 0;
1102 c->maximum = 63;
1103 c->step = 1;
1104 c->default_value = 32;
1105 c->flags = 0;
1106 break;
1107 case V4L2_CID_AGC:
1108 c->type = V4L2_CTRL_TYPE_INTEGER;
1109 strcpy(c->name, "Agc");
1110 c->minimum = 0;
1111 c->maximum = 63;
1112 c->step = 1;
1113 c->default_value = 48;
1114 c->flags = 0;
1115 break;
1116 case V4L2_CID_MEYE_SHARPNESS:
1117 case V4L2_CID_SHARPNESS:
1118 c->type = V4L2_CTRL_TYPE_INTEGER;
1119 strcpy(c->name, "Sharpness");
1120 c->minimum = 0;
1121 c->maximum = 63;
1122 c->step = 1;
1123 c->default_value = 32;
1124
1125 /* Continue to report legacy private SHARPNESS ctrl but
1126 * say it is disabled in preference to ctrl in the spec
1127 */
1128 c->flags = (c->id == V4L2_CID_SHARPNESS) ? 0 :
1129 V4L2_CTRL_FLAG_DISABLED;
1130 break;
1131 case V4L2_CID_PICTURE:
1132 c->type = V4L2_CTRL_TYPE_INTEGER;
1133 strcpy(c->name, "Picture");
1134 c->minimum = 0;
1135 c->maximum = 63;
1136 c->step = 1;
1137 c->default_value = 0;
1138 c->flags = 0;
1139 break;
1140 case V4L2_CID_JPEGQUAL:
1141 c->type = V4L2_CTRL_TYPE_INTEGER;
1142 strcpy(c->name, "JPEG quality");
1143 c->minimum = 0;
1144 c->maximum = 10;
1145 c->step = 1;
1146 c->default_value = 8;
1147 c->flags = 0;
1148 break;
1149 case V4L2_CID_FRAMERATE:
1150 c->type = V4L2_CTRL_TYPE_INTEGER;
1151 strcpy(c->name, "Framerate");
1152 c->minimum = 0;
1153 c->maximum = 31;
1154 c->step = 1;
1155 c->default_value = 0;
1156 c->flags = 0;
1157 break;
1158 default:
1159 return -EINVAL;
1160 }
1161
1162 return 0;
1163}
1164
1165static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1166{
1167 mutex_lock(&meye.lock);
1168 switch (c->id) {
1169 case V4L2_CID_BRIGHTNESS:
1170 sony_pic_camera_command(
1171 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, c->value);
1172 meye.brightness = c->value << 10;
1173 break;
1174 case V4L2_CID_HUE:
1175 sony_pic_camera_command(
1176 SONY_PIC_COMMAND_SETCAMERAHUE, c->value);
1177 meye.hue = c->value << 10;
1178 break;
1179 case V4L2_CID_CONTRAST:
1180 sony_pic_camera_command(
1181 SONY_PIC_COMMAND_SETCAMERACONTRAST, c->value);
1182 meye.contrast = c->value << 10;
1183 break;
1184 case V4L2_CID_SATURATION:
1185 sony_pic_camera_command(
1186 SONY_PIC_COMMAND_SETCAMERACOLOR, c->value);
1187 meye.colour = c->value << 10;
1188 break;
1189 case V4L2_CID_AGC:
1190 sony_pic_camera_command(
1191 SONY_PIC_COMMAND_SETCAMERAAGC, c->value);
1192 meye.params.agc = c->value;
1193 break;
1194 case V4L2_CID_SHARPNESS:
1195 case V4L2_CID_MEYE_SHARPNESS:
1196 sony_pic_camera_command(
1197 SONY_PIC_COMMAND_SETCAMERASHARPNESS, c->value);
1198 meye.params.sharpness = c->value;
1199 break;
1200 case V4L2_CID_PICTURE:
1201 sony_pic_camera_command(
1202 SONY_PIC_COMMAND_SETCAMERAPICTURE, c->value);
1203 meye.params.picture = c->value;
1204 break;
1205 case V4L2_CID_JPEGQUAL:
1206 meye.params.quality = c->value;
1207 break;
1208 case V4L2_CID_FRAMERATE:
1209 meye.params.framerate = c->value;
1210 break;
1211 default:
1212 mutex_unlock(&meye.lock);
1213 return -EINVAL;
1214 }
1215 mutex_unlock(&meye.lock);
1216
1217 return 0;
1218}
1219
1220static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1221{
1222 mutex_lock(&meye.lock);
1223 switch (c->id) {
1224 case V4L2_CID_BRIGHTNESS:
1225 c->value = meye.brightness >> 10;
1226 break;
1227 case V4L2_CID_HUE:
1228 c->value = meye.hue >> 10;
1229 break;
1230 case V4L2_CID_CONTRAST:
1231 c->value = meye.contrast >> 10;
1232 break;
1233 case V4L2_CID_SATURATION:
1234 c->value = meye.colour >> 10;
1235 break;
1236 case V4L2_CID_AGC:
1237 c->value = meye.params.agc;
1238 break;
1239 case V4L2_CID_SHARPNESS:
1240 case V4L2_CID_MEYE_SHARPNESS:
1241 c->value = meye.params.sharpness;
1242 break;
1243 case V4L2_CID_PICTURE:
1244 c->value = meye.params.picture;
1245 break;
1246 case V4L2_CID_JPEGQUAL:
1247 c->value = meye.params.quality;
1248 break;
1249 case V4L2_CID_FRAMERATE:
1250 c->value = meye.params.framerate;
1251 break;
1252 default:
1253 mutex_unlock(&meye.lock);
1254 return -EINVAL;
1255 }
1256 mutex_unlock(&meye.lock);
1257
1258 return 0;
1259}
1260
1261static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1262 struct v4l2_fmtdesc *f)
1263{
1264 if (f->index > 1)
1265 return -EINVAL;
1266
1267 if (f->index == 0) {
1268 /* standard YUV 422 capture */
1269 f->flags = 0;
1270 strcpy(f->description, "YUV422");
1271 f->pixelformat = V4L2_PIX_FMT_YUYV;
1272 } else {
1273 /* compressed MJPEG capture */
1274 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1275 strcpy(f->description, "MJPEG");
1276 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1277 }
1278
1279 return 0;
1280}
1281
1282static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1283 struct v4l2_format *f)
1284{
1285 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1286 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1287 return -EINVAL;
1288
1289 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1290 f->fmt.pix.field != V4L2_FIELD_NONE)
1291 return -EINVAL;
1292
1293 f->fmt.pix.field = V4L2_FIELD_NONE;
1294
1295 if (f->fmt.pix.width <= 320) {
1296 f->fmt.pix.width = 320;
1297 f->fmt.pix.height = 240;
1298 } else {
1299 f->fmt.pix.width = 640;
1300 f->fmt.pix.height = 480;
1301 }
1302
1303 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1304 f->fmt.pix.sizeimage = f->fmt.pix.height *
1305 f->fmt.pix.bytesperline;
1306 f->fmt.pix.colorspace = 0;
1307 f->fmt.pix.priv = 0;
1308
1309 return 0;
1310}
1311
1312static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1313 struct v4l2_format *f)
1314{
1315 switch (meye.mchip_mode) {
1316 case MCHIP_HIC_MODE_CONT_OUT:
1317 default:
1318 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1319 break;
1320 case MCHIP_HIC_MODE_CONT_COMP:
1321 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1322 break;
1323 }
1324
1325 f->fmt.pix.field = V4L2_FIELD_NONE;
1326 f->fmt.pix.width = mchip_hsize();
1327 f->fmt.pix.height = mchip_vsize();
1328 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1329 f->fmt.pix.sizeimage = f->fmt.pix.height *
1330 f->fmt.pix.bytesperline;
1331
1332 return 0;
1333}
1334
1335static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1336 struct v4l2_format *f)
1337{
1338 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1339 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1340 return -EINVAL;
1341
1342 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1343 f->fmt.pix.field != V4L2_FIELD_NONE)
1344 return -EINVAL;
1345
1346 f->fmt.pix.field = V4L2_FIELD_NONE;
1347 mutex_lock(&meye.lock);
1348
1349 if (f->fmt.pix.width <= 320) {
1350 f->fmt.pix.width = 320;
1351 f->fmt.pix.height = 240;
1352 meye.params.subsample = 1;
1353 } else {
1354 f->fmt.pix.width = 640;
1355 f->fmt.pix.height = 480;
1356 meye.params.subsample = 0;
1357 }
1358
1359 switch (f->fmt.pix.pixelformat) {
1360 case V4L2_PIX_FMT_YUYV:
1361 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1362 break;
1363 case V4L2_PIX_FMT_MJPEG:
1364 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1365 break;
1366 }
1367
1368 mutex_unlock(&meye.lock);
1369 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1370 f->fmt.pix.sizeimage = f->fmt.pix.height *
1371 f->fmt.pix.bytesperline;
1372 f->fmt.pix.colorspace = 0;
1373 f->fmt.pix.priv = 0;
1374
1375 return 0;
1376}
1377
1378static int vidioc_reqbufs(struct file *file, void *fh,
1379 struct v4l2_requestbuffers *req)
1380{
1381 int i;
1382
1383 if (req->memory != V4L2_MEMORY_MMAP)
1384 return -EINVAL;
1385
1386 if (meye.grab_fbuffer && req->count == gbuffers) {
1387 /* already allocated, no modifications */
1388 return 0;
1389 }
1390
1391 mutex_lock(&meye.lock);
1392 if (meye.grab_fbuffer) {
1393 for (i = 0; i < gbuffers; i++)
1394 if (meye.vma_use_count[i]) {
1395 mutex_unlock(&meye.lock);
1396 return -EINVAL;
1397 }
1398 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1399 meye.grab_fbuffer = NULL;
1400 }
1401
1402 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1403 req->count = gbuffers;
1404 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1405
1406 if (!meye.grab_fbuffer) {
1407 printk(KERN_ERR "meye: v4l framebuffer allocation"
1408 " failed\n");
1409 mutex_unlock(&meye.lock);
1410 return -ENOMEM;
1411 }
1412
1413 for (i = 0; i < gbuffers; i++)
1414 meye.vma_use_count[i] = 0;
1415
1416 mutex_unlock(&meye.lock);
1417
1418 return 0;
1419}
1420
1421static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1422{
1423 unsigned int index = buf->index;
1424
1425 if (index >= gbuffers)
1426 return -EINVAL;
1427
1428 buf->bytesused = meye.grab_buffer[index].size;
1429 buf->flags = V4L2_BUF_FLAG_MAPPED;
1430
1431 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1432 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1433
1434 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1435 buf->flags |= V4L2_BUF_FLAG_DONE;
1436
1437 buf->field = V4L2_FIELD_NONE;
1438 buf->timestamp = meye.grab_buffer[index].timestamp;
1439 buf->sequence = meye.grab_buffer[index].sequence;
1440 buf->memory = V4L2_MEMORY_MMAP;
1441 buf->m.offset = index * gbufsize;
1442 buf->length = gbufsize;
1443
1444 return 0;
1445}
1446
1447static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1448{
1449 if (buf->memory != V4L2_MEMORY_MMAP)
1450 return -EINVAL;
1451
1452 if (buf->index >= gbuffers)
1453 return -EINVAL;
1454
1455 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1456 return -EINVAL;
1457
1458 mutex_lock(&meye.lock);
1459 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1460 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1461 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1462 kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
1463 sizeof(int), &meye.grabq_lock);
1464 mutex_unlock(&meye.lock);
1465
1466 return 0;
1467}
1468
1469static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1470{
1471 int reqnr;
1472
1473 if (buf->memory != V4L2_MEMORY_MMAP)
1474 return -EINVAL;
1475
1476 mutex_lock(&meye.lock);
1477
1478 if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1479 mutex_unlock(&meye.lock);
1480 return -EAGAIN;
1481 }
1482
1483 if (wait_event_interruptible(meye.proc_list,
1484 kfifo_len(&meye.doneq) != 0) < 0) {
1485 mutex_unlock(&meye.lock);
1486 return -EINTR;
1487 }
1488
1489 if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
1490 sizeof(int), &meye.doneq_lock)) {
1491 mutex_unlock(&meye.lock);
1492 return -EBUSY;
1493 }
1494
1495 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1496 mutex_unlock(&meye.lock);
1497 return -EINVAL;
1498 }
1499
1500 buf->index = reqnr;
1501 buf->bytesused = meye.grab_buffer[reqnr].size;
1502 buf->flags = V4L2_BUF_FLAG_MAPPED;
1503 buf->field = V4L2_FIELD_NONE;
1504 buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1505 buf->sequence = meye.grab_buffer[reqnr].sequence;
1506 buf->memory = V4L2_MEMORY_MMAP;
1507 buf->m.offset = reqnr * gbufsize;
1508 buf->length = gbufsize;
1509 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1510 mutex_unlock(&meye.lock);
1511
1512 return 0;
1513}
1514
1515static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1516{
1517 mutex_lock(&meye.lock);
1518
1519 switch (meye.mchip_mode) {
1520 case MCHIP_HIC_MODE_CONT_OUT:
1521 mchip_continuous_start();
1522 break;
1523 case MCHIP_HIC_MODE_CONT_COMP:
1524 mchip_cont_compression_start();
1525 break;
1526 default:
1527 mutex_unlock(&meye.lock);
1528 return -EINVAL;
1529 }
1530
1531 mutex_unlock(&meye.lock);
1532
1533 return 0;
1534}
1535
1536static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1537{
1538 mutex_lock(&meye.lock);
1539 mchip_hic_stop();
1540 kfifo_reset(&meye.grabq);
1541 kfifo_reset(&meye.doneq);
1542
1543 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1544 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1545
1546 mutex_unlock(&meye.lock);
1547 return 0;
1548}
1549
1550static long vidioc_default(struct file *file, void *fh, bool valid_prio,
1551 int cmd, void *arg)
1552{
1553 switch (cmd) {
1554 case MEYEIOC_G_PARAMS:
1555 return meyeioc_g_params((struct meye_params *) arg);
1556
1557 case MEYEIOC_S_PARAMS:
1558 return meyeioc_s_params((struct meye_params *) arg);
1559
1560 case MEYEIOC_QBUF_CAPT:
1561 return meyeioc_qbuf_capt((int *) arg);
1562
1563 case MEYEIOC_SYNC:
1564 return meyeioc_sync(file, fh, (int *) arg);
1565
1566 case MEYEIOC_STILLCAPT:
1567 return meyeioc_stillcapt();
1568
1569 case MEYEIOC_STILLJCAPT:
1570 return meyeioc_stilljcapt((int *) arg);
1571
1572 default:
1573 return -ENOTTY;
1574 }
1575
1576}
1577
1578static unsigned int meye_poll(struct file *file, poll_table *wait)
1579{
1580 unsigned int res = 0;
1581
1582 mutex_lock(&meye.lock);
1583 poll_wait(file, &meye.proc_list, wait);
1584 if (kfifo_len(&meye.doneq))
1585 res = POLLIN | POLLRDNORM;
1586 mutex_unlock(&meye.lock);
1587 return res;
1588}
1589
1590static void meye_vm_open(struct vm_area_struct *vma)
1591{
1592 long idx = (long)vma->vm_private_data;
1593 meye.vma_use_count[idx]++;
1594}
1595
1596static void meye_vm_close(struct vm_area_struct *vma)
1597{
1598 long idx = (long)vma->vm_private_data;
1599 meye.vma_use_count[idx]--;
1600}
1601
1602static const struct vm_operations_struct meye_vm_ops = {
1603 .open = meye_vm_open,
1604 .close = meye_vm_close,
1605};
1606
1607static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1608{
1609 unsigned long start = vma->vm_start;
1610 unsigned long size = vma->vm_end - vma->vm_start;
1611 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1612 unsigned long page, pos;
1613
1614 mutex_lock(&meye.lock);
1615 if (size > gbuffers * gbufsize) {
1616 mutex_unlock(&meye.lock);
1617 return -EINVAL;
1618 }
1619 if (!meye.grab_fbuffer) {
1620 int i;
1621
1622 /* lazy allocation */
1623 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1624 if (!meye.grab_fbuffer) {
1625 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1626 mutex_unlock(&meye.lock);
1627 return -ENOMEM;
1628 }
1629 for (i = 0; i < gbuffers; i++)
1630 meye.vma_use_count[i] = 0;
1631 }
1632 pos = (unsigned long)meye.grab_fbuffer + offset;
1633
1634 while (size > 0) {
1635 page = vmalloc_to_pfn((void *)pos);
1636 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1637 mutex_unlock(&meye.lock);
1638 return -EAGAIN;
1639 }
1640 start += PAGE_SIZE;
1641 pos += PAGE_SIZE;
1642 if (size > PAGE_SIZE)
1643 size -= PAGE_SIZE;
1644 else
1645 size = 0;
1646 }
1647
1648 vma->vm_ops = &meye_vm_ops;
1649 vma->vm_flags &= ~VM_IO; /* not I/O memory */
1650 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1651 vma->vm_private_data = (void *) (offset / gbufsize);
1652 meye_vm_open(vma);
1653
1654 mutex_unlock(&meye.lock);
1655 return 0;
1656}
1657
1658static const struct v4l2_file_operations meye_fops = {
1659 .owner = THIS_MODULE,
1660 .open = meye_open,
1661 .release = meye_release,
1662 .mmap = meye_mmap,
1663 .unlocked_ioctl = video_ioctl2,
1664 .poll = meye_poll,
1665};
1666
1667static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1668 .vidioc_querycap = vidioc_querycap,
1669 .vidioc_enum_input = vidioc_enum_input,
1670 .vidioc_g_input = vidioc_g_input,
1671 .vidioc_s_input = vidioc_s_input,
1672 .vidioc_queryctrl = vidioc_queryctrl,
1673 .vidioc_s_ctrl = vidioc_s_ctrl,
1674 .vidioc_g_ctrl = vidioc_g_ctrl,
1675 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1676 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1677 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1678 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1679 .vidioc_reqbufs = vidioc_reqbufs,
1680 .vidioc_querybuf = vidioc_querybuf,
1681 .vidioc_qbuf = vidioc_qbuf,
1682 .vidioc_dqbuf = vidioc_dqbuf,
1683 .vidioc_streamon = vidioc_streamon,
1684 .vidioc_streamoff = vidioc_streamoff,
1685 .vidioc_default = vidioc_default,
1686};
1687
1688static struct video_device meye_template = {
1689 .name = "meye",
1690 .fops = &meye_fops,
1691 .ioctl_ops = &meye_ioctl_ops,
1692 .release = video_device_release,
1693};
1694
1695#ifdef CONFIG_PM
1696static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1697{
1698 pci_save_state(pdev);
1699 meye.pm_mchip_mode = meye.mchip_mode;
1700 mchip_hic_stop();
1701 mchip_set(MCHIP_MM_INTA, 0x0);
1702 return 0;
1703}
1704
1705static int meye_resume(struct pci_dev *pdev)
1706{
1707 pci_restore_state(pdev);
1708 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1709
1710 mchip_delay(MCHIP_HIC_CMD, 0);
1711 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1712 msleep(1);
1713 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1714 msleep(1);
1715 mchip_set(MCHIP_MM_PCI_MODE, 5);
1716 msleep(1);
1717 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1718
1719 switch (meye.pm_mchip_mode) {
1720 case MCHIP_HIC_MODE_CONT_OUT:
1721 mchip_continuous_start();
1722 break;
1723 case MCHIP_HIC_MODE_CONT_COMP:
1724 mchip_cont_compression_start();
1725 break;
1726 }
1727 return 0;
1728}
1729#endif
1730
1731static int __devinit meye_probe(struct pci_dev *pcidev,
1732 const struct pci_device_id *ent)
1733{
1734 struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
1735 int ret = -EBUSY;
1736 unsigned long mchip_adr;
1737
1738 if (meye.mchip_dev != NULL) {
1739 printk(KERN_ERR "meye: only one device allowed!\n");
1740 goto outnotdev;
1741 }
1742
1743 ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1744 if (ret < 0) {
1745 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1746 return ret;
1747 }
1748 ret = -ENOMEM;
1749 meye.mchip_dev = pcidev;
1750 meye.vdev = video_device_alloc();
1751 if (!meye.vdev) {
1752 v4l2_err(v4l2_dev, "video_device_alloc() failed!\n");
1753 goto outnotdev;
1754 }
1755
1756 meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1757 if (!meye.grab_temp) {
1758 v4l2_err(v4l2_dev, "grab buffer allocation failed\n");
1759 goto outvmalloc;
1760 }
1761
1762 spin_lock_init(&meye.grabq_lock);
1763 if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1764 GFP_KERNEL)) {
1765 v4l2_err(v4l2_dev, "fifo allocation failed\n");
1766 goto outkfifoalloc1;
1767 }
1768 spin_lock_init(&meye.doneq_lock);
1769 if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1770 GFP_KERNEL)) {
1771 v4l2_err(v4l2_dev, "fifo allocation failed\n");
1772 goto outkfifoalloc2;
1773 }
1774
1775 memcpy(meye.vdev, &meye_template, sizeof(meye_template));
1776 meye.vdev->v4l2_dev = &meye.v4l2_dev;
1777
1778 ret = -EIO;
1779 if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
1780 v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
1781 v4l2_err(v4l2_dev, "meye: did you enable the camera in "
1782 "sonypi using the module options ?\n");
1783 goto outsonypienable;
1784 }
1785
1786 if ((ret = pci_enable_device(meye.mchip_dev))) {
1787 v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
1788 goto outenabledev;
1789 }
1790
1791 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1792 if (!mchip_adr) {
1793 v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
1794 goto outregions;
1795 }
1796 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1797 pci_resource_len(meye.mchip_dev, 0),
1798 "meye")) {
1799 v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
1800 goto outregions;
1801 }
1802 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1803 if (!meye.mchip_mmregs) {
1804 v4l2_err(v4l2_dev, "meye: ioremap failed\n");
1805 goto outremap;
1806 }
1807
1808 meye.mchip_irq = pcidev->irq;
1809 if (request_irq(meye.mchip_irq, meye_irq,
1810 IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) {
1811 v4l2_err(v4l2_dev, "request_irq failed\n");
1812 goto outreqirq;
1813 }
1814
1815 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1816 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1817
1818 pci_set_master(meye.mchip_dev);
1819
1820 /* Ask the camera to perform a soft reset. */
1821 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1822
1823 mchip_delay(MCHIP_HIC_CMD, 0);
1824 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1825
1826 msleep(1);
1827 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1828
1829 msleep(1);
1830 mchip_set(MCHIP_MM_PCI_MODE, 5);
1831
1832 msleep(1);
1833 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1834
1835 mutex_init(&meye.lock);
1836 init_waitqueue_head(&meye.proc_list);
1837 meye.brightness = 32 << 10;
1838 meye.hue = 32 << 10;
1839 meye.colour = 32 << 10;
1840 meye.contrast = 32 << 10;
1841 meye.params.subsample = 0;
1842 meye.params.quality = 8;
1843 meye.params.sharpness = 32;
1844 meye.params.agc = 48;
1845 meye.params.picture = 0;
1846 meye.params.framerate = 0;
1847
1848 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32);
1849 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32);
1850 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32);
1851 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32);
1852 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32);
1853 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1854 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
1855
1856 if (video_register_device(meye.vdev, VFL_TYPE_GRABBER,
1857 video_nr) < 0) {
1858 v4l2_err(v4l2_dev, "video_register_device failed\n");
1859 goto outvideoreg;
1860 }
1861
1862 v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1863 MEYE_DRIVER_VERSION);
1864 v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1865 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1866
1867 return 0;
1868
1869outvideoreg:
1870 free_irq(meye.mchip_irq, meye_irq);
1871outreqirq:
1872 iounmap(meye.mchip_mmregs);
1873outremap:
1874 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1875 pci_resource_len(meye.mchip_dev, 0));
1876outregions:
1877 pci_disable_device(meye.mchip_dev);
1878outenabledev:
1879 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1880outsonypienable:
1881 kfifo_free(&meye.doneq);
1882outkfifoalloc2:
1883 kfifo_free(&meye.grabq);
1884outkfifoalloc1:
1885 vfree(meye.grab_temp);
1886outvmalloc:
1887 video_device_release(meye.vdev);
1888outnotdev:
1889 return ret;
1890}
1891
1892static void __devexit meye_remove(struct pci_dev *pcidev)
1893{
1894 video_unregister_device(meye.vdev);
1895
1896 mchip_hic_stop();
1897
1898 mchip_dma_free();
1899
1900 /* disable interrupts */
1901 mchip_set(MCHIP_MM_INTA, 0x0);
1902
1903 free_irq(meye.mchip_irq, meye_irq);
1904
1905 iounmap(meye.mchip_mmregs);
1906
1907 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1908 pci_resource_len(meye.mchip_dev, 0));
1909
1910 pci_disable_device(meye.mchip_dev);
1911
1912 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1913
1914 kfifo_free(&meye.doneq);
1915 kfifo_free(&meye.grabq);
1916
1917 vfree(meye.grab_temp);
1918
1919 if (meye.grab_fbuffer) {
1920 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1921 meye.grab_fbuffer = NULL;
1922 }
1923
1924 printk(KERN_INFO "meye: removed\n");
1925}
1926
1927static struct pci_device_id meye_pci_tbl[] = {
1928 { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1929 { }
1930};
1931
1932MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1933
1934static struct pci_driver meye_driver = {
1935 .name = "meye",
1936 .id_table = meye_pci_tbl,
1937 .probe = meye_probe,
1938 .remove = __devexit_p(meye_remove),
1939#ifdef CONFIG_PM
1940 .suspend = meye_suspend,
1941 .resume = meye_resume,
1942#endif
1943};
1944
1945static int __init meye_init(void)
1946{
1947 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1948 if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1949 gbufsize = MEYE_MAX_BUFSIZE;
1950 gbufsize = PAGE_ALIGN(gbufsize);
1951 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) "
1952 "for capture\n",
1953 gbuffers,
1954 gbufsize / 1024, gbuffers * gbufsize / 1024);
1955 return pci_register_driver(&meye_driver);
1956}
1957
1958static void __exit meye_exit(void)
1959{
1960 pci_unregister_driver(&meye_driver);
1961}
1962
1963module_init(meye_init);
1964module_exit(meye_exit);
diff --git a/drivers/media/pci/meye/meye.h b/drivers/media/pci/meye/meye.h
new file mode 100644
index 000000000000..4bdeb03f1644
--- /dev/null
+++ b/drivers/media/pci/meye/meye.h
@@ -0,0 +1,324 @@
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
30#ifndef _MEYE_PRIV_H_
31#define _MEYE_PRIV_H_
32
33#define MEYE_DRIVER_MAJORVERSION 1
34#define MEYE_DRIVER_MINORVERSION 14
35
36#define MEYE_DRIVER_VERSION __stringify(MEYE_DRIVER_MAJORVERSION) "." \
37 __stringify(MEYE_DRIVER_MINORVERSION)
38
39#include <linux/types.h>
40#include <linux/pci.h>
41#include <linux/kfifo.h>
42
43/****************************************************************************/
44/* Motion JPEG chip registers */
45/****************************************************************************/
46
47/* Motion JPEG chip PCI configuration registers */
48#define MCHIP_PCI_POWER_CSR 0x54
49#define MCHIP_PCI_MCORE_STATUS 0x60 /* see HIC_STATUS */
50#define MCHIP_PCI_HOSTUSEREQ_SET 0x64
51#define MCHIP_PCI_HOSTUSEREQ_CLR 0x68
52#define MCHIP_PCI_LOWPOWER_SET 0x6c
53#define MCHIP_PCI_LOWPOWER_CLR 0x70
54#define MCHIP_PCI_SOFTRESET_SET 0x74
55
56/* Motion JPEG chip memory mapped registers */
57#define MCHIP_MM_REGS 0x200 /* 512 bytes */
58#define MCHIP_REG_TIMEOUT 1000 /* reg access, ~us */
59#define MCHIP_MCC_VRJ_TIMEOUT 1000 /* MCC & VRJ access */
60
61#define MCHIP_MM_PCI_MODE 0x00 /* PCI access mode */
62#define MCHIP_MM_PCI_MODE_RETRY 0x00000001 /* retry mode */
63#define MCHIP_MM_PCI_MODE_MASTER 0x00000002 /* master access */
64#define MCHIP_MM_PCI_MODE_READ_LINE 0x00000004 /* read line */
65
66#define MCHIP_MM_INTA 0x04 /* Int status/mask */
67#define MCHIP_MM_INTA_MCC 0x00000001 /* MCC interrupt */
68#define MCHIP_MM_INTA_VRJ 0x00000002 /* VRJ interrupt */
69#define MCHIP_MM_INTA_HIC_1 0x00000004 /* one frame done */
70#define MCHIP_MM_INTA_HIC_1_MASK 0x00000400 /* 1: enable */
71#define MCHIP_MM_INTA_HIC_END 0x00000008 /* all frames done */
72#define MCHIP_MM_INTA_HIC_END_MASK 0x00000800
73#define MCHIP_MM_INTA_JPEG 0x00000010 /* decompress. error */
74#define MCHIP_MM_INTA_JPEG_MASK 0x00001000
75#define MCHIP_MM_INTA_CAPTURE 0x00000020 /* capture end */
76#define MCHIP_MM_INTA_PCI_ERR 0x00000040 /* PCI error */
77#define MCHIP_MM_INTA_PCI_ERR_MASK 0x00004000
78
79#define MCHIP_MM_PT_ADDR 0x08 /* page table address*/
80 /* n*4kB */
81#define MCHIP_NB_PAGES 1024 /* pages for display */
82#define MCHIP_NB_PAGES_MJPEG 256 /* pages for mjpeg */
83
84#define MCHIP_MM_FIR(n) (0x0c+(n)*4) /* Frame info 0-3 */
85#define MCHIP_MM_FIR_RDY 0x00000001 /* frame ready */
86#define MCHIP_MM_FIR_FAILFR_MASK 0xf8000000 /* # of failed frames */
87#define MCHIP_MM_FIR_FAILFR_SHIFT 27
88
89 /* continuous comp/decomp mode */
90#define MCHIP_MM_FIR_C_ENDL_MASK 0x000007fe /* end DW [10] */
91#define MCHIP_MM_FIR_C_ENDL_SHIFT 1
92#define MCHIP_MM_FIR_C_ENDP_MASK 0x0007f800 /* end page [8] */
93#define MCHIP_MM_FIR_C_ENDP_SHIFT 11
94#define MCHIP_MM_FIR_C_STARTP_MASK 0x07f80000 /* start page [8] */
95#define MCHIP_MM_FIR_C_STARTP_SHIFT 19
96
97 /* continuous picture output mode */
98#define MCHIP_MM_FIR_O_STARTP_MASK 0x7ffe0000 /* start page [10] */
99#define MCHIP_MM_FIR_O_STARTP_SHIFT 17
100
101#define MCHIP_MM_FIFO_DATA 0x1c /* PCI TGT FIFO data */
102#define MCHIP_MM_FIFO_STATUS 0x20 /* PCI TGT FIFO stat */
103#define MCHIP_MM_FIFO_MASK 0x00000003
104#define MCHIP_MM_FIFO_WAIT_OR_READY 0x00000002 /* Bits common to WAIT & READY*/
105#define MCHIP_MM_FIFO_IDLE 0x0 /* HIC idle */
106#define MCHIP_MM_FIFO_IDLE1 0x1 /* idem ??? */
107#define MCHIP_MM_FIFO_WAIT 0x2 /* wait request */
108#define MCHIP_MM_FIFO_READY 0x3 /* data ready */
109
110#define MCHIP_HIC_HOST_USEREQ 0x40 /* host uses MCORE */
111
112#define MCHIP_HIC_TP_BUSY 0x44 /* taking picture */
113
114#define MCHIP_HIC_PIC_SAVED 0x48 /* pic in SDRAM */
115
116#define MCHIP_HIC_LOWPOWER 0x4c /* clock stopped */
117
118#define MCHIP_HIC_CTL 0x50 /* HIC control */
119#define MCHIP_HIC_CTL_SOFT_RESET 0x00000001 /* MCORE reset */
120#define MCHIP_HIC_CTL_MCORE_RDY 0x00000002 /* MCORE ready */
121
122#define MCHIP_HIC_CMD 0x54 /* HIC command */
123#define MCHIP_HIC_CMD_BITS 0x00000003 /* cmd width=[1:0]*/
124#define MCHIP_HIC_CMD_NOOP 0x0
125#define MCHIP_HIC_CMD_START 0x1
126#define MCHIP_HIC_CMD_STOP 0x2
127
128#define MCHIP_HIC_MODE 0x58
129#define MCHIP_HIC_MODE_NOOP 0x0
130#define MCHIP_HIC_MODE_STILL_CAP 0x1 /* still pic capt */
131#define MCHIP_HIC_MODE_DISPLAY 0x2 /* display */
132#define MCHIP_HIC_MODE_STILL_COMP 0x3 /* still pic comp. */
133#define MCHIP_HIC_MODE_STILL_DECOMP 0x4 /* still pic decomp. */
134#define MCHIP_HIC_MODE_CONT_COMP 0x5 /* cont capt+comp */
135#define MCHIP_HIC_MODE_CONT_DECOMP 0x6 /* cont decomp+disp */
136#define MCHIP_HIC_MODE_STILL_OUT 0x7 /* still pic output */
137#define MCHIP_HIC_MODE_CONT_OUT 0x8 /* cont output */
138
139#define MCHIP_HIC_STATUS 0x5c
140#define MCHIP_HIC_STATUS_MCC_RDY 0x00000001 /* MCC reg acc ok */
141#define MCHIP_HIC_STATUS_VRJ_RDY 0x00000002 /* VRJ reg acc ok */
142#define MCHIP_HIC_STATUS_IDLE 0x00000003
143#define MCHIP_HIC_STATUS_CAPDIS 0x00000004 /* cap/disp in prog */
144#define MCHIP_HIC_STATUS_COMPDEC 0x00000008 /* (de)comp in prog */
145#define MCHIP_HIC_STATUS_BUSY 0x00000010 /* HIC busy */
146
147#define MCHIP_HIC_S_RATE 0x60 /* MJPEG # frames */
148
149#define MCHIP_HIC_PCI_VFMT 0x64 /* video format */
150#define MCHIP_HIC_PCI_VFMT_YVYU 0x00000001 /* 0: V Y' U Y */
151 /* 1: Y' V Y U */
152
153#define MCHIP_MCC_CMD 0x80 /* MCC commands */
154#define MCHIP_MCC_CMD_INITIAL 0x0 /* idle ? */
155#define MCHIP_MCC_CMD_IIC_START_SET 0x1
156#define MCHIP_MCC_CMD_IIC_END_SET 0x2
157#define MCHIP_MCC_CMD_FM_WRITE 0x3 /* frame memory */
158#define MCHIP_MCC_CMD_FM_READ 0x4
159#define MCHIP_MCC_CMD_FM_STOP 0x5
160#define MCHIP_MCC_CMD_CAPTURE 0x6
161#define MCHIP_MCC_CMD_DISPLAY 0x7
162#define MCHIP_MCC_CMD_END_DISP 0x8
163#define MCHIP_MCC_CMD_STILL_COMP 0x9
164#define MCHIP_MCC_CMD_STILL_DECOMP 0xa
165#define MCHIP_MCC_CMD_STILL_OUTPUT 0xb
166#define MCHIP_MCC_CMD_CONT_OUTPUT 0xc
167#define MCHIP_MCC_CMD_CONT_COMP 0xd
168#define MCHIP_MCC_CMD_CONT_DECOMP 0xe
169#define MCHIP_MCC_CMD_RESET 0xf /* MCC reset */
170
171#define MCHIP_MCC_IIC_WR 0x84
172
173#define MCHIP_MCC_MCC_WR 0x88
174
175#define MCHIP_MCC_MCC_RD 0x8c
176
177#define MCHIP_MCC_STATUS 0x90
178#define MCHIP_MCC_STATUS_CAPT 0x00000001 /* capturing */
179#define MCHIP_MCC_STATUS_DISP 0x00000002 /* displaying */
180#define MCHIP_MCC_STATUS_COMP 0x00000004 /* compressing */
181#define MCHIP_MCC_STATUS_DECOMP 0x00000008 /* decompressing */
182#define MCHIP_MCC_STATUS_MCC_WR 0x00000010 /* register ready */
183#define MCHIP_MCC_STATUS_MCC_RD 0x00000020 /* register ready */
184#define MCHIP_MCC_STATUS_IIC_WR 0x00000040 /* register ready */
185#define MCHIP_MCC_STATUS_OUTPUT 0x00000080 /* output in prog */
186
187#define MCHIP_MCC_SIG_POLARITY 0x94
188#define MCHIP_MCC_SIG_POL_VS_H 0x00000001 /* VS active-high */
189#define MCHIP_MCC_SIG_POL_HS_H 0x00000002 /* HS active-high */
190#define MCHIP_MCC_SIG_POL_DOE_H 0x00000004 /* DOE active-high */
191
192#define MCHIP_MCC_IRQ 0x98
193#define MCHIP_MCC_IRQ_CAPDIS_STRT 0x00000001 /* cap/disp started */
194#define MCHIP_MCC_IRQ_CAPDIS_STRT_MASK 0x00000010
195#define MCHIP_MCC_IRQ_CAPDIS_END 0x00000002 /* cap/disp ended */
196#define MCHIP_MCC_IRQ_CAPDIS_END_MASK 0x00000020
197#define MCHIP_MCC_IRQ_COMPDEC_STRT 0x00000004 /* (de)comp started */
198#define MCHIP_MCC_IRQ_COMPDEC_STRT_MASK 0x00000040
199#define MCHIP_MCC_IRQ_COMPDEC_END 0x00000008 /* (de)comp ended */
200#define MCHIP_MCC_IRQ_COMPDEC_END_MASK 0x00000080
201
202#define MCHIP_MCC_HSTART 0x9c /* video in */
203#define MCHIP_MCC_VSTART 0xa0
204#define MCHIP_MCC_HCOUNT 0xa4
205#define MCHIP_MCC_VCOUNT 0xa8
206#define MCHIP_MCC_R_XBASE 0xac /* capt/disp */
207#define MCHIP_MCC_R_YBASE 0xb0
208#define MCHIP_MCC_R_XRANGE 0xb4
209#define MCHIP_MCC_R_YRANGE 0xb8
210#define MCHIP_MCC_B_XBASE 0xbc /* comp/decomp */
211#define MCHIP_MCC_B_YBASE 0xc0
212#define MCHIP_MCC_B_XRANGE 0xc4
213#define MCHIP_MCC_B_YRANGE 0xc8
214
215#define MCHIP_MCC_R_SAMPLING 0xcc /* 1: 1:4 */
216
217#define MCHIP_VRJ_CMD 0x100 /* VRJ commands */
218
219/* VRJ registers (see table 12.2.4) */
220#define MCHIP_VRJ_COMPRESSED_DATA 0x1b0
221#define MCHIP_VRJ_PIXEL_DATA 0x1b8
222
223#define MCHIP_VRJ_BUS_MODE 0x100
224#define MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL 0x108
225#define MCHIP_VRJ_PDAT_USE 0x110
226#define MCHIP_VRJ_MODE_SPECIFY 0x118
227#define MCHIP_VRJ_LIMIT_COMPRESSED_LO 0x120
228#define MCHIP_VRJ_LIMIT_COMPRESSED_HI 0x124
229#define MCHIP_VRJ_COMP_DATA_FORMAT 0x128
230#define MCHIP_VRJ_TABLE_DATA 0x140
231#define MCHIP_VRJ_RESTART_INTERVAL 0x148
232#define MCHIP_VRJ_NUM_LINES 0x150
233#define MCHIP_VRJ_NUM_PIXELS 0x158
234#define MCHIP_VRJ_NUM_COMPONENTS 0x160
235#define MCHIP_VRJ_SOF1 0x168
236#define MCHIP_VRJ_SOF2 0x170
237#define MCHIP_VRJ_SOF3 0x178
238#define MCHIP_VRJ_SOF4 0x180
239#define MCHIP_VRJ_SOS 0x188
240#define MCHIP_VRJ_SOFT_RESET 0x190
241
242#define MCHIP_VRJ_STATUS 0x1c0
243#define MCHIP_VRJ_STATUS_BUSY 0x00001
244#define MCHIP_VRJ_STATUS_COMP_ACCESS 0x00002
245#define MCHIP_VRJ_STATUS_PIXEL_ACCESS 0x00004
246#define MCHIP_VRJ_STATUS_ERROR 0x00008
247
248#define MCHIP_VRJ_IRQ_FLAG 0x1c8
249#define MCHIP_VRJ_ERROR_REPORT 0x1d8
250
251#define MCHIP_VRJ_START_COMMAND 0x1a0
252
253/****************************************************************************/
254/* Driver definitions. */
255/****************************************************************************/
256
257/* Sony Programmable I/O Controller for accessing the camera commands */
258#include <linux/sony-laptop.h>
259
260/* private API definitions */
261#include <linux/meye.h>
262#include <linux/mutex.h>
263
264
265/* Enable jpg software correction */
266#define MEYE_JPEG_CORRECTION 1
267
268/* Maximum size of a buffer */
269#define MEYE_MAX_BUFSIZE 614400 /* 640 * 480 * 2 */
270
271/* Maximum number of buffers */
272#define MEYE_MAX_BUFNBRS 32
273
274/* State of a buffer */
275#define MEYE_BUF_UNUSED 0 /* not used */
276#define MEYE_BUF_USING 1 /* currently grabbing / playing */
277#define MEYE_BUF_DONE 2 /* done */
278
279/* grab buffer */
280struct meye_grab_buffer {
281 int state; /* state of buffer */
282 unsigned long size; /* size of jpg frame */
283 struct timeval timestamp; /* timestamp */
284 unsigned long sequence; /* sequence number */
285};
286
287/* size of kfifos containings buffer indices */
288#define MEYE_QUEUE_SIZE MEYE_MAX_BUFNBRS
289
290/* Motion Eye device structure */
291struct meye {
292 struct v4l2_device v4l2_dev; /* Main v4l2_device struct */
293 struct pci_dev *mchip_dev; /* pci device */
294 u8 mchip_irq; /* irq */
295 u8 mchip_mode; /* actual mchip mode: HIC_MODE... */
296 u8 mchip_fnum; /* current mchip frame number */
297 unsigned char __iomem *mchip_mmregs;/* mchip: memory mapped registers */
298 u8 *mchip_ptable[MCHIP_NB_PAGES];/* mchip: ptable */
299 void *mchip_ptable_toc; /* mchip: ptable toc */
300 dma_addr_t mchip_dmahandle; /* mchip: dma handle to ptable toc */
301 unsigned char *grab_fbuffer; /* capture framebuffer */
302 unsigned char *grab_temp; /* temporary buffer */
303 /* list of buffers */
304 struct meye_grab_buffer grab_buffer[MEYE_MAX_BUFNBRS];
305 int vma_use_count[MEYE_MAX_BUFNBRS]; /* mmap count */
306 struct mutex lock; /* mutex for open/mmap... */
307 struct kfifo grabq; /* queue for buffers to be grabbed */
308 spinlock_t grabq_lock; /* lock protecting the queue */
309 struct kfifo doneq; /* queue for grabbed buffers */
310 spinlock_t doneq_lock; /* lock protecting the queue */
311 wait_queue_head_t proc_list; /* wait queue */
312 struct video_device *vdev; /* video device parameters */
313 u16 brightness;
314 u16 hue;
315 u16 contrast;
316 u16 colour;
317 struct meye_params params; /* additional parameters */
318 unsigned long in_use; /* set to 1 if the device is in use */
319#ifdef CONFIG_PM
320 u8 pm_mchip_mode; /* old mchip mode */
321#endif
322};
323
324#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-28 02:19:00 -0500