1 /* 2 * Support for a cx23416 mpeg encoder via cx2388x host port. 3 * "blackbird" reference design. 4 * 5 * (c) 2004 Jelle Foks <jelle@foks.us> 6 * (c) 2004 Gerd Knorr <kraxel@bytesex.org> 7 * 8 * (c) 2005-2006 Mauro Carvalho Chehab <mchehab@kernel.org> 9 * - video_ioctl2 conversion 10 * 11 * Includes parts from the ivtv driver <http://sourceforge.net/projects/ivtv/> 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or 16 * (at your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 */ 23 24 #include "cx88.h" 25 26 #include <linux/module.h> 27 #include <linux/init.h> 28 #include <linux/slab.h> 29 #include <linux/fs.h> 30 #include <linux/delay.h> 31 #include <linux/device.h> 32 #include <linux/firmware.h> 33 #include <media/v4l2-common.h> 34 #include <media/v4l2-ioctl.h> 35 #include <media/v4l2-event.h> 36 #include <media/drv-intf/cx2341x.h> 37 38 MODULE_DESCRIPTION("driver for cx2388x/cx23416 based mpeg encoder cards"); 39 MODULE_AUTHOR("Jelle Foks <jelle@foks.us>, Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]"); 40 MODULE_LICENSE("GPL"); 41 MODULE_VERSION(CX88_VERSION); 42 43 static unsigned int debug; 44 module_param(debug, int, 0644); 45 MODULE_PARM_DESC(debug, "enable debug messages [blackbird]"); 46 47 #define dprintk(level, fmt, arg...) do { \ 48 if (debug + 1 > level) \ 49 printk(KERN_DEBUG pr_fmt("%s: blackbird:" fmt), \ 50 __func__, ##arg); \ 51 } while (0) 52 53 /* ------------------------------------------------------------------ */ 54 55 #define BLACKBIRD_FIRM_IMAGE_SIZE 376836 56 57 /* defines below are from ivtv-driver.h */ 58 59 #define IVTV_CMD_HW_BLOCKS_RST 0xFFFFFFFF 60 61 /* Firmware API commands */ 62 #define IVTV_API_STD_TIMEOUT 500 63 64 enum blackbird_capture_type { 65 BLACKBIRD_MPEG_CAPTURE, 66 BLACKBIRD_RAW_CAPTURE, 67 BLACKBIRD_RAW_PASSTHRU_CAPTURE 68 }; 69 70 enum blackbird_capture_bits { 71 BLACKBIRD_RAW_BITS_NONE = 0x00, 72 BLACKBIRD_RAW_BITS_YUV_CAPTURE = 0x01, 73 BLACKBIRD_RAW_BITS_PCM_CAPTURE = 0x02, 74 BLACKBIRD_RAW_BITS_VBI_CAPTURE = 0x04, 75 BLACKBIRD_RAW_BITS_PASSTHRU_CAPTURE = 0x08, 76 BLACKBIRD_RAW_BITS_TO_HOST_CAPTURE = 0x10 77 }; 78 79 enum blackbird_capture_end { 80 BLACKBIRD_END_AT_GOP, /* stop at the end of gop, generate irq */ 81 BLACKBIRD_END_NOW, /* stop immediately, no irq */ 82 }; 83 84 enum blackbird_framerate { 85 BLACKBIRD_FRAMERATE_NTSC_30, /* NTSC: 30fps */ 86 BLACKBIRD_FRAMERATE_PAL_25 /* PAL: 25fps */ 87 }; 88 89 enum blackbird_stream_port { 90 BLACKBIRD_OUTPUT_PORT_MEMORY, 91 BLACKBIRD_OUTPUT_PORT_STREAMING, 92 BLACKBIRD_OUTPUT_PORT_SERIAL 93 }; 94 95 enum blackbird_data_xfer_status { 96 BLACKBIRD_MORE_BUFFERS_FOLLOW, 97 BLACKBIRD_LAST_BUFFER, 98 }; 99 100 enum blackbird_picture_mask { 101 BLACKBIRD_PICTURE_MASK_NONE, 102 BLACKBIRD_PICTURE_MASK_I_FRAMES, 103 BLACKBIRD_PICTURE_MASK_I_P_FRAMES = 0x3, 104 BLACKBIRD_PICTURE_MASK_ALL_FRAMES = 0x7, 105 }; 106 107 enum blackbird_vbi_mode_bits { 108 BLACKBIRD_VBI_BITS_SLICED, 109 BLACKBIRD_VBI_BITS_RAW, 110 }; 111 112 enum blackbird_vbi_insertion_bits { 113 BLACKBIRD_VBI_BITS_INSERT_IN_XTENSION_USR_DATA, 114 BLACKBIRD_VBI_BITS_INSERT_IN_PRIVATE_PACKETS = 0x1 << 1, 115 BLACKBIRD_VBI_BITS_SEPARATE_STREAM = 0x2 << 1, 116 BLACKBIRD_VBI_BITS_SEPARATE_STREAM_USR_DATA = 0x4 << 1, 117 BLACKBIRD_VBI_BITS_SEPARATE_STREAM_PRV_DATA = 0x5 << 1, 118 }; 119 120 enum blackbird_dma_unit { 121 BLACKBIRD_DMA_BYTES, 122 BLACKBIRD_DMA_FRAMES, 123 }; 124 125 enum blackbird_dma_transfer_status_bits { 126 BLACKBIRD_DMA_TRANSFER_BITS_DONE = 0x01, 127 BLACKBIRD_DMA_TRANSFER_BITS_ERROR = 0x04, 128 BLACKBIRD_DMA_TRANSFER_BITS_LL_ERROR = 0x10, 129 }; 130 131 enum blackbird_pause { 132 BLACKBIRD_PAUSE_ENCODING, 133 BLACKBIRD_RESUME_ENCODING, 134 }; 135 136 enum blackbird_copyright { 137 BLACKBIRD_COPYRIGHT_OFF, 138 BLACKBIRD_COPYRIGHT_ON, 139 }; 140 141 enum blackbird_notification_type { 142 BLACKBIRD_NOTIFICATION_REFRESH, 143 }; 144 145 enum blackbird_notification_status { 146 BLACKBIRD_NOTIFICATION_OFF, 147 BLACKBIRD_NOTIFICATION_ON, 148 }; 149 150 enum blackbird_notification_mailbox { 151 BLACKBIRD_NOTIFICATION_NO_MAILBOX = -1, 152 }; 153 154 enum blackbird_field1_lines { 155 BLACKBIRD_FIELD1_SAA7114 = 0x00EF, /* 239 */ 156 BLACKBIRD_FIELD1_SAA7115 = 0x00F0, /* 240 */ 157 BLACKBIRD_FIELD1_MICRONAS = 0x0105, /* 261 */ 158 }; 159 160 enum blackbird_field2_lines { 161 BLACKBIRD_FIELD2_SAA7114 = 0x00EF, /* 239 */ 162 BLACKBIRD_FIELD2_SAA7115 = 0x00F0, /* 240 */ 163 BLACKBIRD_FIELD2_MICRONAS = 0x0106, /* 262 */ 164 }; 165 166 enum blackbird_custom_data_type { 167 BLACKBIRD_CUSTOM_EXTENSION_USR_DATA, 168 BLACKBIRD_CUSTOM_PRIVATE_PACKET, 169 }; 170 171 enum blackbird_mute { 172 BLACKBIRD_UNMUTE, 173 BLACKBIRD_MUTE, 174 }; 175 176 enum blackbird_mute_video_mask { 177 BLACKBIRD_MUTE_VIDEO_V_MASK = 0x0000FF00, 178 BLACKBIRD_MUTE_VIDEO_U_MASK = 0x00FF0000, 179 BLACKBIRD_MUTE_VIDEO_Y_MASK = 0xFF000000, 180 }; 181 182 enum blackbird_mute_video_shift { 183 BLACKBIRD_MUTE_VIDEO_V_SHIFT = 8, 184 BLACKBIRD_MUTE_VIDEO_U_SHIFT = 16, 185 BLACKBIRD_MUTE_VIDEO_Y_SHIFT = 24, 186 }; 187 188 /* Registers */ 189 #define IVTV_REG_ENC_SDRAM_REFRESH (0x07F8 /*| IVTV_REG_OFFSET*/) 190 #define IVTV_REG_ENC_SDRAM_PRECHARGE (0x07FC /*| IVTV_REG_OFFSET*/) 191 #define IVTV_REG_SPU (0x9050 /*| IVTV_REG_OFFSET*/) 192 #define IVTV_REG_HW_BLOCKS (0x9054 /*| IVTV_REG_OFFSET*/) 193 #define IVTV_REG_VPU (0x9058 /*| IVTV_REG_OFFSET*/) 194 #define IVTV_REG_APU (0xA064 /*| IVTV_REG_OFFSET*/) 195 196 /* ------------------------------------------------------------------ */ 197 198 static void host_setup(struct cx88_core *core) 199 { 200 /* toggle reset of the host */ 201 cx_write(MO_GPHST_SOFT_RST, 1); 202 udelay(100); 203 cx_write(MO_GPHST_SOFT_RST, 0); 204 udelay(100); 205 206 /* host port setup */ 207 cx_write(MO_GPHST_WSC, 0x44444444U); 208 cx_write(MO_GPHST_XFR, 0); 209 cx_write(MO_GPHST_WDTH, 15); 210 cx_write(MO_GPHST_HDSHK, 0); 211 cx_write(MO_GPHST_MUX16, 0x44448888U); 212 cx_write(MO_GPHST_MODE, 0); 213 } 214 215 /* ------------------------------------------------------------------ */ 216 217 #define P1_MDATA0 0x390000 218 #define P1_MDATA1 0x390001 219 #define P1_MDATA2 0x390002 220 #define P1_MDATA3 0x390003 221 #define P1_MADDR2 0x390004 222 #define P1_MADDR1 0x390005 223 #define P1_MADDR0 0x390006 224 #define P1_RDATA0 0x390008 225 #define P1_RDATA1 0x390009 226 #define P1_RDATA2 0x39000A 227 #define P1_RDATA3 0x39000B 228 #define P1_RADDR0 0x39000C 229 #define P1_RADDR1 0x39000D 230 #define P1_RRDWR 0x39000E 231 232 static int wait_ready_gpio0_bit1(struct cx88_core *core, u32 state) 233 { 234 unsigned long timeout = jiffies + msecs_to_jiffies(1); 235 u32 gpio0, need; 236 237 need = state ? 2 : 0; 238 for (;;) { 239 gpio0 = cx_read(MO_GP0_IO) & 2; 240 if (need == gpio0) 241 return 0; 242 if (time_after(jiffies, timeout)) 243 return -1; 244 udelay(1); 245 } 246 } 247 248 static int memory_write(struct cx88_core *core, u32 address, u32 value) 249 { 250 /* Warning: address is dword address (4 bytes) */ 251 cx_writeb(P1_MDATA0, (unsigned int)value); 252 cx_writeb(P1_MDATA1, (unsigned int)(value >> 8)); 253 cx_writeb(P1_MDATA2, (unsigned int)(value >> 16)); 254 cx_writeb(P1_MDATA3, (unsigned int)(value >> 24)); 255 cx_writeb(P1_MADDR2, (unsigned int)(address >> 16) | 0x40); 256 cx_writeb(P1_MADDR1, (unsigned int)(address >> 8)); 257 cx_writeb(P1_MADDR0, (unsigned int)address); 258 cx_read(P1_MDATA0); 259 cx_read(P1_MADDR0); 260 261 return wait_ready_gpio0_bit1(core, 1); 262 } 263 264 static int memory_read(struct cx88_core *core, u32 address, u32 *value) 265 { 266 int retval; 267 u32 val; 268 269 /* Warning: address is dword address (4 bytes) */ 270 cx_writeb(P1_MADDR2, (unsigned int)(address >> 16) & ~0xC0); 271 cx_writeb(P1_MADDR1, (unsigned int)(address >> 8)); 272 cx_writeb(P1_MADDR0, (unsigned int)address); 273 cx_read(P1_MADDR0); 274 275 retval = wait_ready_gpio0_bit1(core, 1); 276 277 cx_writeb(P1_MDATA3, 0); 278 val = (unsigned char)cx_read(P1_MDATA3) << 24; 279 cx_writeb(P1_MDATA2, 0); 280 val |= (unsigned char)cx_read(P1_MDATA2) << 16; 281 cx_writeb(P1_MDATA1, 0); 282 val |= (unsigned char)cx_read(P1_MDATA1) << 8; 283 cx_writeb(P1_MDATA0, 0); 284 val |= (unsigned char)cx_read(P1_MDATA0); 285 286 *value = val; 287 return retval; 288 } 289 290 static int register_write(struct cx88_core *core, u32 address, u32 value) 291 { 292 cx_writeb(P1_RDATA0, (unsigned int)value); 293 cx_writeb(P1_RDATA1, (unsigned int)(value >> 8)); 294 cx_writeb(P1_RDATA2, (unsigned int)(value >> 16)); 295 cx_writeb(P1_RDATA3, (unsigned int)(value >> 24)); 296 cx_writeb(P1_RADDR0, (unsigned int)address); 297 cx_writeb(P1_RADDR1, (unsigned int)(address >> 8)); 298 cx_writeb(P1_RRDWR, 1); 299 cx_read(P1_RDATA0); 300 cx_read(P1_RADDR0); 301 302 return wait_ready_gpio0_bit1(core, 1); 303 } 304 305 static int register_read(struct cx88_core *core, u32 address, u32 *value) 306 { 307 int retval; 308 u32 val; 309 310 cx_writeb(P1_RADDR0, (unsigned int)address); 311 cx_writeb(P1_RADDR1, (unsigned int)(address >> 8)); 312 cx_writeb(P1_RRDWR, 0); 313 cx_read(P1_RADDR0); 314 315 retval = wait_ready_gpio0_bit1(core, 1); 316 val = (unsigned char)cx_read(P1_RDATA0); 317 val |= (unsigned char)cx_read(P1_RDATA1) << 8; 318 val |= (unsigned char)cx_read(P1_RDATA2) << 16; 319 val |= (unsigned char)cx_read(P1_RDATA3) << 24; 320 321 *value = val; 322 return retval; 323 } 324 325 /* ------------------------------------------------------------------ */ 326 327 static int blackbird_mbox_func(void *priv, u32 command, int in, 328 int out, u32 data[CX2341X_MBOX_MAX_DATA]) 329 { 330 struct cx8802_dev *dev = priv; 331 unsigned long timeout; 332 u32 value, flag, retval; 333 int i; 334 335 dprintk(1, "%s: 0x%X\n", __func__, command); 336 337 /* 338 * this may not be 100% safe if we can't read any memory location 339 * without side effects 340 */ 341 memory_read(dev->core, dev->mailbox - 4, &value); 342 if (value != 0x12345678) { 343 dprintk(0, 344 "Firmware and/or mailbox pointer not initialized or corrupted\n"); 345 return -EIO; 346 } 347 348 memory_read(dev->core, dev->mailbox, &flag); 349 if (flag) { 350 dprintk(0, "ERROR: Mailbox appears to be in use (%x)\n", flag); 351 return -EIO; 352 } 353 354 flag |= 1; /* tell 'em we're working on it */ 355 memory_write(dev->core, dev->mailbox, flag); 356 357 /* write command + args + fill remaining with zeros */ 358 memory_write(dev->core, dev->mailbox + 1, command); /* command code */ 359 /* timeout */ 360 memory_write(dev->core, dev->mailbox + 3, IVTV_API_STD_TIMEOUT); 361 for (i = 0; i < in; i++) { 362 memory_write(dev->core, dev->mailbox + 4 + i, data[i]); 363 dprintk(1, "API Input %d = %d\n", i, data[i]); 364 } 365 for (; i < CX2341X_MBOX_MAX_DATA; i++) 366 memory_write(dev->core, dev->mailbox + 4 + i, 0); 367 368 flag |= 3; /* tell 'em we're done writing */ 369 memory_write(dev->core, dev->mailbox, flag); 370 371 /* wait for firmware to handle the API command */ 372 timeout = jiffies + msecs_to_jiffies(1000); 373 for (;;) { 374 memory_read(dev->core, dev->mailbox, &flag); 375 if (0 != (flag & 4)) 376 break; 377 if (time_after(jiffies, timeout)) { 378 dprintk(0, "ERROR: API Mailbox timeout %x\n", command); 379 return -EIO; 380 } 381 udelay(10); 382 } 383 384 /* read output values */ 385 for (i = 0; i < out; i++) { 386 memory_read(dev->core, dev->mailbox + 4 + i, data + i); 387 dprintk(1, "API Output %d = %d\n", i, data[i]); 388 } 389 390 memory_read(dev->core, dev->mailbox + 2, &retval); 391 dprintk(1, "API result = %d\n", retval); 392 393 flag = 0; 394 memory_write(dev->core, dev->mailbox, flag); 395 return retval; 396 } 397 398 /* ------------------------------------------------------------------ */ 399 400 /* 401 * We don't need to call the API often, so using just one mailbox 402 * will probably suffice 403 */ 404 static int blackbird_api_cmd(struct cx8802_dev *dev, u32 command, 405 u32 inputcnt, u32 outputcnt, ...) 406 { 407 u32 data[CX2341X_MBOX_MAX_DATA]; 408 va_list vargs; 409 int i, err; 410 411 va_start(vargs, outputcnt); 412 413 for (i = 0; i < inputcnt; i++) 414 data[i] = va_arg(vargs, int); 415 416 err = blackbird_mbox_func(dev, command, inputcnt, outputcnt, data); 417 for (i = 0; i < outputcnt; i++) { 418 int *vptr = va_arg(vargs, int *); 419 *vptr = data[i]; 420 } 421 va_end(vargs); 422 return err; 423 } 424 425 static int blackbird_find_mailbox(struct cx8802_dev *dev) 426 { 427 u32 signature[4] = {0x12345678, 0x34567812, 0x56781234, 0x78123456}; 428 int signaturecnt = 0; 429 u32 value; 430 int i; 431 432 for (i = 0; i < BLACKBIRD_FIRM_IMAGE_SIZE; i++) { 433 memory_read(dev->core, i, &value); 434 if (value == signature[signaturecnt]) 435 signaturecnt++; 436 else 437 signaturecnt = 0; 438 if (signaturecnt == 4) { 439 dprintk(1, "Mailbox signature found\n"); 440 return i + 1; 441 } 442 } 443 dprintk(0, "Mailbox signature values not found!\n"); 444 return -EIO; 445 } 446 447 static int blackbird_load_firmware(struct cx8802_dev *dev) 448 { 449 static const unsigned char magic[8] = { 450 0xa7, 0x0d, 0x00, 0x00, 0x66, 0xbb, 0x55, 0xaa 451 }; 452 const struct firmware *firmware; 453 int i, retval = 0; 454 u32 value = 0; 455 u32 checksum = 0; 456 __le32 *dataptr; 457 458 retval = register_write(dev->core, IVTV_REG_VPU, 0xFFFFFFED); 459 retval |= register_write(dev->core, IVTV_REG_HW_BLOCKS, 460 IVTV_CMD_HW_BLOCKS_RST); 461 retval |= register_write(dev->core, IVTV_REG_ENC_SDRAM_REFRESH, 462 0x80000640); 463 retval |= register_write(dev->core, IVTV_REG_ENC_SDRAM_PRECHARGE, 464 0x1A); 465 usleep_range(10000, 20000); 466 retval |= register_write(dev->core, IVTV_REG_APU, 0); 467 468 if (retval < 0) 469 dprintk(0, "Error with register_write\n"); 470 471 retval = request_firmware(&firmware, CX2341X_FIRM_ENC_FILENAME, 472 &dev->pci->dev); 473 474 if (retval != 0) { 475 pr_err("Hotplug firmware request failed (%s).\n", 476 CX2341X_FIRM_ENC_FILENAME); 477 pr_err("Please fix your hotplug setup, the board will not work without firmware loaded!\n"); 478 return -EIO; 479 } 480 481 if (firmware->size != BLACKBIRD_FIRM_IMAGE_SIZE) { 482 pr_err("Firmware size mismatch (have %zd, expected %d)\n", 483 firmware->size, BLACKBIRD_FIRM_IMAGE_SIZE); 484 release_firmware(firmware); 485 return -EINVAL; 486 } 487 488 if (memcmp(firmware->data, magic, 8) != 0) { 489 pr_err("Firmware magic mismatch, wrong file?\n"); 490 release_firmware(firmware); 491 return -EINVAL; 492 } 493 494 /* transfer to the chip */ 495 dprintk(1, "Loading firmware ...\n"); 496 dataptr = (__le32 *)firmware->data; 497 for (i = 0; i < (firmware->size >> 2); i++) { 498 value = le32_to_cpu(*dataptr); 499 checksum += ~value; 500 memory_write(dev->core, i, value); 501 dataptr++; 502 } 503 504 /* read back to verify with the checksum */ 505 for (i--; i >= 0; i--) { 506 memory_read(dev->core, i, &value); 507 checksum -= ~value; 508 } 509 release_firmware(firmware); 510 if (checksum) { 511 pr_err("Firmware load might have failed (checksum mismatch).\n"); 512 return -EIO; 513 } 514 dprintk(0, "Firmware upload successful.\n"); 515 516 retval |= register_write(dev->core, IVTV_REG_HW_BLOCKS, 517 IVTV_CMD_HW_BLOCKS_RST); 518 retval |= register_read(dev->core, IVTV_REG_SPU, &value); 519 retval |= register_write(dev->core, IVTV_REG_SPU, value & 0xFFFFFFFE); 520 usleep_range(10000, 20000); 521 522 retval |= register_read(dev->core, IVTV_REG_VPU, &value); 523 retval |= register_write(dev->core, IVTV_REG_VPU, value & 0xFFFFFFE8); 524 525 if (retval < 0) 526 dprintk(0, "Error with register_write\n"); 527 return 0; 528 } 529 530 /* 531 * Settings used by the windows tv app for PVR2000: 532 * ================================================================================================================= 533 * Profile | Codec | Resolution | CBR/VBR | Video Qlty | V. Bitrate | Frmrate | Audio Codec | A. Bitrate | A. Mode 534 * ----------------------------------------------------------------------------------------------------------------- 535 * MPEG-1 | MPEG1 | 352x288PAL | (CBR) | 1000:Optimal | 2000 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo 536 * MPEG-2 | MPEG2 | 720x576PAL | VBR | 600 :Good | 4000 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo 537 * VCD | MPEG1 | 352x288PAL | (CBR) | 1000:Optimal | 1150 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo 538 * DVD | MPEG2 | 720x576PAL | VBR | 600 :Good | 6000 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo 539 * DB* DVD | MPEG2 | 720x576PAL | CBR | 600 :Good | 6000 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo 540 * ================================================================================================================= 541 * [*] DB: "DirectBurn" 542 */ 543 544 static void blackbird_codec_settings(struct cx8802_dev *dev) 545 { 546 struct cx88_core *core = dev->core; 547 548 /* assign frame size */ 549 blackbird_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0, 550 core->height, core->width); 551 552 dev->cxhdl.width = core->width; 553 dev->cxhdl.height = core->height; 554 cx2341x_handler_set_50hz(&dev->cxhdl, 555 dev->core->tvnorm & V4L2_STD_625_50); 556 cx2341x_handler_setup(&dev->cxhdl); 557 } 558 559 static int blackbird_initialize_codec(struct cx8802_dev *dev) 560 { 561 struct cx88_core *core = dev->core; 562 int version; 563 int retval; 564 565 dprintk(1, "Initialize codec\n"); 566 retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */ 567 if (retval < 0) { 568 /* ping was not successful, reset and upload firmware */ 569 cx_write(MO_SRST_IO, 0); /* SYS_RSTO=0 */ 570 cx_write(MO_SRST_IO, 1); /* SYS_RSTO=1 */ 571 retval = blackbird_load_firmware(dev); 572 if (retval < 0) 573 return retval; 574 575 retval = blackbird_find_mailbox(dev); 576 if (retval < 0) 577 return -1; 578 579 dev->mailbox = retval; 580 581 /* ping */ 582 retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); 583 if (retval < 0) { 584 dprintk(0, "ERROR: Firmware ping failed!\n"); 585 return -1; 586 } 587 588 retval = blackbird_api_cmd(dev, CX2341X_ENC_GET_VERSION, 589 0, 1, &version); 590 if (retval < 0) { 591 dprintk(0, 592 "ERROR: Firmware get encoder version failed!\n"); 593 return -1; 594 } 595 dprintk(0, "Firmware version is 0x%08x\n", version); 596 } 597 598 cx_write(MO_PINMUX_IO, 0x88); /* 656-8bit IO and enable MPEG parallel IO */ 599 cx_clear(MO_INPUT_FORMAT, 0x100); /* chroma subcarrier lock to normal? */ 600 cx_write(MO_VBOS_CONTROL, 0x84A00); /* no 656 mode, 8-bit pixels, disable VBI */ 601 cx_clear(MO_OUTPUT_FORMAT, 0x0008); /* Normal Y-limits to let the mpeg encoder sync */ 602 603 blackbird_codec_settings(dev); 604 605 blackbird_api_cmd(dev, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, 0, 606 BLACKBIRD_FIELD1_SAA7115, BLACKBIRD_FIELD2_SAA7115); 607 608 blackbird_api_cmd(dev, CX2341X_ENC_SET_PLACEHOLDER, 12, 0, 609 BLACKBIRD_CUSTOM_EXTENSION_USR_DATA, 610 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); 611 612 return 0; 613 } 614 615 static int blackbird_start_codec(struct cx8802_dev *dev) 616 { 617 struct cx88_core *core = dev->core; 618 /* start capturing to the host interface */ 619 u32 reg; 620 621 int i; 622 int lastchange = -1; 623 int lastval = 0; 624 625 for (i = 0; (i < 10) && (i < (lastchange + 4)); i++) { 626 reg = cx_read(AUD_STATUS); 627 628 dprintk(1, "AUD_STATUS:%dL: 0x%x\n", i, reg); 629 if ((reg & 0x0F) != lastval) { 630 lastval = reg & 0x0F; 631 lastchange = i; 632 } 633 msleep(100); 634 } 635 636 /* unmute audio source */ 637 cx_clear(AUD_VOL_CTL, (1 << 6)); 638 639 blackbird_api_cmd(dev, CX2341X_ENC_REFRESH_INPUT, 0, 0); 640 641 /* initialize the video input */ 642 blackbird_api_cmd(dev, CX2341X_ENC_INITIALIZE_INPUT, 0, 0); 643 644 cx2341x_handler_set_busy(&dev->cxhdl, 1); 645 646 /* start capturing to the host interface */ 647 blackbird_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0, 648 BLACKBIRD_MPEG_CAPTURE, BLACKBIRD_RAW_BITS_NONE); 649 650 return 0; 651 } 652 653 static int blackbird_stop_codec(struct cx8802_dev *dev) 654 { 655 blackbird_api_cmd(dev, CX2341X_ENC_STOP_CAPTURE, 3, 0, 656 BLACKBIRD_END_NOW, 657 BLACKBIRD_MPEG_CAPTURE, 658 BLACKBIRD_RAW_BITS_NONE); 659 660 cx2341x_handler_set_busy(&dev->cxhdl, 0); 661 662 return 0; 663 } 664 665 /* ------------------------------------------------------------------ */ 666 667 static int queue_setup(struct vb2_queue *q, 668 unsigned int *num_buffers, unsigned int *num_planes, 669 unsigned int sizes[], struct device *alloc_devs[]) 670 { 671 struct cx8802_dev *dev = q->drv_priv; 672 673 *num_planes = 1; 674 dev->ts_packet_size = 188 * 4; 675 dev->ts_packet_count = 32; 676 sizes[0] = dev->ts_packet_size * dev->ts_packet_count; 677 return 0; 678 } 679 680 static int buffer_prepare(struct vb2_buffer *vb) 681 { 682 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 683 struct cx8802_dev *dev = vb->vb2_queue->drv_priv; 684 struct cx88_buffer *buf = container_of(vbuf, struct cx88_buffer, vb); 685 686 return cx8802_buf_prepare(vb->vb2_queue, dev, buf); 687 } 688 689 static void buffer_finish(struct vb2_buffer *vb) 690 { 691 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 692 struct cx8802_dev *dev = vb->vb2_queue->drv_priv; 693 struct cx88_buffer *buf = container_of(vbuf, struct cx88_buffer, vb); 694 struct cx88_riscmem *risc = &buf->risc; 695 696 if (risc->cpu) 697 pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma); 698 memset(risc, 0, sizeof(*risc)); 699 } 700 701 static void buffer_queue(struct vb2_buffer *vb) 702 { 703 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 704 struct cx8802_dev *dev = vb->vb2_queue->drv_priv; 705 struct cx88_buffer *buf = container_of(vbuf, struct cx88_buffer, vb); 706 707 cx8802_buf_queue(dev, buf); 708 } 709 710 static int start_streaming(struct vb2_queue *q, unsigned int count) 711 { 712 struct cx8802_dev *dev = q->drv_priv; 713 struct cx88_dmaqueue *dmaq = &dev->mpegq; 714 struct cx8802_driver *drv; 715 struct cx88_buffer *buf; 716 unsigned long flags; 717 int err; 718 719 /* Make sure we can acquire the hardware */ 720 drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD); 721 if (!drv) { 722 dprintk(1, "%s: blackbird driver is not loaded\n", __func__); 723 err = -ENODEV; 724 goto fail; 725 } 726 727 err = drv->request_acquire(drv); 728 if (err != 0) { 729 dprintk(1, "%s: Unable to acquire hardware, %d\n", __func__, 730 err); 731 goto fail; 732 } 733 734 if (blackbird_initialize_codec(dev) < 0) { 735 drv->request_release(drv); 736 err = -EINVAL; 737 goto fail; 738 } 739 740 err = blackbird_start_codec(dev); 741 if (err == 0) { 742 buf = list_entry(dmaq->active.next, struct cx88_buffer, list); 743 cx8802_start_dma(dev, dmaq, buf); 744 return 0; 745 } 746 747 fail: 748 spin_lock_irqsave(&dev->slock, flags); 749 while (!list_empty(&dmaq->active)) { 750 struct cx88_buffer *buf = list_entry(dmaq->active.next, 751 struct cx88_buffer, list); 752 753 list_del(&buf->list); 754 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_QUEUED); 755 } 756 spin_unlock_irqrestore(&dev->slock, flags); 757 return err; 758 } 759 760 static void stop_streaming(struct vb2_queue *q) 761 { 762 struct cx8802_dev *dev = q->drv_priv; 763 struct cx88_dmaqueue *dmaq = &dev->mpegq; 764 struct cx8802_driver *drv = NULL; 765 unsigned long flags; 766 767 cx8802_cancel_buffers(dev); 768 blackbird_stop_codec(dev); 769 770 /* Make sure we release the hardware */ 771 drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD); 772 WARN_ON(!drv); 773 if (drv) 774 drv->request_release(drv); 775 776 spin_lock_irqsave(&dev->slock, flags); 777 while (!list_empty(&dmaq->active)) { 778 struct cx88_buffer *buf = list_entry(dmaq->active.next, 779 struct cx88_buffer, list); 780 781 list_del(&buf->list); 782 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 783 } 784 spin_unlock_irqrestore(&dev->slock, flags); 785 } 786 787 static const struct vb2_ops blackbird_qops = { 788 .queue_setup = queue_setup, 789 .buf_prepare = buffer_prepare, 790 .buf_finish = buffer_finish, 791 .buf_queue = buffer_queue, 792 .wait_prepare = vb2_ops_wait_prepare, 793 .wait_finish = vb2_ops_wait_finish, 794 .start_streaming = start_streaming, 795 .stop_streaming = stop_streaming, 796 }; 797 798 /* ------------------------------------------------------------------ */ 799 800 static int vidioc_querycap(struct file *file, void *priv, 801 struct v4l2_capability *cap) 802 { 803 struct cx8802_dev *dev = video_drvdata(file); 804 struct cx88_core *core = dev->core; 805 806 strcpy(cap->driver, "cx88_blackbird"); 807 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci)); 808 return cx88_querycap(file, core, cap); 809 } 810 811 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 812 struct v4l2_fmtdesc *f) 813 { 814 if (f->index != 0) 815 return -EINVAL; 816 817 strlcpy(f->description, "MPEG", sizeof(f->description)); 818 f->pixelformat = V4L2_PIX_FMT_MPEG; 819 f->flags = V4L2_FMT_FLAG_COMPRESSED; 820 return 0; 821 } 822 823 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, 824 struct v4l2_format *f) 825 { 826 struct cx8802_dev *dev = video_drvdata(file); 827 struct cx88_core *core = dev->core; 828 829 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 830 f->fmt.pix.bytesperline = 0; 831 f->fmt.pix.sizeimage = dev->ts_packet_size * dev->ts_packet_count; 832 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 833 f->fmt.pix.width = core->width; 834 f->fmt.pix.height = core->height; 835 f->fmt.pix.field = core->field; 836 return 0; 837 } 838 839 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, 840 struct v4l2_format *f) 841 { 842 struct cx8802_dev *dev = video_drvdata(file); 843 struct cx88_core *core = dev->core; 844 unsigned int maxw, maxh; 845 enum v4l2_field field; 846 847 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 848 f->fmt.pix.bytesperline = 0; 849 f->fmt.pix.sizeimage = dev->ts_packet_size * dev->ts_packet_count; 850 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 851 852 maxw = norm_maxw(core->tvnorm); 853 maxh = norm_maxh(core->tvnorm); 854 855 field = f->fmt.pix.field; 856 857 switch (field) { 858 case V4L2_FIELD_TOP: 859 case V4L2_FIELD_BOTTOM: 860 case V4L2_FIELD_INTERLACED: 861 case V4L2_FIELD_SEQ_BT: 862 case V4L2_FIELD_SEQ_TB: 863 break; 864 default: 865 field = (f->fmt.pix.height > maxh / 2) 866 ? V4L2_FIELD_INTERLACED 867 : V4L2_FIELD_BOTTOM; 868 break; 869 } 870 if (V4L2_FIELD_HAS_T_OR_B(field)) 871 maxh /= 2; 872 873 v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2, 874 &f->fmt.pix.height, 32, maxh, 0, 0); 875 f->fmt.pix.field = field; 876 return 0; 877 } 878 879 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 880 struct v4l2_format *f) 881 { 882 struct cx8802_dev *dev = video_drvdata(file); 883 struct cx88_core *core = dev->core; 884 885 if (vb2_is_busy(&dev->vb2_mpegq)) 886 return -EBUSY; 887 if (core->v4ldev && (vb2_is_busy(&core->v4ldev->vb2_vidq) || 888 vb2_is_busy(&core->v4ldev->vb2_vbiq))) 889 return -EBUSY; 890 vidioc_try_fmt_vid_cap(file, priv, f); 891 core->width = f->fmt.pix.width; 892 core->height = f->fmt.pix.height; 893 core->field = f->fmt.pix.field; 894 cx88_set_scale(core, f->fmt.pix.width, f->fmt.pix.height, 895 f->fmt.pix.field); 896 blackbird_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0, 897 f->fmt.pix.height, f->fmt.pix.width); 898 return 0; 899 } 900 901 static int vidioc_s_frequency(struct file *file, void *priv, 902 const struct v4l2_frequency *f) 903 { 904 struct cx8802_dev *dev = video_drvdata(file); 905 struct cx88_core *core = dev->core; 906 bool streaming; 907 908 if (unlikely(core->board.tuner_type == UNSET)) 909 return -EINVAL; 910 if (unlikely(f->tuner != 0)) 911 return -EINVAL; 912 streaming = vb2_start_streaming_called(&dev->vb2_mpegq); 913 if (streaming) 914 blackbird_stop_codec(dev); 915 916 cx88_set_freq(core, f); 917 blackbird_initialize_codec(dev); 918 cx88_set_scale(core, core->width, core->height, core->field); 919 if (streaming) 920 blackbird_start_codec(dev); 921 return 0; 922 } 923 924 static int vidioc_log_status(struct file *file, void *priv) 925 { 926 struct cx8802_dev *dev = video_drvdata(file); 927 struct cx88_core *core = dev->core; 928 char name[32 + 2]; 929 930 snprintf(name, sizeof(name), "%s/2", core->name); 931 call_all(core, core, log_status); 932 v4l2_ctrl_handler_log_status(&dev->cxhdl.hdl, name); 933 return 0; 934 } 935 936 static int vidioc_enum_input(struct file *file, void *priv, 937 struct v4l2_input *i) 938 { 939 struct cx8802_dev *dev = video_drvdata(file); 940 struct cx88_core *core = dev->core; 941 942 return cx88_enum_input(core, i); 943 } 944 945 static int vidioc_g_frequency(struct file *file, void *priv, 946 struct v4l2_frequency *f) 947 { 948 struct cx8802_dev *dev = video_drvdata(file); 949 struct cx88_core *core = dev->core; 950 951 if (unlikely(core->board.tuner_type == UNSET)) 952 return -EINVAL; 953 if (unlikely(f->tuner != 0)) 954 return -EINVAL; 955 956 f->frequency = core->freq; 957 call_all(core, tuner, g_frequency, f); 958 959 return 0; 960 } 961 962 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 963 { 964 struct cx8802_dev *dev = video_drvdata(file); 965 struct cx88_core *core = dev->core; 966 967 *i = core->input; 968 return 0; 969 } 970 971 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 972 { 973 struct cx8802_dev *dev = video_drvdata(file); 974 struct cx88_core *core = dev->core; 975 976 if (i >= 4) 977 return -EINVAL; 978 if (!INPUT(i).type) 979 return -EINVAL; 980 981 cx88_newstation(core); 982 cx88_video_mux(core, i); 983 return 0; 984 } 985 986 static int vidioc_g_tuner(struct file *file, void *priv, 987 struct v4l2_tuner *t) 988 { 989 struct cx8802_dev *dev = video_drvdata(file); 990 struct cx88_core *core = dev->core; 991 u32 reg; 992 993 if (unlikely(core->board.tuner_type == UNSET)) 994 return -EINVAL; 995 if (t->index != 0) 996 return -EINVAL; 997 998 strcpy(t->name, "Television"); 999 t->capability = V4L2_TUNER_CAP_NORM; 1000 t->rangehigh = 0xffffffffUL; 1001 call_all(core, tuner, g_tuner, t); 1002 1003 cx88_get_stereo(core, t); 1004 reg = cx_read(MO_DEVICE_STATUS); 1005 t->signal = (reg & (1 << 5)) ? 0xffff : 0x0000; 1006 return 0; 1007 } 1008 1009 static int vidioc_s_tuner(struct file *file, void *priv, 1010 const struct v4l2_tuner *t) 1011 { 1012 struct cx8802_dev *dev = video_drvdata(file); 1013 struct cx88_core *core = dev->core; 1014 1015 if (core->board.tuner_type == UNSET) 1016 return -EINVAL; 1017 if (t->index != 0) 1018 return -EINVAL; 1019 1020 cx88_set_stereo(core, t->audmode, 1); 1021 return 0; 1022 } 1023 1024 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorm) 1025 { 1026 struct cx8802_dev *dev = video_drvdata(file); 1027 struct cx88_core *core = dev->core; 1028 1029 *tvnorm = core->tvnorm; 1030 return 0; 1031 } 1032 1033 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id) 1034 { 1035 struct cx8802_dev *dev = video_drvdata(file); 1036 struct cx88_core *core = dev->core; 1037 1038 return cx88_set_tvnorm(core, id); 1039 } 1040 1041 static const struct v4l2_file_operations mpeg_fops = { 1042 .owner = THIS_MODULE, 1043 .open = v4l2_fh_open, 1044 .release = vb2_fop_release, 1045 .read = vb2_fop_read, 1046 .poll = vb2_fop_poll, 1047 .mmap = vb2_fop_mmap, 1048 .unlocked_ioctl = video_ioctl2, 1049 }; 1050 1051 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = { 1052 .vidioc_querycap = vidioc_querycap, 1053 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 1054 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 1055 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 1056 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 1057 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1058 .vidioc_querybuf = vb2_ioctl_querybuf, 1059 .vidioc_qbuf = vb2_ioctl_qbuf, 1060 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1061 .vidioc_streamon = vb2_ioctl_streamon, 1062 .vidioc_streamoff = vb2_ioctl_streamoff, 1063 .vidioc_s_frequency = vidioc_s_frequency, 1064 .vidioc_log_status = vidioc_log_status, 1065 .vidioc_enum_input = vidioc_enum_input, 1066 .vidioc_g_frequency = vidioc_g_frequency, 1067 .vidioc_g_input = vidioc_g_input, 1068 .vidioc_s_input = vidioc_s_input, 1069 .vidioc_g_tuner = vidioc_g_tuner, 1070 .vidioc_s_tuner = vidioc_s_tuner, 1071 .vidioc_g_std = vidioc_g_std, 1072 .vidioc_s_std = vidioc_s_std, 1073 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 1074 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1075 }; 1076 1077 static const struct video_device cx8802_mpeg_template = { 1078 .name = "cx8802", 1079 .fops = &mpeg_fops, 1080 .ioctl_ops = &mpeg_ioctl_ops, 1081 .tvnorms = CX88_NORMS, 1082 }; 1083 1084 /* ------------------------------------------------------------------ */ 1085 1086 /* The CX8802 MPEG API will call this when we can use the hardware */ 1087 static int cx8802_blackbird_advise_acquire(struct cx8802_driver *drv) 1088 { 1089 struct cx88_core *core = drv->core; 1090 int err = 0; 1091 1092 switch (core->boardnr) { 1093 case CX88_BOARD_HAUPPAUGE_HVR1300: 1094 /* 1095 * By default, core setup will leave the cx22702 out of reset, 1096 * on the bus. 1097 * We left the hardware on power up with the cx22702 active. 1098 * We're being given access to re-arrange the GPIOs. 1099 * Take the bus off the cx22702 and put the cx23416 on it. 1100 */ 1101 /* Toggle reset on cx22702 leaving i2c active */ 1102 cx_set(MO_GP0_IO, 0x00000080); 1103 udelay(1000); 1104 cx_clear(MO_GP0_IO, 0x00000080); 1105 udelay(50); 1106 cx_set(MO_GP0_IO, 0x00000080); 1107 udelay(1000); 1108 /* tri-state the cx22702 pins */ 1109 cx_set(MO_GP0_IO, 0x00000004); 1110 udelay(1000); 1111 break; 1112 default: 1113 err = -ENODEV; 1114 } 1115 return err; 1116 } 1117 1118 /* The CX8802 MPEG API will call this when we need to release the hardware */ 1119 static int cx8802_blackbird_advise_release(struct cx8802_driver *drv) 1120 { 1121 struct cx88_core *core = drv->core; 1122 int err = 0; 1123 1124 switch (core->boardnr) { 1125 case CX88_BOARD_HAUPPAUGE_HVR1300: 1126 /* Exit leaving the cx23416 on the bus */ 1127 break; 1128 default: 1129 err = -ENODEV; 1130 } 1131 return err; 1132 } 1133 1134 static void blackbird_unregister_video(struct cx8802_dev *dev) 1135 { 1136 video_unregister_device(&dev->mpeg_dev); 1137 } 1138 1139 static int blackbird_register_video(struct cx8802_dev *dev) 1140 { 1141 int err; 1142 1143 cx88_vdev_init(dev->core, dev->pci, &dev->mpeg_dev, 1144 &cx8802_mpeg_template, "mpeg"); 1145 dev->mpeg_dev.ctrl_handler = &dev->cxhdl.hdl; 1146 video_set_drvdata(&dev->mpeg_dev, dev); 1147 dev->mpeg_dev.queue = &dev->vb2_mpegq; 1148 err = video_register_device(&dev->mpeg_dev, VFL_TYPE_GRABBER, -1); 1149 if (err < 0) { 1150 pr_info("can't register mpeg device\n"); 1151 return err; 1152 } 1153 pr_info("registered device %s [mpeg]\n", 1154 video_device_node_name(&dev->mpeg_dev)); 1155 return 0; 1156 } 1157 1158 /* ----------------------------------------------------------- */ 1159 1160 static int cx8802_blackbird_probe(struct cx8802_driver *drv) 1161 { 1162 struct cx88_core *core = drv->core; 1163 struct cx8802_dev *dev = core->dvbdev; 1164 struct vb2_queue *q; 1165 int err; 1166 1167 dprintk(1, "%s\n", __func__); 1168 dprintk(1, " ->being probed by Card=%d Name=%s, PCI %02x:%02x\n", 1169 core->boardnr, 1170 core->name, 1171 core->pci_bus, 1172 core->pci_slot); 1173 1174 err = -ENODEV; 1175 if (!(core->board.mpeg & CX88_MPEG_BLACKBIRD)) 1176 goto fail_core; 1177 1178 dev->cxhdl.port = CX2341X_PORT_STREAMING; 1179 dev->cxhdl.width = core->width; 1180 dev->cxhdl.height = core->height; 1181 dev->cxhdl.func = blackbird_mbox_func; 1182 dev->cxhdl.priv = dev; 1183 err = cx2341x_handler_init(&dev->cxhdl, 36); 1184 if (err) 1185 goto fail_core; 1186 v4l2_ctrl_add_handler(&dev->cxhdl.hdl, &core->video_hdl, NULL); 1187 1188 /* blackbird stuff */ 1189 pr_info("cx23416 based mpeg encoder (blackbird reference design)\n"); 1190 host_setup(dev->core); 1191 1192 blackbird_initialize_codec(dev); 1193 1194 /* initial device configuration: needed ? */ 1195 // init_controls(core); 1196 cx88_set_tvnorm(core, core->tvnorm); 1197 cx88_video_mux(core, 0); 1198 cx2341x_handler_set_50hz(&dev->cxhdl, core->height == 576); 1199 cx2341x_handler_setup(&dev->cxhdl); 1200 1201 q = &dev->vb2_mpegq; 1202 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1203 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ; 1204 q->gfp_flags = GFP_DMA32; 1205 q->min_buffers_needed = 2; 1206 q->drv_priv = dev; 1207 q->buf_struct_size = sizeof(struct cx88_buffer); 1208 q->ops = &blackbird_qops; 1209 q->mem_ops = &vb2_dma_sg_memops; 1210 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1211 q->lock = &core->lock; 1212 q->dev = &dev->pci->dev; 1213 1214 err = vb2_queue_init(q); 1215 if (err < 0) 1216 goto fail_core; 1217 1218 blackbird_register_video(dev); 1219 1220 return 0; 1221 1222 fail_core: 1223 return err; 1224 } 1225 1226 static int cx8802_blackbird_remove(struct cx8802_driver *drv) 1227 { 1228 struct cx88_core *core = drv->core; 1229 struct cx8802_dev *dev = core->dvbdev; 1230 1231 /* blackbird */ 1232 blackbird_unregister_video(drv->core->dvbdev); 1233 v4l2_ctrl_handler_free(&dev->cxhdl.hdl); 1234 1235 return 0; 1236 } 1237 1238 static struct cx8802_driver cx8802_blackbird_driver = { 1239 .type_id = CX88_MPEG_BLACKBIRD, 1240 .hw_access = CX8802_DRVCTL_SHARED, 1241 .probe = cx8802_blackbird_probe, 1242 .remove = cx8802_blackbird_remove, 1243 .advise_acquire = cx8802_blackbird_advise_acquire, 1244 .advise_release = cx8802_blackbird_advise_release, 1245 }; 1246 1247 static int __init blackbird_init(void) 1248 { 1249 pr_info("cx2388x blackbird driver version %s loaded\n", 1250 CX88_VERSION); 1251 return cx8802_register_driver(&cx8802_blackbird_driver); 1252 } 1253 1254 static void __exit blackbird_fini(void) 1255 { 1256 cx8802_unregister_driver(&cx8802_blackbird_driver); 1257 } 1258 1259 module_init(blackbird_init); 1260 module_exit(blackbird_fini); 1261