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