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[], void *alloc_ctxs[]) 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 alloc_ctxs[0] = dev->alloc_ctx; 651 return 0; 652 } 653 654 static int buffer_prepare(struct vb2_buffer *vb) 655 { 656 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 657 struct cx8802_dev *dev = vb->vb2_queue->drv_priv; 658 struct cx88_buffer *buf = container_of(vbuf, struct cx88_buffer, vb); 659 660 return cx8802_buf_prepare(vb->vb2_queue, dev, buf); 661 } 662 663 static void buffer_finish(struct vb2_buffer *vb) 664 { 665 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 666 struct cx8802_dev *dev = vb->vb2_queue->drv_priv; 667 struct cx88_buffer *buf = container_of(vbuf, struct cx88_buffer, vb); 668 struct cx88_riscmem *risc = &buf->risc; 669 670 if (risc->cpu) 671 pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma); 672 memset(risc, 0, sizeof(*risc)); 673 } 674 675 static void buffer_queue(struct vb2_buffer *vb) 676 { 677 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 678 struct cx8802_dev *dev = vb->vb2_queue->drv_priv; 679 struct cx88_buffer *buf = container_of(vbuf, struct cx88_buffer, vb); 680 681 cx8802_buf_queue(dev, buf); 682 } 683 684 static int start_streaming(struct vb2_queue *q, unsigned int count) 685 { 686 struct cx8802_dev *dev = q->drv_priv; 687 struct cx88_dmaqueue *dmaq = &dev->mpegq; 688 struct cx8802_driver *drv; 689 struct cx88_buffer *buf; 690 unsigned long flags; 691 int err; 692 693 /* Make sure we can acquire the hardware */ 694 drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD); 695 if (!drv) { 696 dprintk(1, "%s: blackbird driver is not loaded\n", __func__); 697 err = -ENODEV; 698 goto fail; 699 } 700 701 err = drv->request_acquire(drv); 702 if (err != 0) { 703 dprintk(1, "%s: Unable to acquire hardware, %d\n", __func__, err); 704 goto fail; 705 } 706 707 if (blackbird_initialize_codec(dev) < 0) { 708 drv->request_release(drv); 709 err = -EINVAL; 710 goto fail; 711 } 712 713 err = blackbird_start_codec(dev); 714 if (err == 0) { 715 buf = list_entry(dmaq->active.next, struct cx88_buffer, list); 716 cx8802_start_dma(dev, dmaq, buf); 717 return 0; 718 } 719 720 fail: 721 spin_lock_irqsave(&dev->slock, flags); 722 while (!list_empty(&dmaq->active)) { 723 struct cx88_buffer *buf = list_entry(dmaq->active.next, 724 struct cx88_buffer, list); 725 726 list_del(&buf->list); 727 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_QUEUED); 728 } 729 spin_unlock_irqrestore(&dev->slock, flags); 730 return err; 731 } 732 733 static void stop_streaming(struct vb2_queue *q) 734 { 735 struct cx8802_dev *dev = q->drv_priv; 736 struct cx88_dmaqueue *dmaq = &dev->mpegq; 737 struct cx8802_driver *drv = NULL; 738 unsigned long flags; 739 740 cx8802_cancel_buffers(dev); 741 blackbird_stop_codec(dev); 742 743 /* Make sure we release the hardware */ 744 drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD); 745 WARN_ON(!drv); 746 if (drv) 747 drv->request_release(drv); 748 749 spin_lock_irqsave(&dev->slock, flags); 750 while (!list_empty(&dmaq->active)) { 751 struct cx88_buffer *buf = list_entry(dmaq->active.next, 752 struct cx88_buffer, list); 753 754 list_del(&buf->list); 755 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 756 } 757 spin_unlock_irqrestore(&dev->slock, flags); 758 } 759 760 static struct vb2_ops blackbird_qops = { 761 .queue_setup = queue_setup, 762 .buf_prepare = buffer_prepare, 763 .buf_finish = buffer_finish, 764 .buf_queue = buffer_queue, 765 .wait_prepare = vb2_ops_wait_prepare, 766 .wait_finish = vb2_ops_wait_finish, 767 .start_streaming = start_streaming, 768 .stop_streaming = stop_streaming, 769 }; 770 771 /* ------------------------------------------------------------------ */ 772 773 static int vidioc_querycap(struct file *file, void *priv, 774 struct v4l2_capability *cap) 775 { 776 struct cx8802_dev *dev = video_drvdata(file); 777 struct cx88_core *core = dev->core; 778 779 strcpy(cap->driver, "cx88_blackbird"); 780 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci)); 781 cx88_querycap(file, core, cap); 782 return 0; 783 } 784 785 static int vidioc_enum_fmt_vid_cap (struct file *file, void *priv, 786 struct v4l2_fmtdesc *f) 787 { 788 if (f->index != 0) 789 return -EINVAL; 790 791 strlcpy(f->description, "MPEG", sizeof(f->description)); 792 f->pixelformat = V4L2_PIX_FMT_MPEG; 793 f->flags = V4L2_FMT_FLAG_COMPRESSED; 794 return 0; 795 } 796 797 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, 798 struct v4l2_format *f) 799 { 800 struct cx8802_dev *dev = video_drvdata(file); 801 struct cx88_core *core = dev->core; 802 803 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 804 f->fmt.pix.bytesperline = 0; 805 f->fmt.pix.sizeimage = dev->ts_packet_size * dev->ts_packet_count; 806 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 807 f->fmt.pix.width = core->width; 808 f->fmt.pix.height = core->height; 809 f->fmt.pix.field = core->field; 810 return 0; 811 } 812 813 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, 814 struct v4l2_format *f) 815 { 816 struct cx8802_dev *dev = video_drvdata(file); 817 struct cx88_core *core = dev->core; 818 unsigned maxw, maxh; 819 enum v4l2_field field; 820 821 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 822 f->fmt.pix.bytesperline = 0; 823 f->fmt.pix.sizeimage = dev->ts_packet_size * dev->ts_packet_count; 824 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 825 826 maxw = norm_maxw(core->tvnorm); 827 maxh = norm_maxh(core->tvnorm); 828 829 field = f->fmt.pix.field; 830 831 switch (field) { 832 case V4L2_FIELD_TOP: 833 case V4L2_FIELD_BOTTOM: 834 case V4L2_FIELD_INTERLACED: 835 case V4L2_FIELD_SEQ_BT: 836 case V4L2_FIELD_SEQ_TB: 837 break; 838 default: 839 field = (f->fmt.pix.height > maxh / 2) 840 ? V4L2_FIELD_INTERLACED 841 : V4L2_FIELD_BOTTOM; 842 break; 843 } 844 if (V4L2_FIELD_HAS_T_OR_B(field)) 845 maxh /= 2; 846 847 v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2, 848 &f->fmt.pix.height, 32, maxh, 0, 0); 849 f->fmt.pix.field = field; 850 return 0; 851 } 852 853 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 854 struct v4l2_format *f) 855 { 856 struct cx8802_dev *dev = video_drvdata(file); 857 struct cx88_core *core = dev->core; 858 859 if (vb2_is_busy(&dev->vb2_mpegq)) 860 return -EBUSY; 861 if (core->v4ldev && (vb2_is_busy(&core->v4ldev->vb2_vidq) || 862 vb2_is_busy(&core->v4ldev->vb2_vbiq))) 863 return -EBUSY; 864 vidioc_try_fmt_vid_cap(file, priv, f); 865 core->width = f->fmt.pix.width; 866 core->height = f->fmt.pix.height; 867 core->field = f->fmt.pix.field; 868 cx88_set_scale(core, f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field); 869 blackbird_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0, 870 f->fmt.pix.height, f->fmt.pix.width); 871 return 0; 872 } 873 874 static int vidioc_s_frequency (struct file *file, void *priv, 875 const struct v4l2_frequency *f) 876 { 877 struct cx8802_dev *dev = video_drvdata(file); 878 struct cx88_core *core = dev->core; 879 bool streaming; 880 881 if (unlikely(UNSET == core->board.tuner_type)) 882 return -EINVAL; 883 if (unlikely(f->tuner != 0)) 884 return -EINVAL; 885 streaming = vb2_start_streaming_called(&dev->vb2_mpegq); 886 if (streaming) 887 blackbird_stop_codec(dev); 888 889 cx88_set_freq (core,f); 890 blackbird_initialize_codec(dev); 891 cx88_set_scale(core, core->width, core->height, 892 core->field); 893 if (streaming) 894 blackbird_start_codec(dev); 895 return 0; 896 } 897 898 static int vidioc_log_status (struct file *file, void *priv) 899 { 900 struct cx8802_dev *dev = video_drvdata(file); 901 struct cx88_core *core = dev->core; 902 char name[32 + 2]; 903 904 snprintf(name, sizeof(name), "%s/2", core->name); 905 call_all(core, core, log_status); 906 v4l2_ctrl_handler_log_status(&dev->cxhdl.hdl, name); 907 return 0; 908 } 909 910 static int vidioc_enum_input (struct file *file, void *priv, 911 struct v4l2_input *i) 912 { 913 struct cx8802_dev *dev = video_drvdata(file); 914 struct cx88_core *core = dev->core; 915 return cx88_enum_input (core,i); 916 } 917 918 static int vidioc_g_frequency (struct file *file, void *priv, 919 struct v4l2_frequency *f) 920 { 921 struct cx8802_dev *dev = video_drvdata(file); 922 struct cx88_core *core = dev->core; 923 924 if (unlikely(UNSET == core->board.tuner_type)) 925 return -EINVAL; 926 if (unlikely(f->tuner != 0)) 927 return -EINVAL; 928 929 f->frequency = core->freq; 930 call_all(core, tuner, g_frequency, f); 931 932 return 0; 933 } 934 935 static int vidioc_g_input (struct file *file, void *priv, unsigned int *i) 936 { 937 struct cx8802_dev *dev = video_drvdata(file); 938 struct cx88_core *core = dev->core; 939 940 *i = core->input; 941 return 0; 942 } 943 944 static int vidioc_s_input (struct file *file, void *priv, unsigned int i) 945 { 946 struct cx8802_dev *dev = video_drvdata(file); 947 struct cx88_core *core = dev->core; 948 949 if (i >= 4) 950 return -EINVAL; 951 if (0 == INPUT(i).type) 952 return -EINVAL; 953 954 cx88_newstation(core); 955 cx88_video_mux(core,i); 956 return 0; 957 } 958 959 static int vidioc_g_tuner (struct file *file, void *priv, 960 struct v4l2_tuner *t) 961 { 962 struct cx8802_dev *dev = video_drvdata(file); 963 struct cx88_core *core = dev->core; 964 u32 reg; 965 966 if (unlikely(UNSET == core->board.tuner_type)) 967 return -EINVAL; 968 if (0 != t->index) 969 return -EINVAL; 970 971 strcpy(t->name, "Television"); 972 t->capability = V4L2_TUNER_CAP_NORM; 973 t->rangehigh = 0xffffffffUL; 974 call_all(core, tuner, g_tuner, t); 975 976 cx88_get_stereo(core ,t); 977 reg = cx_read(MO_DEVICE_STATUS); 978 t->signal = (reg & (1<<5)) ? 0xffff : 0x0000; 979 return 0; 980 } 981 982 static int vidioc_s_tuner (struct file *file, void *priv, 983 const struct v4l2_tuner *t) 984 { 985 struct cx8802_dev *dev = video_drvdata(file); 986 struct cx88_core *core = dev->core; 987 988 if (UNSET == core->board.tuner_type) 989 return -EINVAL; 990 if (0 != t->index) 991 return -EINVAL; 992 993 cx88_set_stereo(core, t->audmode, 1); 994 return 0; 995 } 996 997 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorm) 998 { 999 struct cx8802_dev *dev = video_drvdata(file); 1000 struct cx88_core *core = dev->core; 1001 1002 *tvnorm = core->tvnorm; 1003 return 0; 1004 } 1005 1006 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id) 1007 { 1008 struct cx8802_dev *dev = video_drvdata(file); 1009 struct cx88_core *core = dev->core; 1010 1011 return cx88_set_tvnorm(core, id); 1012 } 1013 1014 static const struct v4l2_file_operations mpeg_fops = 1015 { 1016 .owner = THIS_MODULE, 1017 .open = v4l2_fh_open, 1018 .release = vb2_fop_release, 1019 .read = vb2_fop_read, 1020 .poll = vb2_fop_poll, 1021 .mmap = vb2_fop_mmap, 1022 .unlocked_ioctl = video_ioctl2, 1023 }; 1024 1025 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = { 1026 .vidioc_querycap = vidioc_querycap, 1027 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 1028 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 1029 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 1030 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 1031 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1032 .vidioc_querybuf = vb2_ioctl_querybuf, 1033 .vidioc_qbuf = vb2_ioctl_qbuf, 1034 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1035 .vidioc_streamon = vb2_ioctl_streamon, 1036 .vidioc_streamoff = vb2_ioctl_streamoff, 1037 .vidioc_s_frequency = vidioc_s_frequency, 1038 .vidioc_log_status = vidioc_log_status, 1039 .vidioc_enum_input = vidioc_enum_input, 1040 .vidioc_g_frequency = vidioc_g_frequency, 1041 .vidioc_g_input = vidioc_g_input, 1042 .vidioc_s_input = vidioc_s_input, 1043 .vidioc_g_tuner = vidioc_g_tuner, 1044 .vidioc_s_tuner = vidioc_s_tuner, 1045 .vidioc_g_std = vidioc_g_std, 1046 .vidioc_s_std = vidioc_s_std, 1047 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 1048 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1049 }; 1050 1051 static struct video_device cx8802_mpeg_template = { 1052 .name = "cx8802", 1053 .fops = &mpeg_fops, 1054 .ioctl_ops = &mpeg_ioctl_ops, 1055 .tvnorms = CX88_NORMS, 1056 }; 1057 1058 /* ------------------------------------------------------------------ */ 1059 1060 /* The CX8802 MPEG API will call this when we can use the hardware */ 1061 static int cx8802_blackbird_advise_acquire(struct cx8802_driver *drv) 1062 { 1063 struct cx88_core *core = drv->core; 1064 int err = 0; 1065 1066 switch (core->boardnr) { 1067 case CX88_BOARD_HAUPPAUGE_HVR1300: 1068 /* By default, core setup will leave the cx22702 out of reset, on the bus. 1069 * We left the hardware on power up with the cx22702 active. 1070 * We're being given access to re-arrange the GPIOs. 1071 * Take the bus off the cx22702 and put the cx23416 on it. 1072 */ 1073 /* Toggle reset on cx22702 leaving i2c active */ 1074 cx_set(MO_GP0_IO, 0x00000080); 1075 udelay(1000); 1076 cx_clear(MO_GP0_IO, 0x00000080); 1077 udelay(50); 1078 cx_set(MO_GP0_IO, 0x00000080); 1079 udelay(1000); 1080 /* tri-state the cx22702 pins */ 1081 cx_set(MO_GP0_IO, 0x00000004); 1082 udelay(1000); 1083 break; 1084 default: 1085 err = -ENODEV; 1086 } 1087 return err; 1088 } 1089 1090 /* The CX8802 MPEG API will call this when we need to release the hardware */ 1091 static int cx8802_blackbird_advise_release(struct cx8802_driver *drv) 1092 { 1093 struct cx88_core *core = drv->core; 1094 int err = 0; 1095 1096 switch (core->boardnr) { 1097 case CX88_BOARD_HAUPPAUGE_HVR1300: 1098 /* Exit leaving the cx23416 on the bus */ 1099 break; 1100 default: 1101 err = -ENODEV; 1102 } 1103 return err; 1104 } 1105 1106 static void blackbird_unregister_video(struct cx8802_dev *dev) 1107 { 1108 video_unregister_device(&dev->mpeg_dev); 1109 } 1110 1111 static int blackbird_register_video(struct cx8802_dev *dev) 1112 { 1113 int err; 1114 1115 cx88_vdev_init(dev->core, dev->pci, &dev->mpeg_dev, 1116 &cx8802_mpeg_template, "mpeg"); 1117 dev->mpeg_dev.ctrl_handler = &dev->cxhdl.hdl; 1118 video_set_drvdata(&dev->mpeg_dev, dev); 1119 dev->mpeg_dev.queue = &dev->vb2_mpegq; 1120 err = video_register_device(&dev->mpeg_dev, VFL_TYPE_GRABBER, -1); 1121 if (err < 0) { 1122 printk(KERN_INFO "%s/2: can't register mpeg device\n", 1123 dev->core->name); 1124 return err; 1125 } 1126 printk(KERN_INFO "%s/2: registered device %s [mpeg]\n", 1127 dev->core->name, video_device_node_name(&dev->mpeg_dev)); 1128 return 0; 1129 } 1130 1131 /* ----------------------------------------------------------- */ 1132 1133 static int cx8802_blackbird_probe(struct cx8802_driver *drv) 1134 { 1135 struct cx88_core *core = drv->core; 1136 struct cx8802_dev *dev = core->dvbdev; 1137 struct vb2_queue *q; 1138 int err; 1139 1140 dprintk( 1, "%s\n", __func__); 1141 dprintk( 1, " ->being probed by Card=%d Name=%s, PCI %02x:%02x\n", 1142 core->boardnr, 1143 core->name, 1144 core->pci_bus, 1145 core->pci_slot); 1146 1147 err = -ENODEV; 1148 if (!(core->board.mpeg & CX88_MPEG_BLACKBIRD)) 1149 goto fail_core; 1150 1151 dev->cxhdl.port = CX2341X_PORT_STREAMING; 1152 dev->cxhdl.width = core->width; 1153 dev->cxhdl.height = core->height; 1154 dev->cxhdl.func = blackbird_mbox_func; 1155 dev->cxhdl.priv = dev; 1156 err = cx2341x_handler_init(&dev->cxhdl, 36); 1157 if (err) 1158 goto fail_core; 1159 v4l2_ctrl_add_handler(&dev->cxhdl.hdl, &core->video_hdl, NULL); 1160 1161 /* blackbird stuff */ 1162 printk("%s/2: cx23416 based mpeg encoder (blackbird reference design)\n", 1163 core->name); 1164 host_setup(dev->core); 1165 1166 blackbird_initialize_codec(dev); 1167 1168 /* initial device configuration: needed ? */ 1169 // init_controls(core); 1170 cx88_set_tvnorm(core,core->tvnorm); 1171 cx88_video_mux(core,0); 1172 cx2341x_handler_set_50hz(&dev->cxhdl, core->height == 576); 1173 cx2341x_handler_setup(&dev->cxhdl); 1174 1175 q = &dev->vb2_mpegq; 1176 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1177 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ; 1178 q->gfp_flags = GFP_DMA32; 1179 q->min_buffers_needed = 2; 1180 q->drv_priv = dev; 1181 q->buf_struct_size = sizeof(struct cx88_buffer); 1182 q->ops = &blackbird_qops; 1183 q->mem_ops = &vb2_dma_sg_memops; 1184 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1185 q->lock = &core->lock; 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