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/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 44MODULE_AUTHOR("Stelian Pop <stelian@popies.net>"); 45MODULE_DESCRIPTION("v4l/v4l2 driver for the MotionEye camera"); 46MODULE_LICENSE("GPL"); 47MODULE_VERSION(MEYE_DRIVER_VERSION); 48 49/* force usage of V4L1 API */ 50static int forcev4l1; /* = 0 */ 51module_param(forcev4l1, int, 0644); 52MODULE_PARM_DESC(forcev4l1, "force use of V4L1 instead of V4L2"); 53 54/* number of grab buffers */ 55static unsigned int gbuffers = 2; 56module_param(gbuffers, int, 0444); 57MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)"); 58 59/* size of a grab buffer */ 60static unsigned int gbufsize = MEYE_MAX_BUFSIZE; 61module_param(gbufsize, int, 0444); 62MODULE_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 */ 66static int video_nr = -1; 67module_param(video_nr, int, 0444); 68MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)"); 69 70/* driver structure - only one possible */ 71static struct meye meye; 72 73/****************************************************************************/ 74/* Memory allocation routines (stolen from bttv-driver.c) */ 75/****************************************************************************/ 76static 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 95static 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 */ 116static 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 167static 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 */ 194static 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 */ 211static 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 */ 357static 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 */ 401static inline int mchip_hsize(void) 402{ 403 return meye.params.subsample ? 320 : 640; 404} 405 406/* returns the vertical capture size */ 407static inline int mchip_vsize(void) 408{ 409 return meye.params.subsample ? 240 : 480; 410} 411 412/* waits for a register to be available */ 413static 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 */ 447static 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 */ 454static 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 */ 461static 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 */ 470static 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 */ 481static 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 */ 488static 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 */ 504static 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 */ 528static 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 */ 539static 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 */ 548static 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 */ 558static 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 */ 587static 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 */ 596static 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 */ 605static 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 */ 615static 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 */ 660static 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 */ 681static 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 */ 706static 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 */ 722static 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 752/* start continuous compressed capture */ 753static void mchip_cont_compression_start(void) 754{ 755 mchip_hic_stop(); 756 mchip_vrj_setup(0x3f); 757 mchip_subsample(); 758 mchip_set_framerate(); 759 mchip_dma_setup(meye.mchip_dmahandle); 760 761 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP; 762 763 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP); 764 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START); 765 766 mchip_delay(MCHIP_HIC_CMD, 0); 767} 768 769/****************************************************************************/ 770/* Interrupt handling */ 771/****************************************************************************/ 772 773static irqreturn_t meye_irq(int irq, void *dev_id) 774{ 775 u32 v; 776 int reqnr; 777 static int sequence = 0; 778 779 v = mchip_read(MCHIP_MM_INTA); 780 781 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT && 782 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP) 783 return IRQ_NONE; 784 785again: 786 v = mchip_get_frame(); 787 if (!(v & MCHIP_MM_FIR_RDY)) 788 return IRQ_HANDLED; 789 790 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) { 791 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr, 792 sizeof(int)) != sizeof(int)) { 793 mchip_free_frame(); 794 return IRQ_HANDLED; 795 } 796 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr, 797 mchip_hsize() * mchip_vsize() * 2); 798 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2; 799 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE; 800 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp); 801 meye.grab_buffer[reqnr].sequence = sequence++; 802 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int)); 803 wake_up_interruptible(&meye.proc_list); 804 } else { 805 int size; 806 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize); 807 if (size == -1) { 808 mchip_free_frame(); 809 goto again; 810 } 811 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr, 812 sizeof(int)) != sizeof(int)) { 813 mchip_free_frame(); 814 goto again; 815 } 816 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp, 817 size); 818 meye.grab_buffer[reqnr].size = size; 819 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE; 820 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp); 821 meye.grab_buffer[reqnr].sequence = sequence++; 822 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int)); 823 wake_up_interruptible(&meye.proc_list); 824 } 825 mchip_free_frame(); 826 goto again; 827} 828 829/****************************************************************************/ 830/* video4linux integration */ 831/****************************************************************************/ 832 833static int meye_open(struct inode *inode, struct file *file) 834{ 835 int i, err; 836 837 err = video_exclusive_open(inode, file); 838 if (err < 0) 839 return err; 840 841 mchip_hic_stop(); 842 843 if (mchip_dma_alloc()) { 844 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n"); 845 video_exclusive_release(inode, file); 846 return -ENOBUFS; 847 } 848 849 for (i = 0; i < MEYE_MAX_BUFNBRS; i++) 850 meye.grab_buffer[i].state = MEYE_BUF_UNUSED; 851 kfifo_reset(meye.grabq); 852 kfifo_reset(meye.doneq); 853 return 0; 854} 855 856static int meye_release(struct inode *inode, struct file *file) 857{ 858 mchip_hic_stop(); 859 mchip_dma_free(); 860 video_exclusive_release(inode, file); 861 return 0; 862} 863 864static int meye_do_ioctl(struct inode *inode, struct file *file, 865 unsigned int cmd, void *arg) 866{ 867 switch (cmd) { 868 869 case VIDIOCGCAP: { 870 struct video_capability *b = arg; 871 strcpy(b->name,meye.video_dev->name); 872 b->type = VID_TYPE_CAPTURE; 873 b->channels = 1; 874 b->audios = 0; 875 b->maxwidth = 640; 876 b->maxheight = 480; 877 b->minwidth = 320; 878 b->minheight = 240; 879 break; 880 } 881 882 case VIDIOCGCHAN: { 883 struct video_channel *v = arg; 884 v->flags = 0; 885 v->tuners = 0; 886 v->type = VIDEO_TYPE_CAMERA; 887 if (v->channel != 0) 888 return -EINVAL; 889 strcpy(v->name,"Camera"); 890 break; 891 } 892 893 case VIDIOCSCHAN: { 894 struct video_channel *v = arg; 895 if (v->channel != 0) 896 return -EINVAL; 897 break; 898 } 899 900 case VIDIOCGPICT: { 901 struct video_picture *p = arg; 902 *p = meye.picture; 903 break; 904 } 905 906 case VIDIOCSPICT: { 907 struct video_picture *p = arg; 908 if (p->depth != 16) 909 return -EINVAL; 910 if (p->palette != VIDEO_PALETTE_YUV422 && p->palette != VIDEO_PALETTE_YUYV) 911 return -EINVAL; 912 mutex_lock(&meye.lock); 913 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 914 p->brightness >> 10); 915 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 916 p->hue >> 10); 917 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 918 p->colour >> 10); 919 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 920 p->contrast >> 10); 921 meye.picture = *p; 922 mutex_unlock(&meye.lock); 923 break; 924 } 925 926 case VIDIOCSYNC: { 927 int *i = arg; 928 int unused; 929 930 if (*i < 0 || *i >= gbuffers) 931 return -EINVAL; 932 933 mutex_lock(&meye.lock); 934 935 switch (meye.grab_buffer[*i].state) { 936 937 case MEYE_BUF_UNUSED: 938 mutex_unlock(&meye.lock); 939 return -EINVAL; 940 case MEYE_BUF_USING: 941 if (file->f_flags & O_NONBLOCK) { 942 mutex_unlock(&meye.lock); 943 return -EAGAIN; 944 } 945 if (wait_event_interruptible(meye.proc_list, 946 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) { 947 mutex_unlock(&meye.lock); 948 return -EINTR; 949 } 950 /* fall through */ 951 case MEYE_BUF_DONE: 952 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED; 953 kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int)); 954 } 955 mutex_unlock(&meye.lock); 956 break; 957 } 958 959 case VIDIOCMCAPTURE: { 960 struct video_mmap *vm = arg; 961 int restart = 0; 962 963 if (vm->frame >= gbuffers || vm->frame < 0) 964 return -EINVAL; 965 if (vm->format != VIDEO_PALETTE_YUV422 && vm->format != VIDEO_PALETTE_YUYV) 966 return -EINVAL; 967 if (vm->height * vm->width * 2 > gbufsize) 968 return -EINVAL; 969 if (!meye.grab_fbuffer) 970 return -EINVAL; 971 if (meye.grab_buffer[vm->frame].state != MEYE_BUF_UNUSED) 972 return -EBUSY; 973 974 mutex_lock(&meye.lock); 975 if (vm->width == 640 && vm->height == 480) { 976 if (meye.params.subsample) { 977 meye.params.subsample = 0; 978 restart = 1; 979 } 980 } else if (vm->width == 320 && vm->height == 240) { 981 if (!meye.params.subsample) { 982 meye.params.subsample = 1; 983 restart = 1; 984 } 985 } else { 986 mutex_unlock(&meye.lock); 987 return -EINVAL; 988 } 989 990 if (restart || meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT) 991 mchip_continuous_start(); 992 meye.grab_buffer[vm->frame].state = MEYE_BUF_USING; 993 kfifo_put(meye.grabq, (unsigned char *)&vm->frame, sizeof(int)); 994 mutex_unlock(&meye.lock); 995 break; 996 } 997 998 case VIDIOCGMBUF: { 999 struct video_mbuf *vm = arg; 1000 int i; 1001 1002 memset(vm, 0 , sizeof(*vm)); 1003 vm->size = gbufsize * gbuffers; 1004 vm->frames = gbuffers; 1005 for (i = 0; i < gbuffers; i++) 1006 vm->offsets[i] = i * gbufsize; 1007 break; 1008 } 1009 1010 case MEYEIOC_G_PARAMS: { 1011 struct meye_params *p = arg; 1012 *p = meye.params; 1013 break; 1014 } 1015 1016 case MEYEIOC_S_PARAMS: { 1017 struct meye_params *jp = arg; 1018 if (jp->subsample > 1) 1019 return -EINVAL; 1020 if (jp->quality > 10) 1021 return -EINVAL; 1022 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63) 1023 return -EINVAL; 1024 if (jp->framerate > 31) 1025 return -EINVAL; 1026 mutex_lock(&meye.lock); 1027 if (meye.params.subsample != jp->subsample || 1028 meye.params.quality != jp->quality) 1029 mchip_hic_stop(); /* need restart */ 1030 meye.params = *jp; 1031 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 1032 meye.params.sharpness); 1033 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 1034 meye.params.agc); 1035 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 1036 meye.params.picture); 1037 mutex_unlock(&meye.lock); 1038 break; 1039 } 1040 1041 case MEYEIOC_QBUF_CAPT: { 1042 int *nb = arg; 1043 1044 if (!meye.grab_fbuffer) 1045 return -EINVAL; 1046 if (*nb >= gbuffers) 1047 return -EINVAL; 1048 if (*nb < 0) { 1049 /* stop capture */ 1050 mchip_hic_stop(); 1051 return 0; 1052 } 1053 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED) 1054 return -EBUSY; 1055 mutex_lock(&meye.lock); 1056 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP) 1057 mchip_cont_compression_start(); 1058 meye.grab_buffer[*nb].state = MEYE_BUF_USING; 1059 kfifo_put(meye.grabq, (unsigned char *)nb, sizeof(int)); 1060 mutex_unlock(&meye.lock); 1061 break; 1062 } 1063 1064 case MEYEIOC_SYNC: { 1065 int *i = arg; 1066 int unused; 1067 1068 if (*i < 0 || *i >= gbuffers) 1069 return -EINVAL; 1070 1071 mutex_lock(&meye.lock); 1072 switch (meye.grab_buffer[*i].state) { 1073 1074 case MEYE_BUF_UNUSED: 1075 mutex_unlock(&meye.lock); 1076 return -EINVAL; 1077 case MEYE_BUF_USING: 1078 if (file->f_flags & O_NONBLOCK) { 1079 mutex_unlock(&meye.lock); 1080 return -EAGAIN; 1081 } 1082 if (wait_event_interruptible(meye.proc_list, 1083 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) { 1084 mutex_unlock(&meye.lock); 1085 return -EINTR; 1086 } 1087 /* fall through */ 1088 case MEYE_BUF_DONE: 1089 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED; 1090 kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int)); 1091 } 1092 *i = meye.grab_buffer[*i].size; 1093 mutex_unlock(&meye.lock); 1094 break; 1095 } 1096 1097 case MEYEIOC_STILLCAPT: { 1098 1099 if (!meye.grab_fbuffer) 1100 return -EINVAL; 1101 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED) 1102 return -EBUSY; 1103 mutex_lock(&meye.lock); 1104 meye.grab_buffer[0].state = MEYE_BUF_USING; 1105 mchip_take_picture(); 1106 mchip_get_picture( 1107 meye.grab_fbuffer, 1108 mchip_hsize() * mchip_vsize() * 2); 1109 meye.grab_buffer[0].state = MEYE_BUF_DONE; 1110 mutex_unlock(&meye.lock); 1111 break; 1112 } 1113 1114 case MEYEIOC_STILLJCAPT: { 1115 int *len = arg; 1116 1117 if (!meye.grab_fbuffer) 1118 return -EINVAL; 1119 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED) 1120 return -EBUSY; 1121 mutex_lock(&meye.lock); 1122 meye.grab_buffer[0].state = MEYE_BUF_USING; 1123 *len = -1; 1124 while (*len == -1) { 1125 mchip_take_picture(); 1126 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize); 1127 } 1128 meye.grab_buffer[0].state = MEYE_BUF_DONE; 1129 mutex_unlock(&meye.lock); 1130 break; 1131 } 1132 1133 case VIDIOC_QUERYCAP: { 1134 struct v4l2_capability *cap = arg; 1135 1136 if (forcev4l1) 1137 return -EINVAL; 1138 1139 memset(cap, 0, sizeof(*cap)); 1140 strcpy(cap->driver, "meye"); 1141 strcpy(cap->card, "meye"); 1142 sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev)); 1143 cap->version = (MEYE_DRIVER_MAJORVERSION << 8) + 1144 MEYE_DRIVER_MINORVERSION; 1145 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | 1146 V4L2_CAP_STREAMING; 1147 break; 1148 } 1149 1150 case VIDIOC_ENUMINPUT: { 1151 struct v4l2_input *i = arg; 1152 1153 if (i->index != 0) 1154 return -EINVAL; 1155 memset(i, 0, sizeof(*i)); 1156 i->index = 0; 1157 strcpy(i->name, "Camera"); 1158 i->type = V4L2_INPUT_TYPE_CAMERA; 1159 break; 1160 } 1161 1162 case VIDIOC_G_INPUT: { 1163 int *i = arg; 1164 1165 *i = 0; 1166 break; 1167 } 1168 1169 case VIDIOC_S_INPUT: { 1170 int *i = arg; 1171 1172 if (*i != 0) 1173 return -EINVAL; 1174 break; 1175 } 1176 1177 case VIDIOC_QUERYCTRL: { 1178 struct v4l2_queryctrl *c = arg; 1179 1180 switch (c->id) { 1181 1182 case V4L2_CID_BRIGHTNESS: 1183 c->type = V4L2_CTRL_TYPE_INTEGER; 1184 strcpy(c->name, "Brightness"); 1185 c->minimum = 0; 1186 c->maximum = 63; 1187 c->step = 1; 1188 c->default_value = 32; 1189 c->flags = 0; 1190 break; 1191 case V4L2_CID_HUE: 1192 c->type = V4L2_CTRL_TYPE_INTEGER; 1193 strcpy(c->name, "Hue"); 1194 c->minimum = 0; 1195 c->maximum = 63; 1196 c->step = 1; 1197 c->default_value = 32; 1198 c->flags = 0; 1199 break; 1200 case V4L2_CID_CONTRAST: 1201 c->type = V4L2_CTRL_TYPE_INTEGER; 1202 strcpy(c->name, "Contrast"); 1203 c->minimum = 0; 1204 c->maximum = 63; 1205 c->step = 1; 1206 c->default_value = 32; 1207 c->flags = 0; 1208 break; 1209 case V4L2_CID_SATURATION: 1210 c->type = V4L2_CTRL_TYPE_INTEGER; 1211 strcpy(c->name, "Saturation"); 1212 c->minimum = 0; 1213 c->maximum = 63; 1214 c->step = 1; 1215 c->default_value = 32; 1216 c->flags = 0; 1217 break; 1218 case V4L2_CID_AGC: 1219 c->type = V4L2_CTRL_TYPE_INTEGER; 1220 strcpy(c->name, "Agc"); 1221 c->minimum = 0; 1222 c->maximum = 63; 1223 c->step = 1; 1224 c->default_value = 48; 1225 c->flags = 0; 1226 break; 1227 case V4L2_CID_SHARPNESS: 1228 c->type = V4L2_CTRL_TYPE_INTEGER; 1229 strcpy(c->name, "Sharpness"); 1230 c->minimum = 0; 1231 c->maximum = 63; 1232 c->step = 1; 1233 c->default_value = 32; 1234 c->flags = 0; 1235 break; 1236 case V4L2_CID_PICTURE: 1237 c->type = V4L2_CTRL_TYPE_INTEGER; 1238 strcpy(c->name, "Picture"); 1239 c->minimum = 0; 1240 c->maximum = 63; 1241 c->step = 1; 1242 c->default_value = 0; 1243 c->flags = 0; 1244 break; 1245 case V4L2_CID_JPEGQUAL: 1246 c->type = V4L2_CTRL_TYPE_INTEGER; 1247 strcpy(c->name, "JPEG quality"); 1248 c->minimum = 0; 1249 c->maximum = 10; 1250 c->step = 1; 1251 c->default_value = 8; 1252 c->flags = 0; 1253 break; 1254 case V4L2_CID_FRAMERATE: 1255 c->type = V4L2_CTRL_TYPE_INTEGER; 1256 strcpy(c->name, "Framerate"); 1257 c->minimum = 0; 1258 c->maximum = 31; 1259 c->step = 1; 1260 c->default_value = 0; 1261 c->flags = 0; 1262 break; 1263 default: 1264 return -EINVAL; 1265 } 1266 break; 1267 } 1268 1269 case VIDIOC_S_CTRL: { 1270 struct v4l2_control *c = arg; 1271 1272 mutex_lock(&meye.lock); 1273 switch (c->id) { 1274 case V4L2_CID_BRIGHTNESS: 1275 sony_pic_camera_command( 1276 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, c->value); 1277 meye.picture.brightness = c->value << 10; 1278 break; 1279 case V4L2_CID_HUE: 1280 sony_pic_camera_command( 1281 SONY_PIC_COMMAND_SETCAMERAHUE, c->value); 1282 meye.picture.hue = c->value << 10; 1283 break; 1284 case V4L2_CID_CONTRAST: 1285 sony_pic_camera_command( 1286 SONY_PIC_COMMAND_SETCAMERACONTRAST, c->value); 1287 meye.picture.contrast = c->value << 10; 1288 break; 1289 case V4L2_CID_SATURATION: 1290 sony_pic_camera_command( 1291 SONY_PIC_COMMAND_SETCAMERACOLOR, c->value); 1292 meye.picture.colour = c->value << 10; 1293 break; 1294 case V4L2_CID_AGC: 1295 sony_pic_camera_command( 1296 SONY_PIC_COMMAND_SETCAMERAAGC, c->value); 1297 meye.params.agc = c->value; 1298 break; 1299 case V4L2_CID_SHARPNESS: 1300 sony_pic_camera_command( 1301 SONY_PIC_COMMAND_SETCAMERASHARPNESS, c->value); 1302 meye.params.sharpness = c->value; 1303 break; 1304 case V4L2_CID_PICTURE: 1305 sony_pic_camera_command( 1306 SONY_PIC_COMMAND_SETCAMERAPICTURE, c->value); 1307 meye.params.picture = c->value; 1308 break; 1309 case V4L2_CID_JPEGQUAL: 1310 meye.params.quality = c->value; 1311 break; 1312 case V4L2_CID_FRAMERATE: 1313 meye.params.framerate = c->value; 1314 break; 1315 default: 1316 mutex_unlock(&meye.lock); 1317 return -EINVAL; 1318 } 1319 mutex_unlock(&meye.lock); 1320 break; 1321 } 1322 1323 case VIDIOC_G_CTRL: { 1324 struct v4l2_control *c = arg; 1325 1326 mutex_lock(&meye.lock); 1327 switch (c->id) { 1328 case V4L2_CID_BRIGHTNESS: 1329 c->value = meye.picture.brightness >> 10; 1330 break; 1331 case V4L2_CID_HUE: 1332 c->value = meye.picture.hue >> 10; 1333 break; 1334 case V4L2_CID_CONTRAST: 1335 c->value = meye.picture.contrast >> 10; 1336 break; 1337 case V4L2_CID_SATURATION: 1338 c->value = meye.picture.colour >> 10; 1339 break; 1340 case V4L2_CID_AGC: 1341 c->value = meye.params.agc; 1342 break; 1343 case V4L2_CID_SHARPNESS: 1344 c->value = meye.params.sharpness; 1345 break; 1346 case V4L2_CID_PICTURE: 1347 c->value = meye.params.picture; 1348 break; 1349 case V4L2_CID_JPEGQUAL: 1350 c->value = meye.params.quality; 1351 break; 1352 case V4L2_CID_FRAMERATE: 1353 c->value = meye.params.framerate; 1354 break; 1355 default: 1356 mutex_unlock(&meye.lock); 1357 return -EINVAL; 1358 } 1359 mutex_unlock(&meye.lock); 1360 break; 1361 } 1362 1363 case VIDIOC_ENUM_FMT: { 1364 struct v4l2_fmtdesc *f = arg; 1365 1366 if (f->index > 1) 1367 return -EINVAL; 1368 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1369 return -EINVAL; 1370 if (f->index == 0) { 1371 /* standard YUV 422 capture */ 1372 memset(f, 0, sizeof(*f)); 1373 f->index = 0; 1374 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1375 f->flags = 0; 1376 strcpy(f->description, "YUV422"); 1377 f->pixelformat = V4L2_PIX_FMT_YUYV; 1378 } else { 1379 /* compressed MJPEG capture */ 1380 memset(f, 0, sizeof(*f)); 1381 f->index = 1; 1382 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1383 f->flags = V4L2_FMT_FLAG_COMPRESSED; 1384 strcpy(f->description, "MJPEG"); 1385 f->pixelformat = V4L2_PIX_FMT_MJPEG; 1386 } 1387 break; 1388 } 1389 1390 case VIDIOC_TRY_FMT: { 1391 struct v4l2_format *f = arg; 1392 1393 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1394 return -EINVAL; 1395 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV && 1396 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG) 1397 return -EINVAL; 1398 if (f->fmt.pix.field != V4L2_FIELD_ANY && 1399 f->fmt.pix.field != V4L2_FIELD_NONE) 1400 return -EINVAL; 1401 f->fmt.pix.field = V4L2_FIELD_NONE; 1402 if (f->fmt.pix.width <= 320) { 1403 f->fmt.pix.width = 320; 1404 f->fmt.pix.height = 240; 1405 } else { 1406 f->fmt.pix.width = 640; 1407 f->fmt.pix.height = 480; 1408 } 1409 f->fmt.pix.bytesperline = f->fmt.pix.width * 2; 1410 f->fmt.pix.sizeimage = f->fmt.pix.height * 1411 f->fmt.pix.bytesperline; 1412 f->fmt.pix.colorspace = 0; 1413 f->fmt.pix.priv = 0; 1414 break; 1415 } 1416 1417 case VIDIOC_G_FMT: { 1418 struct v4l2_format *f = arg; 1419 1420 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1421 return -EINVAL; 1422 memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format)); 1423 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1424 switch (meye.mchip_mode) { 1425 case MCHIP_HIC_MODE_CONT_OUT: 1426 default: 1427 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 1428 break; 1429 case MCHIP_HIC_MODE_CONT_COMP: 1430 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG; 1431 break; 1432 } 1433 f->fmt.pix.field = V4L2_FIELD_NONE; 1434 f->fmt.pix.width = mchip_hsize(); 1435 f->fmt.pix.height = mchip_vsize(); 1436 f->fmt.pix.bytesperline = f->fmt.pix.width * 2; 1437 f->fmt.pix.sizeimage = f->fmt.pix.height * 1438 f->fmt.pix.bytesperline; 1439 f->fmt.pix.colorspace = 0; 1440 f->fmt.pix.priv = 0; 1441 break; 1442 } 1443 1444 case VIDIOC_S_FMT: { 1445 struct v4l2_format *f = arg; 1446 1447 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1448 return -EINVAL; 1449 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV && 1450 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG) 1451 return -EINVAL; 1452 if (f->fmt.pix.field != V4L2_FIELD_ANY && 1453 f->fmt.pix.field != V4L2_FIELD_NONE) 1454 return -EINVAL; 1455 f->fmt.pix.field = V4L2_FIELD_NONE; 1456 mutex_lock(&meye.lock); 1457 if (f->fmt.pix.width <= 320) { 1458 f->fmt.pix.width = 320; 1459 f->fmt.pix.height = 240; 1460 meye.params.subsample = 1; 1461 } else { 1462 f->fmt.pix.width = 640; 1463 f->fmt.pix.height = 480; 1464 meye.params.subsample = 0; 1465 } 1466 switch (f->fmt.pix.pixelformat) { 1467 case V4L2_PIX_FMT_YUYV: 1468 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT; 1469 break; 1470 case V4L2_PIX_FMT_MJPEG: 1471 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP; 1472 break; 1473 } 1474 mutex_unlock(&meye.lock); 1475 f->fmt.pix.bytesperline = f->fmt.pix.width * 2; 1476 f->fmt.pix.sizeimage = f->fmt.pix.height * 1477 f->fmt.pix.bytesperline; 1478 f->fmt.pix.colorspace = 0; 1479 f->fmt.pix.priv = 0; 1480 1481 break; 1482 } 1483 1484 case VIDIOC_REQBUFS: { 1485 struct v4l2_requestbuffers *req = arg; 1486 int i; 1487 1488 if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1489 return -EINVAL; 1490 if (req->memory != V4L2_MEMORY_MMAP) 1491 return -EINVAL; 1492 if (meye.grab_fbuffer && req->count == gbuffers) { 1493 /* already allocated, no modifications */ 1494 break; 1495 } 1496 mutex_lock(&meye.lock); 1497 if (meye.grab_fbuffer) { 1498 for (i = 0; i < gbuffers; i++) 1499 if (meye.vma_use_count[i]) { 1500 mutex_unlock(&meye.lock); 1501 return -EINVAL; 1502 } 1503 rvfree(meye.grab_fbuffer, gbuffers * gbufsize); 1504 meye.grab_fbuffer = NULL; 1505 } 1506 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS)); 1507 req->count = gbuffers; 1508 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize); 1509 if (!meye.grab_fbuffer) { 1510 printk(KERN_ERR "meye: v4l framebuffer allocation" 1511 " failed\n"); 1512 mutex_unlock(&meye.lock); 1513 return -ENOMEM; 1514 } 1515 for (i = 0; i < gbuffers; i++) 1516 meye.vma_use_count[i] = 0; 1517 mutex_unlock(&meye.lock); 1518 break; 1519 } 1520 1521 case VIDIOC_QUERYBUF: { 1522 struct v4l2_buffer *buf = arg; 1523 int index = buf->index; 1524 1525 if (index < 0 || index >= gbuffers) 1526 return -EINVAL; 1527 memset(buf, 0, sizeof(*buf)); 1528 buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1529 buf->index = index; 1530 buf->bytesused = meye.grab_buffer[index].size; 1531 buf->flags = V4L2_BUF_FLAG_MAPPED; 1532 if (meye.grab_buffer[index].state == MEYE_BUF_USING) 1533 buf->flags |= V4L2_BUF_FLAG_QUEUED; 1534 if (meye.grab_buffer[index].state == MEYE_BUF_DONE) 1535 buf->flags |= V4L2_BUF_FLAG_DONE; 1536 buf->field = V4L2_FIELD_NONE; 1537 buf->timestamp = meye.grab_buffer[index].timestamp; 1538 buf->sequence = meye.grab_buffer[index].sequence; 1539 buf->memory = V4L2_MEMORY_MMAP; 1540 buf->m.offset = index * gbufsize; 1541 buf->length = gbufsize; 1542 break; 1543 } 1544 1545 case VIDIOC_QBUF: { 1546 struct v4l2_buffer *buf = arg; 1547 1548 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1549 return -EINVAL; 1550 if (buf->memory != V4L2_MEMORY_MMAP) 1551 return -EINVAL; 1552 if (buf->index < 0 || buf->index >= gbuffers) 1553 return -EINVAL; 1554 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED) 1555 return -EINVAL; 1556 mutex_lock(&meye.lock); 1557 buf->flags |= V4L2_BUF_FLAG_QUEUED; 1558 buf->flags &= ~V4L2_BUF_FLAG_DONE; 1559 meye.grab_buffer[buf->index].state = MEYE_BUF_USING; 1560 kfifo_put(meye.grabq, (unsigned char *)&buf->index, sizeof(int)); 1561 mutex_unlock(&meye.lock); 1562 break; 1563 } 1564 1565 case VIDIOC_DQBUF: { 1566 struct v4l2_buffer *buf = arg; 1567 int reqnr; 1568 1569 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1570 return -EINVAL; 1571 if (buf->memory != V4L2_MEMORY_MMAP) 1572 return -EINVAL; 1573 1574 mutex_lock(&meye.lock); 1575 if (kfifo_len(meye.doneq) == 0 && file->f_flags & O_NONBLOCK) { 1576 mutex_unlock(&meye.lock); 1577 return -EAGAIN; 1578 } 1579 if (wait_event_interruptible(meye.proc_list, 1580 kfifo_len(meye.doneq) != 0) < 0) { 1581 mutex_unlock(&meye.lock); 1582 return -EINTR; 1583 } 1584 if (!kfifo_get(meye.doneq, (unsigned char *)&reqnr, 1585 sizeof(int))) { 1586 mutex_unlock(&meye.lock); 1587 return -EBUSY; 1588 } 1589 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) { 1590 mutex_unlock(&meye.lock); 1591 return -EINVAL; 1592 } 1593 buf->index = reqnr; 1594 buf->bytesused = meye.grab_buffer[reqnr].size; 1595 buf->flags = V4L2_BUF_FLAG_MAPPED; 1596 buf->field = V4L2_FIELD_NONE; 1597 buf->timestamp = meye.grab_buffer[reqnr].timestamp; 1598 buf->sequence = meye.grab_buffer[reqnr].sequence; 1599 buf->memory = V4L2_MEMORY_MMAP; 1600 buf->m.offset = reqnr * gbufsize; 1601 buf->length = gbufsize; 1602 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED; 1603 mutex_unlock(&meye.lock); 1604 break; 1605 } 1606 1607 case VIDIOC_STREAMON: { 1608 mutex_lock(&meye.lock); 1609 switch (meye.mchip_mode) { 1610 case MCHIP_HIC_MODE_CONT_OUT: 1611 mchip_continuous_start(); 1612 break; 1613 case MCHIP_HIC_MODE_CONT_COMP: 1614 mchip_cont_compression_start(); 1615 break; 1616 default: 1617 mutex_unlock(&meye.lock); 1618 return -EINVAL; 1619 } 1620 mutex_unlock(&meye.lock); 1621 break; 1622 } 1623 1624 case VIDIOC_STREAMOFF: { 1625 int i; 1626 1627 mutex_lock(&meye.lock); 1628 mchip_hic_stop(); 1629 kfifo_reset(meye.grabq); 1630 kfifo_reset(meye.doneq); 1631 for (i = 0; i < MEYE_MAX_BUFNBRS; i++) 1632 meye.grab_buffer[i].state = MEYE_BUF_UNUSED; 1633 mutex_unlock(&meye.lock); 1634 break; 1635 } 1636 1637 1638 default: 1639 return -ENOIOCTLCMD; 1640 } 1641 1642 return 0; 1643} 1644 1645static int meye_ioctl(struct inode *inode, struct file *file, 1646 unsigned int cmd, unsigned long arg) 1647{ 1648 return video_usercopy(inode, file, cmd, arg, meye_do_ioctl); 1649} 1650 1651static unsigned int meye_poll(struct file *file, poll_table *wait) 1652{ 1653 unsigned int res = 0; 1654 1655 mutex_lock(&meye.lock); 1656 poll_wait(file, &meye.proc_list, wait); 1657 if (kfifo_len(meye.doneq)) 1658 res = POLLIN | POLLRDNORM; 1659 mutex_unlock(&meye.lock); 1660 return res; 1661} 1662 1663static void meye_vm_open(struct vm_area_struct *vma) 1664{ 1665 long idx = (long)vma->vm_private_data; 1666 meye.vma_use_count[idx]++; 1667} 1668 1669static void meye_vm_close(struct vm_area_struct *vma) 1670{ 1671 long idx = (long)vma->vm_private_data; 1672 meye.vma_use_count[idx]--; 1673} 1674 1675static struct vm_operations_struct meye_vm_ops = { 1676 .open = meye_vm_open, 1677 .close = meye_vm_close, 1678}; 1679 1680static int meye_mmap(struct file *file, struct vm_area_struct *vma) 1681{ 1682 unsigned long start = vma->vm_start; 1683 unsigned long size = vma->vm_end - vma->vm_start; 1684 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT; 1685 unsigned long page, pos; 1686 1687 mutex_lock(&meye.lock); 1688 if (size > gbuffers * gbufsize) { 1689 mutex_unlock(&meye.lock); 1690 return -EINVAL; 1691 } 1692 if (!meye.grab_fbuffer) { 1693 int i; 1694 1695 /* lazy allocation */ 1696 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize); 1697 if (!meye.grab_fbuffer) { 1698 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n"); 1699 mutex_unlock(&meye.lock); 1700 return -ENOMEM; 1701 } 1702 for (i = 0; i < gbuffers; i++) 1703 meye.vma_use_count[i] = 0; 1704 } 1705 pos = (unsigned long)meye.grab_fbuffer + offset; 1706 1707 while (size > 0) { 1708 page = vmalloc_to_pfn((void *)pos); 1709 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) { 1710 mutex_unlock(&meye.lock); 1711 return -EAGAIN; 1712 } 1713 start += PAGE_SIZE; 1714 pos += PAGE_SIZE; 1715 if (size > PAGE_SIZE) 1716 size -= PAGE_SIZE; 1717 else 1718 size = 0; 1719 } 1720 1721 vma->vm_ops = &meye_vm_ops; 1722 vma->vm_flags &= ~VM_IO; /* not I/O memory */ 1723 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */ 1724 vma->vm_private_data = (void *) (offset / gbufsize); 1725 meye_vm_open(vma); 1726 1727 mutex_unlock(&meye.lock); 1728 return 0; 1729} 1730 1731static const struct file_operations meye_fops = { 1732 .owner = THIS_MODULE, 1733 .open = meye_open, 1734 .release = meye_release, 1735 .mmap = meye_mmap, 1736 .ioctl = meye_ioctl, 1737 .compat_ioctl = v4l_compat_ioctl32, 1738 .poll = meye_poll, 1739 .llseek = no_llseek, 1740}; 1741 1742static struct video_device meye_template = { 1743 .owner = THIS_MODULE, 1744 .name = "meye", 1745 .type = VID_TYPE_CAPTURE, 1746 .hardware = VID_HARDWARE_MEYE, 1747 .fops = &meye_fops, 1748 .release = video_device_release, 1749 .minor = -1, 1750}; 1751 1752#ifdef CONFIG_PM 1753static int meye_suspend(struct pci_dev *pdev, pm_message_t state) 1754{ 1755 pci_save_state(pdev); 1756 meye.pm_mchip_mode = meye.mchip_mode; 1757 mchip_hic_stop(); 1758 mchip_set(MCHIP_MM_INTA, 0x0); 1759 return 0; 1760} 1761 1762static int meye_resume(struct pci_dev *pdev) 1763{ 1764 pci_restore_state(pdev); 1765 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1); 1766 1767 mchip_delay(MCHIP_HIC_CMD, 0); 1768 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE); 1769 msleep(1); 1770 mchip_set(MCHIP_VRJ_SOFT_RESET, 1); 1771 msleep(1); 1772 mchip_set(MCHIP_MM_PCI_MODE, 5); 1773 msleep(1); 1774 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK); 1775 1776 switch (meye.pm_mchip_mode) { 1777 case MCHIP_HIC_MODE_CONT_OUT: 1778 mchip_continuous_start(); 1779 break; 1780 case MCHIP_HIC_MODE_CONT_COMP: 1781 mchip_cont_compression_start(); 1782 break; 1783 } 1784 return 0; 1785} 1786#endif 1787 1788static int __devinit meye_probe(struct pci_dev *pcidev, 1789 const struct pci_device_id *ent) 1790{ 1791 int ret = -EBUSY; 1792 unsigned long mchip_adr; 1793 u8 revision; 1794 1795 if (meye.mchip_dev != NULL) { 1796 printk(KERN_ERR "meye: only one device allowed!\n"); 1797 goto outnotdev; 1798 } 1799 1800 meye.mchip_dev = pcidev; 1801 meye.video_dev = video_device_alloc(); 1802 if (!meye.video_dev) { 1803 printk(KERN_ERR "meye: video_device_alloc() failed!\n"); 1804 goto outnotdev; 1805 } 1806 1807 ret = -ENOMEM; 1808 meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE); 1809 if (!meye.grab_temp) { 1810 printk(KERN_ERR "meye: grab buffer allocation failed\n"); 1811 goto outvmalloc; 1812 } 1813 1814 spin_lock_init(&meye.grabq_lock); 1815 meye.grabq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL, 1816 &meye.grabq_lock); 1817 if (IS_ERR(meye.grabq)) { 1818 printk(KERN_ERR "meye: fifo allocation failed\n"); 1819 goto outkfifoalloc1; 1820 } 1821 spin_lock_init(&meye.doneq_lock); 1822 meye.doneq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL, 1823 &meye.doneq_lock); 1824 if (IS_ERR(meye.doneq)) { 1825 printk(KERN_ERR "meye: fifo allocation failed\n"); 1826 goto outkfifoalloc2; 1827 } 1828 1829 memcpy(meye.video_dev, &meye_template, sizeof(meye_template)); 1830 meye.video_dev->dev = &meye.mchip_dev->dev; 1831 1832 if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) { 1833 printk(KERN_ERR "meye: unable to power on the camera\n"); 1834 printk(KERN_ERR "meye: did you enable the camera in " 1835 "sonypi using the module options ?\n"); 1836 goto outsonypienable; 1837 } 1838 1839 ret = -EIO; 1840 if ((ret = pci_enable_device(meye.mchip_dev))) { 1841 printk(KERN_ERR "meye: pci_enable_device failed\n"); 1842 goto outenabledev; 1843 } 1844 1845 mchip_adr = pci_resource_start(meye.mchip_dev,0); 1846 if (!mchip_adr) { 1847 printk(KERN_ERR "meye: mchip has no device base address\n"); 1848 goto outregions; 1849 } 1850 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0), 1851 pci_resource_len(meye.mchip_dev, 0), 1852 "meye")) { 1853 printk(KERN_ERR "meye: request_mem_region failed\n"); 1854 goto outregions; 1855 } 1856 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS); 1857 if (!meye.mchip_mmregs) { 1858 printk(KERN_ERR "meye: ioremap failed\n"); 1859 goto outremap; 1860 } 1861 1862 meye.mchip_irq = pcidev->irq; 1863 if (request_irq(meye.mchip_irq, meye_irq, 1864 IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) { 1865 printk(KERN_ERR "meye: request_irq failed\n"); 1866 goto outreqirq; 1867 } 1868 1869 pci_read_config_byte(meye.mchip_dev, PCI_REVISION_ID, &revision); 1870 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8); 1871 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64); 1872 1873 pci_set_master(meye.mchip_dev); 1874 1875 /* Ask the camera to perform a soft reset. */ 1876 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1); 1877 1878 mchip_delay(MCHIP_HIC_CMD, 0); 1879 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE); 1880 1881 msleep(1); 1882 mchip_set(MCHIP_VRJ_SOFT_RESET, 1); 1883 1884 msleep(1); 1885 mchip_set(MCHIP_MM_PCI_MODE, 5); 1886 1887 msleep(1); 1888 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK); 1889 1890 if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER, 1891 video_nr) < 0) { 1892 printk(KERN_ERR "meye: video_register_device failed\n"); 1893 goto outvideoreg; 1894 } 1895 1896 mutex_init(&meye.lock); 1897 init_waitqueue_head(&meye.proc_list); 1898 meye.picture.depth = 16; 1899 meye.picture.palette = VIDEO_PALETTE_YUV422; 1900 meye.picture.brightness = 32 << 10; 1901 meye.picture.hue = 32 << 10; 1902 meye.picture.colour = 32 << 10; 1903 meye.picture.contrast = 32 << 10; 1904 meye.picture.whiteness = 0; 1905 meye.params.subsample = 0; 1906 meye.params.quality = 8; 1907 meye.params.sharpness = 32; 1908 meye.params.agc = 48; 1909 meye.params.picture = 0; 1910 meye.params.framerate = 0; 1911 1912 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32); 1913 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32); 1914 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32); 1915 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32); 1916 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32); 1917 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0); 1918 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48); 1919 1920 printk(KERN_INFO "meye: Motion Eye Camera Driver v%s.\n", 1921 MEYE_DRIVER_VERSION); 1922 printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n", 1923 revision, mchip_adr, meye.mchip_irq); 1924 1925 return 0; 1926 1927outvideoreg: 1928 free_irq(meye.mchip_irq, meye_irq); 1929outreqirq: 1930 iounmap(meye.mchip_mmregs); 1931outremap: 1932 release_mem_region(pci_resource_start(meye.mchip_dev, 0), 1933 pci_resource_len(meye.mchip_dev, 0)); 1934outregions: 1935 pci_disable_device(meye.mchip_dev); 1936outenabledev: 1937 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0); 1938outsonypienable: 1939 kfifo_free(meye.doneq); 1940outkfifoalloc2: 1941 kfifo_free(meye.grabq); 1942outkfifoalloc1: 1943 vfree(meye.grab_temp); 1944outvmalloc: 1945 video_device_release(meye.video_dev); 1946outnotdev: 1947 return ret; 1948} 1949 1950static void __devexit meye_remove(struct pci_dev *pcidev) 1951{ 1952 video_unregister_device(meye.video_dev); 1953 1954 mchip_hic_stop(); 1955 1956 mchip_dma_free(); 1957 1958 /* disable interrupts */ 1959 mchip_set(MCHIP_MM_INTA, 0x0); 1960 1961 free_irq(meye.mchip_irq, meye_irq); 1962 1963 iounmap(meye.mchip_mmregs); 1964 1965 release_mem_region(pci_resource_start(meye.mchip_dev, 0), 1966 pci_resource_len(meye.mchip_dev, 0)); 1967 1968 pci_disable_device(meye.mchip_dev); 1969 1970 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0); 1971 1972 kfifo_free(meye.doneq); 1973 kfifo_free(meye.grabq); 1974 1975 vfree(meye.grab_temp); 1976 1977 if (meye.grab_fbuffer) { 1978 rvfree(meye.grab_fbuffer, gbuffers*gbufsize); 1979 meye.grab_fbuffer = NULL; 1980 } 1981 1982 printk(KERN_INFO "meye: removed\n"); 1983} 1984 1985static struct pci_device_id meye_pci_tbl[] = { 1986 { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002, 1987 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 1988 { } 1989}; 1990 1991MODULE_DEVICE_TABLE(pci, meye_pci_tbl); 1992 1993static struct pci_driver meye_driver = { 1994 .name = "meye", 1995 .id_table = meye_pci_tbl, 1996 .probe = meye_probe, 1997 .remove = __devexit_p(meye_remove), 1998#ifdef CONFIG_PM 1999 .suspend = meye_suspend, 2000 .resume = meye_resume, 2001#endif 2002}; 2003 2004static int __init meye_init(void) 2005{ 2006 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS)); 2007 if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE) 2008 gbufsize = MEYE_MAX_BUFSIZE; 2009 gbufsize = PAGE_ALIGN(gbufsize); 2010 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total)" 2011 "for capture\n", 2012 gbuffers, 2013 gbufsize / 1024, gbuffers * gbufsize / 1024); 2014 return pci_register_driver(&meye_driver); 2015} 2016 2017static void __exit meye_exit(void) 2018{ 2019 pci_unregister_driver(&meye_driver); 2020} 2021 2022module_init(meye_init); 2023module_exit(meye_exit); 2024