OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [meye.c] - Blame information for rev 62

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.