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