1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Zoran zr36057/zr36067 PCI controller driver, for the 4 * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux 5 * Media Labs LML33/LML33R10. 6 * 7 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx> 8 * 9 * Changes for BUZ by Wolfgang Scherr <scherr@net4you.net> 10 * 11 * Changes for DC10/DC30 by Laurent Pinchart <laurent.pinchart@skynet.be> 12 * 13 * Changes for LML33R10 by Maxim Yevtyushkin <max@linuxmedialabs.com> 14 * 15 * Changes for videodev2/v4l2 by Ronald Bultje <rbultje@ronald.bitfreak.net> 16 * 17 * Based on 18 * 19 * Miro DC10 driver 20 * Copyright (C) 1999 Wolfgang Scherr <scherr@net4you.net> 21 * 22 * Iomega Buz driver version 1.0 23 * Copyright (C) 1999 Rainer Johanni <Rainer@Johanni.de> 24 * 25 * buz.0.0.3 26 * Copyright (C) 1998 Dave Perks <dperks@ibm.net> 27 * 28 * bttv - Bt848 frame grabber driver 29 * Copyright (C) 1996,97,98 Ralph Metzler (rjkm@thp.uni-koeln.de) 30 * & Marcus Metzler (mocm@thp.uni-koeln.de) 31 */ 32 33 #include <linux/init.h> 34 #include <linux/module.h> 35 #include <linux/delay.h> 36 #include <linux/slab.h> 37 #include <linux/pci.h> 38 #include <linux/wait.h> 39 40 #include <linux/interrupt.h> 41 #include <linux/i2c.h> 42 #include <linux/i2c-algo-bit.h> 43 44 #include <linux/spinlock.h> 45 46 #include <linux/videodev2.h> 47 #include <media/v4l2-common.h> 48 #include <media/v4l2-ioctl.h> 49 #include <media/v4l2-event.h> 50 #include "videocodec.h" 51 52 #include <linux/io.h> 53 #include <linux/uaccess.h> 54 55 #include <linux/mutex.h> 56 #include "zoran.h" 57 #include "zoran_device.h" 58 #include "zoran_card.h" 59 60 const struct zoran_format zoran_formats[] = { 61 { 62 .name = "15-bit RGB LE", 63 .fourcc = V4L2_PIX_FMT_RGB555, 64 .colorspace = V4L2_COLORSPACE_SRGB, 65 .depth = 15, 66 .flags = ZORAN_FORMAT_CAPTURE, 67 .vfespfr = ZR36057_VFESPFR_RGB555 | ZR36057_VFESPFR_ERR_DIF | 68 ZR36057_VFESPFR_LITTLE_ENDIAN, 69 }, { 70 .name = "15-bit RGB BE", 71 .fourcc = V4L2_PIX_FMT_RGB555X, 72 .colorspace = V4L2_COLORSPACE_SRGB, 73 .depth = 15, 74 .flags = ZORAN_FORMAT_CAPTURE, 75 .vfespfr = ZR36057_VFESPFR_RGB555 | ZR36057_VFESPFR_ERR_DIF, 76 }, { 77 .name = "16-bit RGB LE", 78 .fourcc = V4L2_PIX_FMT_RGB565, 79 .colorspace = V4L2_COLORSPACE_SRGB, 80 .depth = 16, 81 .flags = ZORAN_FORMAT_CAPTURE, 82 .vfespfr = ZR36057_VFESPFR_RGB565 | ZR36057_VFESPFR_ERR_DIF | 83 ZR36057_VFESPFR_LITTLE_ENDIAN, 84 }, { 85 .name = "16-bit RGB BE", 86 .fourcc = V4L2_PIX_FMT_RGB565X, 87 .colorspace = V4L2_COLORSPACE_SRGB, 88 .depth = 16, 89 .flags = ZORAN_FORMAT_CAPTURE, 90 .vfespfr = ZR36057_VFESPFR_RGB565 | ZR36057_VFESPFR_ERR_DIF, 91 }, { 92 .name = "24-bit RGB", 93 .fourcc = V4L2_PIX_FMT_BGR24, 94 .colorspace = V4L2_COLORSPACE_SRGB, 95 .depth = 24, 96 .flags = ZORAN_FORMAT_CAPTURE, 97 .vfespfr = ZR36057_VFESPFR_RGB888 | ZR36057_VFESPFR_PACK24, 98 }, { 99 .name = "32-bit RGB LE", 100 .fourcc = V4L2_PIX_FMT_BGR32, 101 .colorspace = V4L2_COLORSPACE_SRGB, 102 .depth = 32, 103 .flags = ZORAN_FORMAT_CAPTURE, 104 .vfespfr = ZR36057_VFESPFR_RGB888 | ZR36057_VFESPFR_LITTLE_ENDIAN, 105 }, { 106 .name = "32-bit RGB BE", 107 .fourcc = V4L2_PIX_FMT_RGB32, 108 .colorspace = V4L2_COLORSPACE_SRGB, 109 .depth = 32, 110 .flags = ZORAN_FORMAT_CAPTURE, 111 .vfespfr = ZR36057_VFESPFR_RGB888, 112 }, { 113 .name = "4:2:2, packed, YUYV", 114 .fourcc = V4L2_PIX_FMT_YUYV, 115 .colorspace = V4L2_COLORSPACE_SMPTE170M, 116 .depth = 16, 117 .flags = ZORAN_FORMAT_CAPTURE, 118 .vfespfr = ZR36057_VFESPFR_YUV422, 119 }, { 120 .name = "4:2:2, packed, UYVY", 121 .fourcc = V4L2_PIX_FMT_UYVY, 122 .colorspace = V4L2_COLORSPACE_SMPTE170M, 123 .depth = 16, 124 .flags = ZORAN_FORMAT_CAPTURE, 125 .vfespfr = ZR36057_VFESPFR_YUV422 | ZR36057_VFESPFR_LITTLE_ENDIAN, 126 }, { 127 .name = "Hardware-encoded Motion-JPEG", 128 .fourcc = V4L2_PIX_FMT_MJPEG, 129 .colorspace = V4L2_COLORSPACE_SMPTE170M, 130 .depth = 0, 131 .flags = ZORAN_FORMAT_CAPTURE | 132 ZORAN_FORMAT_PLAYBACK | 133 ZORAN_FORMAT_COMPRESSED, 134 } 135 }; 136 137 #define NUM_FORMATS ARRAY_SIZE(zoran_formats) 138 139 /* 140 * small helper function for calculating buffersizes for v4l2 141 * we calculate the nearest higher power-of-two, which 142 * will be the recommended buffersize 143 */ 144 static __u32 zoran_v4l2_calc_bufsize(struct zoran_jpg_settings *settings) 145 { 146 __u8 div = settings->ver_dcm * settings->hor_dcm * settings->tmp_dcm; 147 __u32 num = (1024 * 512) / (div); 148 __u32 result = 2; 149 150 num--; 151 while (num) { 152 num >>= 1; 153 result <<= 1; 154 } 155 156 if (result < 8192) 157 return 8192; 158 159 return result; 160 } 161 162 /* 163 * V4L Buffer grabbing 164 */ 165 static int zoran_v4l_set_format(struct zoran *zr, int width, int height, 166 const struct zoran_format *format) 167 { 168 int bpp; 169 170 /* Check size and format of the grab wanted */ 171 172 if (height < BUZ_MIN_HEIGHT || width < BUZ_MIN_WIDTH || 173 height > BUZ_MAX_HEIGHT || width > BUZ_MAX_WIDTH) { 174 pci_dbg(zr->pci_dev, "%s - wrong frame size (%dx%d)\n", __func__, width, height); 175 return -EINVAL; 176 } 177 178 bpp = (format->depth + 7) / 8; 179 180 zr->buffer_size = height * width * bpp; 181 182 /* Check against available buffer size */ 183 if (height * width * bpp > zr->buffer_size) { 184 pci_dbg(zr->pci_dev, "%s - video buffer size (%d kB) is too small\n", 185 __func__, zr->buffer_size >> 10); 186 return -EINVAL; 187 } 188 189 /* The video front end needs 4-byte alinged line sizes */ 190 191 if ((bpp == 2 && (width & 1)) || (bpp == 3 && (width & 3))) { 192 pci_dbg(zr->pci_dev, "%s - wrong frame alignment\n", __func__); 193 return -EINVAL; 194 } 195 196 zr->v4l_settings.width = width; 197 zr->v4l_settings.height = height; 198 zr->v4l_settings.format = format; 199 zr->v4l_settings.bytesperline = bpp * zr->v4l_settings.width; 200 201 return 0; 202 } 203 204 static int zoran_set_norm(struct zoran *zr, v4l2_std_id norm) 205 { 206 if (!(norm & zr->card.norms)) { 207 pci_dbg(zr->pci_dev, "%s - unsupported norm %llx\n", __func__, norm); 208 return -EINVAL; 209 } 210 211 if (norm & V4L2_STD_SECAM) 212 zr->timing = zr->card.tvn[ZR_NORM_SECAM]; 213 else if (norm & V4L2_STD_NTSC) 214 zr->timing = zr->card.tvn[ZR_NORM_NTSC]; 215 else 216 zr->timing = zr->card.tvn[ZR_NORM_PAL]; 217 218 decoder_call(zr, video, s_std, norm); 219 encoder_call(zr, video, s_std_output, norm); 220 221 /* Make sure the changes come into effect */ 222 zr->norm = norm; 223 224 return 0; 225 } 226 227 static int zoran_set_input(struct zoran *zr, int input) 228 { 229 if (input == zr->input) 230 return 0; 231 232 if (input < 0 || input >= zr->card.inputs) { 233 pci_dbg(zr->pci_dev, "%s - unsupported input %d\n", __func__, input); 234 return -EINVAL; 235 } 236 237 zr->input = input; 238 239 decoder_call(zr, video, s_routing, zr->card.input[input].muxsel, 0, 0); 240 241 return 0; 242 } 243 244 /* 245 * ioctl routine 246 */ 247 248 static int zoran_querycap(struct file *file, void *__fh, struct v4l2_capability *cap) 249 { 250 struct zoran *zr = video_drvdata(file); 251 252 strscpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card)); 253 strscpy(cap->driver, "zoran", sizeof(cap->driver)); 254 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s", pci_name(zr->pci_dev)); 255 return 0; 256 } 257 258 static int zoran_enum_fmt(struct zoran *zr, struct v4l2_fmtdesc *fmt, int flag) 259 { 260 unsigned int num, i; 261 262 if (fmt->index >= ARRAY_SIZE(zoran_formats)) 263 return -EINVAL; 264 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 265 return -EINVAL; 266 267 for (num = i = 0; i < NUM_FORMATS; i++) { 268 if (zoran_formats[i].flags & flag && num++ == fmt->index) { 269 strscpy(fmt->description, zoran_formats[i].name, 270 sizeof(fmt->description)); 271 /* fmt struct pre-zeroed, so adding '\0' not needed */ 272 fmt->pixelformat = zoran_formats[i].fourcc; 273 if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED) 274 fmt->flags |= V4L2_FMT_FLAG_COMPRESSED; 275 return 0; 276 } 277 } 278 return -EINVAL; 279 } 280 281 static int zoran_enum_fmt_vid_cap(struct file *file, void *__fh, 282 struct v4l2_fmtdesc *f) 283 { 284 struct zoran *zr = video_drvdata(file); 285 286 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_CAPTURE); 287 } 288 289 static int zoran_g_fmt_vid_out(struct file *file, void *__fh, 290 struct v4l2_format *fmt) 291 { 292 struct zoran *zr = video_drvdata(file); 293 294 fmt->fmt.pix.width = zr->jpg_settings.img_width / zr->jpg_settings.hor_dcm; 295 fmt->fmt.pix.height = zr->jpg_settings.img_height * 2 / 296 (zr->jpg_settings.ver_dcm * zr->jpg_settings.tmp_dcm); 297 fmt->fmt.pix.sizeimage = zr->buffer_size; 298 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG; 299 if (zr->jpg_settings.tmp_dcm == 1) 300 fmt->fmt.pix.field = (zr->jpg_settings.odd_even ? 301 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT); 302 else 303 fmt->fmt.pix.field = (zr->jpg_settings.odd_even ? 304 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM); 305 fmt->fmt.pix.bytesperline = 0; 306 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 307 308 return 0; 309 } 310 311 static int zoran_g_fmt_vid_cap(struct file *file, void *__fh, 312 struct v4l2_format *fmt) 313 { 314 struct zoran *zr = video_drvdata(file); 315 316 if (zr->map_mode != ZORAN_MAP_MODE_RAW) 317 return zoran_g_fmt_vid_out(file, __fh, fmt); 318 fmt->fmt.pix.width = zr->v4l_settings.width; 319 fmt->fmt.pix.height = zr->v4l_settings.height; 320 fmt->fmt.pix.sizeimage = zr->buffer_size; 321 fmt->fmt.pix.pixelformat = zr->v4l_settings.format->fourcc; 322 fmt->fmt.pix.colorspace = zr->v4l_settings.format->colorspace; 323 fmt->fmt.pix.bytesperline = zr->v4l_settings.bytesperline; 324 if (BUZ_MAX_HEIGHT < (zr->v4l_settings.height * 2)) 325 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED; 326 else 327 fmt->fmt.pix.field = V4L2_FIELD_TOP; 328 return 0; 329 } 330 331 static int zoran_try_fmt_vid_out(struct file *file, void *__fh, 332 struct v4l2_format *fmt) 333 { 334 struct zoran *zr = video_drvdata(file); 335 struct zoran_jpg_settings settings; 336 int res = 0; 337 338 if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG) 339 return -EINVAL; 340 341 settings = zr->jpg_settings; 342 343 /* we actually need to set 'real' parameters now */ 344 if ((fmt->fmt.pix.height * 2) > BUZ_MAX_HEIGHT) 345 settings.tmp_dcm = 1; 346 else 347 settings.tmp_dcm = 2; 348 settings.decimation = 0; 349 if (fmt->fmt.pix.height <= zr->jpg_settings.img_height / 2) 350 settings.ver_dcm = 2; 351 else 352 settings.ver_dcm = 1; 353 if (fmt->fmt.pix.width <= zr->jpg_settings.img_width / 4) 354 settings.hor_dcm = 4; 355 else if (fmt->fmt.pix.width <= zr->jpg_settings.img_width / 2) 356 settings.hor_dcm = 2; 357 else 358 settings.hor_dcm = 1; 359 if (settings.tmp_dcm == 1) 360 settings.field_per_buff = 2; 361 else 362 settings.field_per_buff = 1; 363 364 if (settings.hor_dcm > 1) { 365 settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; 366 settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; 367 } else { 368 settings.img_x = 0; 369 settings.img_width = BUZ_MAX_WIDTH; 370 } 371 372 /* check */ 373 res = zoran_check_jpg_settings(zr, &settings, 1); 374 if (res) 375 return res; 376 377 /* tell the user what we actually did */ 378 fmt->fmt.pix.width = settings.img_width / settings.hor_dcm; 379 fmt->fmt.pix.height = settings.img_height * 2 / 380 (settings.tmp_dcm * settings.ver_dcm); 381 if (settings.tmp_dcm == 1) 382 fmt->fmt.pix.field = (zr->jpg_settings.odd_even ? 383 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT); 384 else 385 fmt->fmt.pix.field = (zr->jpg_settings.odd_even ? 386 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM); 387 388 fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&settings); 389 fmt->fmt.pix.bytesperline = 0; 390 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 391 return res; 392 } 393 394 static int zoran_try_fmt_vid_cap(struct file *file, void *__fh, 395 struct v4l2_format *fmt) 396 { 397 struct zoran *zr = video_drvdata(file); 398 int bpp; 399 int i; 400 401 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) 402 return zoran_try_fmt_vid_out(file, __fh, fmt); 403 404 for (i = 0; i < NUM_FORMATS; i++) 405 if (zoran_formats[i].fourcc == fmt->fmt.pix.pixelformat) 406 break; 407 408 if (i == NUM_FORMATS) { 409 /* TODO do not return here to fix the TRY_FMT cannot handle an invalid pixelformat*/ 410 return -EINVAL; 411 } 412 413 fmt->fmt.pix.pixelformat = zoran_formats[i].fourcc; 414 fmt->fmt.pix.colorspace = zoran_formats[i].colorspace; 415 if (BUZ_MAX_HEIGHT < (fmt->fmt.pix.height * 2)) 416 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED; 417 else 418 fmt->fmt.pix.field = V4L2_FIELD_TOP; 419 420 bpp = DIV_ROUND_UP(zoran_formats[i].depth, 8); 421 v4l_bound_align_image(&fmt->fmt.pix.width, BUZ_MIN_WIDTH, BUZ_MAX_WIDTH, 422 bpp == 2 ? 1 : 2, 423 &fmt->fmt.pix.height, BUZ_MIN_HEIGHT, BUZ_MAX_HEIGHT, 424 0, 0); 425 fmt->fmt.pix.bytesperline = fmt->fmt.pix.width * bpp; 426 fmt->fmt.pix.sizeimage = fmt->fmt.pix.bytesperline * fmt->fmt.pix.height; 427 return 0; 428 } 429 430 static int zoran_s_fmt_vid_out(struct file *file, void *__fh, 431 struct v4l2_format *fmt) 432 { 433 struct zoran *zr = video_drvdata(file); 434 __le32 printformat = __cpu_to_le32(fmt->fmt.pix.pixelformat); 435 struct zoran_jpg_settings settings; 436 int res = 0; 437 438 pci_dbg(zr->pci_dev, "size=%dx%d, fmt=0x%x (%4.4s)\n", 439 fmt->fmt.pix.width, fmt->fmt.pix.height, 440 fmt->fmt.pix.pixelformat, 441 (char *)&printformat); 442 if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG) 443 return -EINVAL; 444 445 if (!fmt->fmt.pix.height || !fmt->fmt.pix.width) 446 return -EINVAL; 447 448 settings = zr->jpg_settings; 449 450 /* we actually need to set 'real' parameters now */ 451 if (fmt->fmt.pix.height * 2 > BUZ_MAX_HEIGHT) 452 settings.tmp_dcm = 1; 453 else 454 settings.tmp_dcm = 2; 455 settings.decimation = 0; 456 if (fmt->fmt.pix.height <= zr->jpg_settings.img_height / 2) 457 settings.ver_dcm = 2; 458 else 459 settings.ver_dcm = 1; 460 if (fmt->fmt.pix.width <= zr->jpg_settings.img_width / 4) 461 settings.hor_dcm = 4; 462 else if (fmt->fmt.pix.width <= zr->jpg_settings.img_width / 2) 463 settings.hor_dcm = 2; 464 else 465 settings.hor_dcm = 1; 466 if (settings.tmp_dcm == 1) 467 settings.field_per_buff = 2; 468 else 469 settings.field_per_buff = 1; 470 471 if (settings.hor_dcm > 1) { 472 settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; 473 settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; 474 } else { 475 settings.img_x = 0; 476 settings.img_width = BUZ_MAX_WIDTH; 477 } 478 479 /* check */ 480 res = zoran_check_jpg_settings(zr, &settings, 0); 481 if (res) 482 return res; 483 484 /* it's ok, so set them */ 485 zr->jpg_settings = settings; 486 487 if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 488 zr->map_mode = ZORAN_MAP_MODE_JPG_REC; 489 else 490 zr->map_mode = ZORAN_MAP_MODE_JPG_PLAY; 491 492 zr->buffer_size = zoran_v4l2_calc_bufsize(&zr->jpg_settings); 493 494 /* tell the user what we actually did */ 495 fmt->fmt.pix.width = settings.img_width / settings.hor_dcm; 496 fmt->fmt.pix.height = settings.img_height * 2 / 497 (settings.tmp_dcm * settings.ver_dcm); 498 if (settings.tmp_dcm == 1) 499 fmt->fmt.pix.field = (zr->jpg_settings.odd_even ? 500 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT); 501 else 502 fmt->fmt.pix.field = (zr->jpg_settings.odd_even ? 503 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM); 504 fmt->fmt.pix.bytesperline = 0; 505 fmt->fmt.pix.sizeimage = zr->buffer_size; 506 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 507 return res; 508 } 509 510 static int zoran_s_fmt_vid_cap(struct file *file, void *__fh, 511 struct v4l2_format *fmt) 512 { 513 struct zoran *zr = video_drvdata(file); 514 struct zoran_fh *fh = __fh; 515 int i; 516 int res = 0; 517 518 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) 519 return zoran_s_fmt_vid_out(file, fh, fmt); 520 521 for (i = 0; i < NUM_FORMATS; i++) 522 if (fmt->fmt.pix.pixelformat == zoran_formats[i].fourcc) 523 break; 524 if (i == NUM_FORMATS) { 525 pci_dbg(zr->pci_dev, "VIDIOC_S_FMT - unknown/unsupported format 0x%x\n", 526 fmt->fmt.pix.pixelformat); 527 /* TODO do not return here to fix the TRY_FMT cannot handle an invalid pixelformat*/ 528 return -EINVAL; 529 } 530 531 fmt->fmt.pix.pixelformat = zoran_formats[i].fourcc; 532 if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT) 533 fmt->fmt.pix.height = BUZ_MAX_HEIGHT; 534 if (fmt->fmt.pix.width > BUZ_MAX_WIDTH) 535 fmt->fmt.pix.width = BUZ_MAX_WIDTH; 536 if (fmt->fmt.pix.height < BUZ_MIN_HEIGHT) 537 fmt->fmt.pix.height = BUZ_MIN_HEIGHT; 538 if (fmt->fmt.pix.width < BUZ_MIN_WIDTH) 539 fmt->fmt.pix.width = BUZ_MIN_WIDTH; 540 541 zr->map_mode = ZORAN_MAP_MODE_RAW; 542 543 res = zoran_v4l_set_format(zr, fmt->fmt.pix.width, fmt->fmt.pix.height, 544 &zoran_formats[i]); 545 if (res) 546 return res; 547 548 /* tell the user the results/missing stuff */ 549 fmt->fmt.pix.bytesperline = zr->v4l_settings.bytesperline; 550 fmt->fmt.pix.sizeimage = zr->buffer_size; 551 fmt->fmt.pix.colorspace = zr->v4l_settings.format->colorspace; 552 if (BUZ_MAX_HEIGHT < (zr->v4l_settings.height * 2)) 553 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED; 554 else 555 fmt->fmt.pix.field = V4L2_FIELD_TOP; 556 return res; 557 } 558 559 static int zoran_g_std(struct file *file, void *__fh, v4l2_std_id *std) 560 { 561 struct zoran *zr = video_drvdata(file); 562 563 *std = zr->norm; 564 return 0; 565 } 566 567 static int zoran_s_std(struct file *file, void *__fh, v4l2_std_id std) 568 { 569 struct zoran *zr = video_drvdata(file); 570 int res = 0; 571 572 if (zr->norm == std) 573 return 0; 574 575 if (zr->running != ZORAN_MAP_MODE_NONE) 576 return -EBUSY; 577 578 res = zoran_set_norm(zr, std); 579 return res; 580 } 581 582 static int zoran_enum_input(struct file *file, void *__fh, 583 struct v4l2_input *inp) 584 { 585 struct zoran *zr = video_drvdata(file); 586 587 if (inp->index >= zr->card.inputs) 588 return -EINVAL; 589 590 strscpy(inp->name, zr->card.input[inp->index].name, sizeof(inp->name)); 591 inp->type = V4L2_INPUT_TYPE_CAMERA; 592 inp->std = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM; 593 594 /* Get status of video decoder */ 595 decoder_call(zr, video, g_input_status, &inp->status); 596 return 0; 597 } 598 599 static int zoran_g_input(struct file *file, void *__fh, unsigned int *input) 600 { 601 struct zoran *zr = video_drvdata(file); 602 603 *input = zr->input; 604 605 return 0; 606 } 607 608 static int zoran_s_input(struct file *file, void *__fh, unsigned int input) 609 { 610 struct zoran *zr = video_drvdata(file); 611 int res; 612 613 if (zr->running != ZORAN_MAP_MODE_NONE) 614 return -EBUSY; 615 616 res = zoran_set_input(zr, input); 617 return res; 618 } 619 620 /* cropping (sub-frame capture) */ 621 static int zoran_g_selection(struct file *file, void *__fh, struct v4l2_selection *sel) 622 { 623 struct zoran *zr = video_drvdata(file); 624 625 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 626 sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 627 pci_dbg(zr->pci_dev, "%s invalid selection type combination\n", __func__); 628 return -EINVAL; 629 } 630 631 switch (sel->target) { 632 case V4L2_SEL_TGT_CROP: 633 sel->r.top = zr->jpg_settings.img_y; 634 sel->r.left = zr->jpg_settings.img_x; 635 sel->r.width = zr->jpg_settings.img_width; 636 sel->r.height = zr->jpg_settings.img_height; 637 break; 638 case V4L2_SEL_TGT_CROP_DEFAULT: 639 sel->r.top = 0; 640 sel->r.left = 0; 641 sel->r.width = BUZ_MIN_WIDTH; 642 sel->r.height = BUZ_MIN_HEIGHT; 643 break; 644 case V4L2_SEL_TGT_CROP_BOUNDS: 645 sel->r.top = 0; 646 sel->r.left = 0; 647 sel->r.width = BUZ_MAX_WIDTH; 648 sel->r.height = BUZ_MAX_HEIGHT; 649 break; 650 default: 651 return -EINVAL; 652 } 653 return 0; 654 } 655 656 static int zoran_s_selection(struct file *file, void *__fh, struct v4l2_selection *sel) 657 { 658 struct zoran *zr = video_drvdata(file); 659 struct zoran_jpg_settings settings; 660 int res; 661 662 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 663 sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 664 return -EINVAL; 665 666 if (!sel->r.width || !sel->r.height) 667 return -EINVAL; 668 669 if (sel->target != V4L2_SEL_TGT_CROP) 670 return -EINVAL; 671 672 if (zr->map_mode == ZORAN_MAP_MODE_RAW) { 673 pci_dbg(zr->pci_dev, "VIDIOC_S_SELECTION - subcapture only supported for compressed capture\n"); 674 return -EINVAL; 675 } 676 677 settings = zr->jpg_settings; 678 679 /* move into a form that we understand */ 680 settings.img_x = sel->r.left; 681 settings.img_y = sel->r.top; 682 settings.img_width = sel->r.width; 683 settings.img_height = sel->r.height; 684 685 /* check validity */ 686 res = zoran_check_jpg_settings(zr, &settings, 0); 687 if (res) 688 return res; 689 690 /* accept */ 691 zr->jpg_settings = settings; 692 return res; 693 } 694 695 /* 696 * Output is disabled temporarily 697 * Zoran is picky about jpeg data it accepts. At least it seems to unsupport COM and APPn. 698 * So until a way to filter data will be done, disable output. 699 */ 700 static const struct v4l2_ioctl_ops zoran_ioctl_ops = { 701 .vidioc_querycap = zoran_querycap, 702 .vidioc_s_selection = zoran_s_selection, 703 .vidioc_g_selection = zoran_g_selection, 704 .vidioc_enum_input = zoran_enum_input, 705 .vidioc_g_input = zoran_g_input, 706 .vidioc_s_input = zoran_s_input, 707 .vidioc_g_std = zoran_g_std, 708 .vidioc_s_std = zoran_s_std, 709 .vidioc_create_bufs = vb2_ioctl_create_bufs, 710 .vidioc_reqbufs = vb2_ioctl_reqbufs, 711 .vidioc_querybuf = vb2_ioctl_querybuf, 712 .vidioc_qbuf = vb2_ioctl_qbuf, 713 .vidioc_dqbuf = vb2_ioctl_dqbuf, 714 .vidioc_expbuf = vb2_ioctl_expbuf, 715 .vidioc_streamon = vb2_ioctl_streamon, 716 .vidioc_streamoff = vb2_ioctl_streamoff, 717 .vidioc_enum_fmt_vid_cap = zoran_enum_fmt_vid_cap, 718 .vidioc_g_fmt_vid_cap = zoran_g_fmt_vid_cap, 719 .vidioc_s_fmt_vid_cap = zoran_s_fmt_vid_cap, 720 .vidioc_try_fmt_vid_cap = zoran_try_fmt_vid_cap, 721 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 722 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 723 }; 724 725 static const struct v4l2_file_operations zoran_fops = { 726 .owner = THIS_MODULE, 727 .unlocked_ioctl = video_ioctl2, 728 .open = v4l2_fh_open, 729 .release = vb2_fop_release, 730 .mmap = vb2_fop_mmap, 731 .poll = vb2_fop_poll, 732 }; 733 734 const struct video_device zoran_template = { 735 .name = ZORAN_NAME, 736 .fops = &zoran_fops, 737 .ioctl_ops = &zoran_ioctl_ops, 738 .release = &zoran_vdev_release, 739 .tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM, 740 }; 741 742 static int zr_vb2_queue_setup(struct vb2_queue *vq, unsigned int *nbuffers, unsigned int *nplanes, 743 unsigned int sizes[], struct device *alloc_devs[]) 744 { 745 struct zoran *zr = vb2_get_drv_priv(vq); 746 unsigned int size = zr->buffer_size; 747 748 pci_dbg(zr->pci_dev, "%s nbuf=%u nplanes=%u", __func__, *nbuffers, *nplanes); 749 750 zr->buf_in_reserve = 0; 751 752 if (*nbuffers < vq->min_queued_buffers) 753 *nbuffers = vq->min_queued_buffers; 754 755 if (*nplanes) { 756 if (sizes[0] < size) 757 return -EINVAL; 758 else 759 return 0; 760 } 761 762 *nplanes = 1; 763 sizes[0] = size; 764 765 return 0; 766 } 767 768 static void zr_vb2_queue(struct vb2_buffer *vb) 769 { 770 struct zoran *zr = vb2_get_drv_priv(vb->vb2_queue); 771 struct zr_buffer *buf = vb2_to_zr_buffer(vb); 772 unsigned long flags; 773 774 spin_lock_irqsave(&zr->queued_bufs_lock, flags); 775 list_add_tail(&buf->queue, &zr->queued_bufs); 776 zr->buf_in_reserve++; 777 spin_unlock_irqrestore(&zr->queued_bufs_lock, flags); 778 if (zr->running == ZORAN_MAP_MODE_JPG_REC) 779 zoran_feed_stat_com(zr); 780 zr->queued++; 781 } 782 783 static int zr_vb2_prepare(struct vb2_buffer *vb) 784 { 785 struct zoran *zr = vb2_get_drv_priv(vb->vb2_queue); 786 787 if (vb2_plane_size(vb, 0) < zr->buffer_size) 788 return -EINVAL; 789 zr->prepared++; 790 791 return 0; 792 } 793 794 int zr_set_buf(struct zoran *zr) 795 { 796 struct zr_buffer *buf; 797 struct vb2_v4l2_buffer *vbuf; 798 dma_addr_t phys_addr; 799 unsigned long flags; 800 u32 reg; 801 802 if (zr->running == ZORAN_MAP_MODE_NONE) 803 return 0; 804 805 if (zr->inuse[0]) { 806 buf = zr->inuse[0]; 807 buf->vbuf.vb2_buf.timestamp = ktime_get_ns(); 808 buf->vbuf.sequence = zr->vbseq++; 809 vbuf = &buf->vbuf; 810 811 buf->vbuf.field = V4L2_FIELD_INTERLACED; 812 if (BUZ_MAX_HEIGHT < (zr->v4l_settings.height * 2)) 813 buf->vbuf.field = V4L2_FIELD_INTERLACED; 814 else 815 buf->vbuf.field = V4L2_FIELD_TOP; 816 vb2_set_plane_payload(&buf->vbuf.vb2_buf, 0, zr->buffer_size); 817 vb2_buffer_done(&buf->vbuf.vb2_buf, VB2_BUF_STATE_DONE); 818 zr->inuse[0] = NULL; 819 } 820 821 spin_lock_irqsave(&zr->queued_bufs_lock, flags); 822 if (list_empty(&zr->queued_bufs)) { 823 btand(~ZR36057_ICR_INT_PIN_EN, ZR36057_ICR); 824 vb2_queue_error(zr->video_dev->queue); 825 spin_unlock_irqrestore(&zr->queued_bufs_lock, flags); 826 return -EINVAL; 827 } 828 buf = list_first_entry_or_null(&zr->queued_bufs, struct zr_buffer, queue); 829 if (!buf) { 830 btand(~ZR36057_ICR_INT_PIN_EN, ZR36057_ICR); 831 vb2_queue_error(zr->video_dev->queue); 832 spin_unlock_irqrestore(&zr->queued_bufs_lock, flags); 833 return -EINVAL; 834 } 835 list_del(&buf->queue); 836 zr->buf_in_reserve--; 837 spin_unlock_irqrestore(&zr->queued_bufs_lock, flags); 838 839 vbuf = &buf->vbuf; 840 vbuf->vb2_buf.state = VB2_BUF_STATE_ACTIVE; 841 phys_addr = vb2_dma_contig_plane_dma_addr(&vbuf->vb2_buf, 0); 842 843 if (!phys_addr) 844 return -EINVAL; 845 846 zr->inuse[0] = buf; 847 848 reg = phys_addr; 849 btwrite(reg, ZR36057_VDTR); 850 if (zr->v4l_settings.height > BUZ_MAX_HEIGHT / 2) 851 reg += zr->v4l_settings.bytesperline; 852 btwrite(reg, ZR36057_VDBR); 853 854 reg = 0; 855 if (zr->v4l_settings.height > BUZ_MAX_HEIGHT / 2) 856 reg += zr->v4l_settings.bytesperline; 857 reg = (reg << ZR36057_VSSFGR_DISP_STRIDE); 858 reg |= ZR36057_VSSFGR_VID_OVF; 859 reg |= ZR36057_VSSFGR_SNAP_SHOT; 860 reg |= ZR36057_VSSFGR_FRAME_GRAB; 861 btwrite(reg, ZR36057_VSSFGR); 862 863 btor(ZR36057_VDCR_VID_EN, ZR36057_VDCR); 864 return 0; 865 } 866 867 static int zr_vb2_start_streaming(struct vb2_queue *vq, unsigned int count) 868 { 869 struct zoran *zr = vq->drv_priv; 870 int j; 871 872 for (j = 0; j < BUZ_NUM_STAT_COM; j++) { 873 zr->stat_com[j] = cpu_to_le32(1); 874 zr->inuse[j] = NULL; 875 } 876 zr->vbseq = 0; 877 878 if (zr->map_mode != ZORAN_MAP_MODE_RAW) { 879 pci_dbg(zr->pci_dev, "START JPG\n"); 880 zr36057_restart(zr); 881 zoran_init_hardware(zr); 882 if (zr->map_mode == ZORAN_MAP_MODE_JPG_REC) 883 zr36057_enable_jpg(zr, BUZ_MODE_MOTION_DECOMPRESS); 884 else 885 zr36057_enable_jpg(zr, BUZ_MODE_MOTION_COMPRESS); 886 zoran_feed_stat_com(zr); 887 jpeg_start(zr); 888 zr->running = zr->map_mode; 889 btor(ZR36057_ICR_INT_PIN_EN, ZR36057_ICR); 890 return 0; 891 } 892 893 pci_dbg(zr->pci_dev, "START RAW\n"); 894 zr36057_restart(zr); 895 zoran_init_hardware(zr); 896 897 zr36057_enable_jpg(zr, BUZ_MODE_IDLE); 898 zr36057_set_memgrab(zr, 1); 899 zr->running = zr->map_mode; 900 btor(ZR36057_ICR_INT_PIN_EN, ZR36057_ICR); 901 return 0; 902 } 903 904 static void zr_vb2_stop_streaming(struct vb2_queue *vq) 905 { 906 struct zoran *zr = vq->drv_priv; 907 struct zr_buffer *buf; 908 unsigned long flags; 909 int j; 910 911 btand(~ZR36057_ICR_INT_PIN_EN, ZR36057_ICR); 912 if (zr->map_mode != ZORAN_MAP_MODE_RAW) 913 zr36057_enable_jpg(zr, BUZ_MODE_IDLE); 914 zr36057_set_memgrab(zr, 0); 915 zr->running = ZORAN_MAP_MODE_NONE; 916 917 zoran_set_pci_master(zr, 0); 918 919 if (!pass_through) { /* Switch to color bar */ 920 decoder_call(zr, video, s_stream, 0); 921 encoder_call(zr, video, s_routing, 2, 0, 0); 922 } 923 924 for (j = 0; j < BUZ_NUM_STAT_COM; j++) { 925 zr->stat_com[j] = cpu_to_le32(1); 926 if (!zr->inuse[j]) 927 continue; 928 buf = zr->inuse[j]; 929 pci_dbg(zr->pci_dev, "%s clean buf %d\n", __func__, j); 930 vb2_buffer_done(&buf->vbuf.vb2_buf, VB2_BUF_STATE_ERROR); 931 zr->inuse[j] = NULL; 932 } 933 934 spin_lock_irqsave(&zr->queued_bufs_lock, flags); 935 while (!list_empty(&zr->queued_bufs)) { 936 buf = list_entry(zr->queued_bufs.next, struct zr_buffer, queue); 937 list_del(&buf->queue); 938 vb2_buffer_done(&buf->vbuf.vb2_buf, VB2_BUF_STATE_ERROR); 939 zr->buf_in_reserve--; 940 } 941 spin_unlock_irqrestore(&zr->queued_bufs_lock, flags); 942 if (zr->buf_in_reserve) 943 pci_dbg(zr->pci_dev, "Buffer remaining %d\n", zr->buf_in_reserve); 944 zr->map_mode = ZORAN_MAP_MODE_RAW; 945 } 946 947 static const struct vb2_ops zr_video_qops = { 948 .queue_setup = zr_vb2_queue_setup, 949 .buf_queue = zr_vb2_queue, 950 .buf_prepare = zr_vb2_prepare, 951 .start_streaming = zr_vb2_start_streaming, 952 .stop_streaming = zr_vb2_stop_streaming, 953 .wait_prepare = vb2_ops_wait_prepare, 954 .wait_finish = vb2_ops_wait_finish, 955 }; 956 957 int zoran_queue_init(struct zoran *zr, struct vb2_queue *vq, int dir) 958 { 959 int err; 960 961 spin_lock_init(&zr->queued_bufs_lock); 962 INIT_LIST_HEAD(&zr->queued_bufs); 963 964 vq->dev = &zr->pci_dev->dev; 965 vq->type = dir; 966 967 vq->io_modes = VB2_DMABUF | VB2_MMAP; 968 vq->drv_priv = zr; 969 vq->buf_struct_size = sizeof(struct zr_buffer); 970 vq->ops = &zr_video_qops; 971 vq->mem_ops = &vb2_dma_contig_memops; 972 vq->gfp_flags = GFP_DMA32; 973 vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 974 vq->min_queued_buffers = 9; 975 vq->lock = &zr->lock; 976 err = vb2_queue_init(vq); 977 if (err) 978 return err; 979 zr->video_dev->queue = vq; 980 return 0; 981 } 982 983 void zoran_queue_exit(struct zoran *zr) 984 { 985 vb2_queue_release(zr->video_dev->queue); 986 } 987