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