drivers/media/pci/cx23885/cx23885-417.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
cx23885_mc417_init
mc417_wait_ready
mc417_register_write
mc417_register_read
mc417_memory_write
mc417_memory_read
mc417_gpio_set
mc417_gpio_clear
mc417_gpio_enable
cmd_to_str
cx23885_mbox_func
cx23885_api_cmd
cx23885_api_func
cx23885_find_mailbox
cx23885_load_firmware
cx23885_417_check_encoder
cx23885_codec_settings
cx23885_initialize_codec
queue_setup
buffer_prepare
buffer_finish
buffer_queue
cx23885_start_streaming
cx23885_stop_streaming
vidioc_g_std
vidioc_s_std
vidioc_enum_input
vidioc_g_input
vidioc_s_input
vidioc_g_tuner
vidioc_s_tuner
vidioc_g_frequency
vidioc_s_frequency
vidioc_querycap
vidioc_enum_fmt_vid_cap
vidioc_g_fmt_vid_cap
vidioc_try_fmt_vid_cap
vidioc_s_fmt_vid_cap
vidioc_log_status
cx23885_417_unregister
cx23885_video_dev_alloc
cx23885_417_register
   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *
   4  *  Support for a cx23417 mpeg encoder via cx23885 host port.
   5  *
   6  *    (c) 2004 Jelle Foks <jelle@foks.us>
   7  *    (c) 2004 Gerd Knorr <kraxel@bytesex.org>
   8  *    (c) 2008 Steven Toth <stoth@linuxtv.org>
   9  *      - CX23885/7/8 support
  10  *
  11  *  Includes parts from the ivtv driver <http://sourceforge.net/projects/ivtv/>
  12  */
  13 
  14 #include "cx23885.h"
  15 #include "cx23885-ioctl.h"
  16 
  17 #include <linux/module.h>
  18 #include <linux/moduleparam.h>
  19 #include <linux/init.h>
  20 #include <linux/fs.h>
  21 #include <linux/delay.h>
  22 #include <linux/device.h>
  23 #include <linux/firmware.h>
  24 #include <linux/slab.h>
  25 #include <media/v4l2-common.h>
  26 #include <media/v4l2-ioctl.h>
  27 #include <media/drv-intf/cx2341x.h>
  28 
  29 #define CX23885_FIRM_IMAGE_SIZE 376836
  30 #define CX23885_FIRM_IMAGE_NAME "v4l-cx23885-enc.fw"
  31 
  32 static unsigned int mpegbufs = 32;
  33 module_param(mpegbufs, int, 0644);
  34 MODULE_PARM_DESC(mpegbufs, "number of mpeg buffers, range 2-32");
  35 static unsigned int mpeglines = 32;
  36 module_param(mpeglines, int, 0644);
  37 MODULE_PARM_DESC(mpeglines, "number of lines in an MPEG buffer, range 2-32");
  38 static unsigned int mpeglinesize = 512;
  39 module_param(mpeglinesize, int, 0644);
  40 MODULE_PARM_DESC(mpeglinesize,
  41         "number of bytes in each line of an MPEG buffer, range 512-1024");
  42 
  43 static unsigned int v4l_debug;
  44 module_param(v4l_debug, int, 0644);
  45 MODULE_PARM_DESC(v4l_debug, "enable V4L debug messages");
  46 
  47 #define dprintk(level, fmt, arg...)\
  48         do { if (v4l_debug >= level) \
  49                 printk(KERN_DEBUG pr_fmt("%s: 417:" fmt), \
  50                         __func__, ##arg); \
  51         } while (0)
  52 
  53 static struct cx23885_tvnorm cx23885_tvnorms[] = {
  54         {
  55                 .name      = "NTSC-M",
  56                 .id        = V4L2_STD_NTSC_M,
  57         }, {
  58                 .name      = "NTSC-JP",
  59                 .id        = V4L2_STD_NTSC_M_JP,
  60         }, {
  61                 .name      = "PAL-BG",
  62                 .id        = V4L2_STD_PAL_BG,
  63         }, {
  64                 .name      = "PAL-DK",
  65                 .id        = V4L2_STD_PAL_DK,
  66         }, {
  67                 .name      = "PAL-I",
  68                 .id        = V4L2_STD_PAL_I,
  69         }, {
  70                 .name      = "PAL-M",
  71                 .id        = V4L2_STD_PAL_M,
  72         }, {
  73                 .name      = "PAL-N",
  74                 .id        = V4L2_STD_PAL_N,
  75         }, {
  76                 .name      = "PAL-Nc",
  77                 .id        = V4L2_STD_PAL_Nc,
  78         }, {
  79                 .name      = "PAL-60",
  80                 .id        = V4L2_STD_PAL_60,
  81         }, {
  82                 .name      = "SECAM-L",
  83                 .id        = V4L2_STD_SECAM_L,
  84         }, {
  85                 .name      = "SECAM-DK",
  86                 .id        = V4L2_STD_SECAM_DK,
  87         }
  88 };
  89 
  90 /* ------------------------------------------------------------------ */
  91 enum cx23885_capture_type {
  92         CX23885_MPEG_CAPTURE,
  93         CX23885_RAW_CAPTURE,
  94         CX23885_RAW_PASSTHRU_CAPTURE
  95 };
  96 enum cx23885_capture_bits {
  97         CX23885_RAW_BITS_NONE             = 0x00,
  98         CX23885_RAW_BITS_YUV_CAPTURE      = 0x01,
  99         CX23885_RAW_BITS_PCM_CAPTURE      = 0x02,
 100         CX23885_RAW_BITS_VBI_CAPTURE      = 0x04,
 101         CX23885_RAW_BITS_PASSTHRU_CAPTURE = 0x08,
 102         CX23885_RAW_BITS_TO_HOST_CAPTURE  = 0x10
 103 };
 104 enum cx23885_capture_end {
 105         CX23885_END_AT_GOP, /* stop at the end of gop, generate irq */
 106         CX23885_END_NOW, /* stop immediately, no irq */
 107 };
 108 enum cx23885_framerate {
 109         CX23885_FRAMERATE_NTSC_30, /* NTSC: 30fps */
 110         CX23885_FRAMERATE_PAL_25   /* PAL: 25fps */
 111 };
 112 enum cx23885_stream_port {
 113         CX23885_OUTPUT_PORT_MEMORY,
 114         CX23885_OUTPUT_PORT_STREAMING,
 115         CX23885_OUTPUT_PORT_SERIAL
 116 };
 117 enum cx23885_data_xfer_status {
 118         CX23885_MORE_BUFFERS_FOLLOW,
 119         CX23885_LAST_BUFFER,
 120 };
 121 enum cx23885_picture_mask {
 122         CX23885_PICTURE_MASK_NONE,
 123         CX23885_PICTURE_MASK_I_FRAMES,
 124         CX23885_PICTURE_MASK_I_P_FRAMES = 0x3,
 125         CX23885_PICTURE_MASK_ALL_FRAMES = 0x7,
 126 };
 127 enum cx23885_vbi_mode_bits {
 128         CX23885_VBI_BITS_SLICED,
 129         CX23885_VBI_BITS_RAW,
 130 };
 131 enum cx23885_vbi_insertion_bits {
 132         CX23885_VBI_BITS_INSERT_IN_XTENSION_USR_DATA,
 133         CX23885_VBI_BITS_INSERT_IN_PRIVATE_PACKETS = 0x1 << 1,
 134         CX23885_VBI_BITS_SEPARATE_STREAM = 0x2 << 1,
 135         CX23885_VBI_BITS_SEPARATE_STREAM_USR_DATA = 0x4 << 1,
 136         CX23885_VBI_BITS_SEPARATE_STREAM_PRV_DATA = 0x5 << 1,
 137 };
 138 enum cx23885_dma_unit {
 139         CX23885_DMA_BYTES,
 140         CX23885_DMA_FRAMES,
 141 };
 142 enum cx23885_dma_transfer_status_bits {
 143         CX23885_DMA_TRANSFER_BITS_DONE = 0x01,
 144         CX23885_DMA_TRANSFER_BITS_ERROR = 0x04,
 145         CX23885_DMA_TRANSFER_BITS_LL_ERROR = 0x10,
 146 };
 147 enum cx23885_pause {
 148         CX23885_PAUSE_ENCODING,
 149         CX23885_RESUME_ENCODING,
 150 };
 151 enum cx23885_copyright {
 152         CX23885_COPYRIGHT_OFF,
 153         CX23885_COPYRIGHT_ON,
 154 };
 155 enum cx23885_notification_type {
 156         CX23885_NOTIFICATION_REFRESH,
 157 };
 158 enum cx23885_notification_status {
 159         CX23885_NOTIFICATION_OFF,
 160         CX23885_NOTIFICATION_ON,
 161 };
 162 enum cx23885_notification_mailbox {
 163         CX23885_NOTIFICATION_NO_MAILBOX = -1,
 164 };
 165 enum cx23885_field1_lines {
 166         CX23885_FIELD1_SAA7114 = 0x00EF, /* 239 */
 167         CX23885_FIELD1_SAA7115 = 0x00F0, /* 240 */
 168         CX23885_FIELD1_MICRONAS = 0x0105, /* 261 */
 169 };
 170 enum cx23885_field2_lines {
 171         CX23885_FIELD2_SAA7114 = 0x00EF, /* 239 */
 172         CX23885_FIELD2_SAA7115 = 0x00F0, /* 240 */
 173         CX23885_FIELD2_MICRONAS = 0x0106, /* 262 */
 174 };
 175 enum cx23885_custom_data_type {
 176         CX23885_CUSTOM_EXTENSION_USR_DATA,
 177         CX23885_CUSTOM_PRIVATE_PACKET,
 178 };
 179 enum cx23885_mute {
 180         CX23885_UNMUTE,
 181         CX23885_MUTE,
 182 };
 183 enum cx23885_mute_video_mask {
 184         CX23885_MUTE_VIDEO_V_MASK = 0x0000FF00,
 185         CX23885_MUTE_VIDEO_U_MASK = 0x00FF0000,
 186         CX23885_MUTE_VIDEO_Y_MASK = 0xFF000000,
 187 };
 188 enum cx23885_mute_video_shift {
 189         CX23885_MUTE_VIDEO_V_SHIFT = 8,
 190         CX23885_MUTE_VIDEO_U_SHIFT = 16,
 191         CX23885_MUTE_VIDEO_Y_SHIFT = 24,
 192 };
 193 
 194 /* defines below are from ivtv-driver.h */
 195 #define IVTV_CMD_HW_BLOCKS_RST 0xFFFFFFFF
 196 
 197 /* Firmware API commands */
 198 #define IVTV_API_STD_TIMEOUT 500
 199 
 200 /* Registers */
 201 /* IVTV_REG_OFFSET */
 202 #define IVTV_REG_ENC_SDRAM_REFRESH (0x07F8)
 203 #define IVTV_REG_ENC_SDRAM_PRECHARGE (0x07FC)
 204 #define IVTV_REG_SPU (0x9050)
 205 #define IVTV_REG_HW_BLOCKS (0x9054)
 206 #define IVTV_REG_VPU (0x9058)
 207 #define IVTV_REG_APU (0xA064)
 208 
 209 /**** Bit definitions for MC417_RWD and MC417_OEN registers  ***
 210   bits 31-16
 211 +-----------+
 212 | Reserved  |
 213 +-----------+
 214   bit 15  bit 14  bit 13 bit 12  bit 11  bit 10  bit 9   bit 8
 215 +-------+-------+-------+-------+-------+-------+-------+-------+
 216 | MIWR# | MIRD# | MICS# |MIRDY# |MIADDR3|MIADDR2|MIADDR1|MIADDR0|
 217 +-------+-------+-------+-------+-------+-------+-------+-------+
 218  bit 7   bit 6   bit 5   bit 4   bit 3   bit 2   bit 1   bit 0
 219 +-------+-------+-------+-------+-------+-------+-------+-------+
 220 |MIDATA7|MIDATA6|MIDATA5|MIDATA4|MIDATA3|MIDATA2|MIDATA1|MIDATA0|
 221 +-------+-------+-------+-------+-------+-------+-------+-------+
 222 ***/
 223 #define MC417_MIWR      0x8000
 224 #define MC417_MIRD      0x4000
 225 #define MC417_MICS      0x2000
 226 #define MC417_MIRDY     0x1000
 227 #define MC417_MIADDR    0x0F00
 228 #define MC417_MIDATA    0x00FF
 229 
 230 /* MIADDR* nibble definitions */
 231 #define  MCI_MEMORY_DATA_BYTE0          0x000
 232 #define  MCI_MEMORY_DATA_BYTE1          0x100
 233 #define  MCI_MEMORY_DATA_BYTE2          0x200
 234 #define  MCI_MEMORY_DATA_BYTE3          0x300
 235 #define  MCI_MEMORY_ADDRESS_BYTE2       0x400
 236 #define  MCI_MEMORY_ADDRESS_BYTE1       0x500
 237 #define  MCI_MEMORY_ADDRESS_BYTE0       0x600
 238 #define  MCI_REGISTER_DATA_BYTE0        0x800
 239 #define  MCI_REGISTER_DATA_BYTE1        0x900
 240 #define  MCI_REGISTER_DATA_BYTE2        0xA00
 241 #define  MCI_REGISTER_DATA_BYTE3        0xB00
 242 #define  MCI_REGISTER_ADDRESS_BYTE0     0xC00
 243 #define  MCI_REGISTER_ADDRESS_BYTE1     0xD00
 244 #define  MCI_REGISTER_MODE              0xE00
 245 
 246 /* Read and write modes */
 247 #define  MCI_MODE_REGISTER_READ         0
 248 #define  MCI_MODE_REGISTER_WRITE        1
 249 #define  MCI_MODE_MEMORY_READ           0
 250 #define  MCI_MODE_MEMORY_WRITE          0x40
 251 
 252 /*** Bit definitions for MC417_CTL register ****
 253  bits 31-6   bits 5-4   bit 3    bits 2-1       Bit 0
 254 +--------+-------------+--------+--------------+------------+
 255 |Reserved|MC417_SPD_CTL|Reserved|MC417_GPIO_SEL|UART_GPIO_EN|
 256 +--------+-------------+--------+--------------+------------+
 257 ***/
 258 #define MC417_SPD_CTL(x)        (((x) << 4) & 0x00000030)
 259 #define MC417_GPIO_SEL(x)       (((x) << 1) & 0x00000006)
 260 #define MC417_UART_GPIO_EN      0x00000001
 261 
 262 /* Values for speed control */
 263 #define MC417_SPD_CTL_SLOW      0x1
 264 #define MC417_SPD_CTL_MEDIUM    0x0
 265 #define MC417_SPD_CTL_FAST      0x3     /* b'1x, but we use b'11 */
 266 
 267 /* Values for GPIO select */
 268 #define MC417_GPIO_SEL_GPIO3    0x3
 269 #define MC417_GPIO_SEL_GPIO2    0x2
 270 #define MC417_GPIO_SEL_GPIO1    0x1
 271 #define MC417_GPIO_SEL_GPIO0    0x0
 272 
 273 void cx23885_mc417_init(struct cx23885_dev *dev)
 274 {
 275         u32 regval;
 276 
 277         dprintk(2, "%s()\n", __func__);
 278 
 279         /* Configure MC417_CTL register to defaults. */
 280         regval = MC417_SPD_CTL(MC417_SPD_CTL_FAST)      |
 281                  MC417_GPIO_SEL(MC417_GPIO_SEL_GPIO3)   |
 282                  MC417_UART_GPIO_EN;
 283         cx_write(MC417_CTL, regval);
 284 
 285         /* Configure MC417_OEN to defaults. */
 286         regval = MC417_MIRDY;
 287         cx_write(MC417_OEN, regval);
 288 
 289         /* Configure MC417_RWD to defaults. */
 290         regval = MC417_MIWR | MC417_MIRD | MC417_MICS;
 291         cx_write(MC417_RWD, regval);
 292 }
 293 
 294 static int mc417_wait_ready(struct cx23885_dev *dev)
 295 {
 296         u32 mi_ready;
 297         unsigned long timeout = jiffies + msecs_to_jiffies(1);
 298 
 299         for (;;) {
 300                 mi_ready = cx_read(MC417_RWD) & MC417_MIRDY;
 301                 if (mi_ready != 0)
 302                         return 0;
 303                 if (time_after(jiffies, timeout))
 304                         return -1;
 305                 udelay(1);
 306         }
 307 }
 308 
 309 int mc417_register_write(struct cx23885_dev *dev, u16 address, u32 value)
 310 {
 311         u32 regval;
 312 
 313         /* Enable MC417 GPIO outputs except for MC417_MIRDY,
 314          * which is an input.
 315          */
 316         cx_write(MC417_OEN, MC417_MIRDY);
 317 
 318         /* Write data byte 0 */
 319         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE0 |
 320                 (value & 0x000000FF);
 321         cx_write(MC417_RWD, regval);
 322 
 323         /* Transition CS/WR to effect write transaction across bus. */
 324         regval |= MC417_MICS | MC417_MIWR;
 325         cx_write(MC417_RWD, regval);
 326 
 327         /* Write data byte 1 */
 328         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE1 |
 329                 ((value >> 8) & 0x000000FF);
 330         cx_write(MC417_RWD, regval);
 331         regval |= MC417_MICS | MC417_MIWR;
 332         cx_write(MC417_RWD, regval);
 333 
 334         /* Write data byte 2 */
 335         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE2 |
 336                 ((value >> 16) & 0x000000FF);
 337         cx_write(MC417_RWD, regval);
 338         regval |= MC417_MICS | MC417_MIWR;
 339         cx_write(MC417_RWD, regval);
 340 
 341         /* Write data byte 3 */
 342         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE3 |
 343                 ((value >> 24) & 0x000000FF);
 344         cx_write(MC417_RWD, regval);
 345         regval |= MC417_MICS | MC417_MIWR;
 346         cx_write(MC417_RWD, regval);
 347 
 348         /* Write address byte 0 */
 349         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_ADDRESS_BYTE0 |
 350                 (address & 0xFF);
 351         cx_write(MC417_RWD, regval);
 352         regval |= MC417_MICS | MC417_MIWR;
 353         cx_write(MC417_RWD, regval);
 354 
 355         /* Write address byte 1 */
 356         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_ADDRESS_BYTE1 |
 357                 ((address >> 8) & 0xFF);
 358         cx_write(MC417_RWD, regval);
 359         regval |= MC417_MICS | MC417_MIWR;
 360         cx_write(MC417_RWD, regval);
 361 
 362         /* Indicate that this is a write. */
 363         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_MODE |
 364                 MCI_MODE_REGISTER_WRITE;
 365         cx_write(MC417_RWD, regval);
 366         regval |= MC417_MICS | MC417_MIWR;
 367         cx_write(MC417_RWD, regval);
 368 
 369         /* Wait for the trans to complete (MC417_MIRDY asserted). */
 370         return mc417_wait_ready(dev);
 371 }
 372 
 373 int mc417_register_read(struct cx23885_dev *dev, u16 address, u32 *value)
 374 {
 375         int retval;
 376         u32 regval;
 377         u32 tempval;
 378         u32 dataval;
 379 
 380         /* Enable MC417 GPIO outputs except for MC417_MIRDY,
 381          * which is an input.
 382          */
 383         cx_write(MC417_OEN, MC417_MIRDY);
 384 
 385         /* Write address byte 0 */
 386         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_ADDRESS_BYTE0 |
 387                 ((address & 0x00FF));
 388         cx_write(MC417_RWD, regval);
 389         regval |= MC417_MICS | MC417_MIWR;
 390         cx_write(MC417_RWD, regval);
 391 
 392         /* Write address byte 1 */
 393         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_ADDRESS_BYTE1 |
 394                 ((address >> 8) & 0xFF);
 395         cx_write(MC417_RWD, regval);
 396         regval |= MC417_MICS | MC417_MIWR;
 397         cx_write(MC417_RWD, regval);
 398 
 399         /* Indicate that this is a register read. */
 400         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_MODE |
 401                 MCI_MODE_REGISTER_READ;
 402         cx_write(MC417_RWD, regval);
 403         regval |= MC417_MICS | MC417_MIWR;
 404         cx_write(MC417_RWD, regval);
 405 
 406         /* Wait for the trans to complete (MC417_MIRDY asserted). */
 407         retval = mc417_wait_ready(dev);
 408 
 409         /* switch the DAT0-7 GPIO[10:3] to input mode */
 410         cx_write(MC417_OEN, MC417_MIRDY | MC417_MIDATA);
 411 
 412         /* Read data byte 0 */
 413         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE0;
 414         cx_write(MC417_RWD, regval);
 415 
 416         /* Transition RD to effect read transaction across bus.
 417          * Transition 0x5000 -> 0x9000 correct (RD/RDY -> WR/RDY)?
 418          * Should it be 0x9000 -> 0xF000 (also why is RDY being set, its
 419          * input only...)
 420          */
 421         regval = MC417_MIWR | MC417_MIRDY | MCI_REGISTER_DATA_BYTE0;
 422         cx_write(MC417_RWD, regval);
 423 
 424         /* Collect byte */
 425         tempval = cx_read(MC417_RWD);
 426         dataval = tempval & 0x000000FF;
 427 
 428         /* Bring CS and RD high. */
 429         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
 430         cx_write(MC417_RWD, regval);
 431 
 432         /* Read data byte 1 */
 433         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE1;
 434         cx_write(MC417_RWD, regval);
 435         regval = MC417_MIWR | MC417_MIRDY | MCI_REGISTER_DATA_BYTE1;
 436         cx_write(MC417_RWD, regval);
 437         tempval = cx_read(MC417_RWD);
 438         dataval |= ((tempval & 0x000000FF) << 8);
 439         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
 440         cx_write(MC417_RWD, regval);
 441 
 442         /* Read data byte 2 */
 443         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE2;
 444         cx_write(MC417_RWD, regval);
 445         regval = MC417_MIWR | MC417_MIRDY | MCI_REGISTER_DATA_BYTE2;
 446         cx_write(MC417_RWD, regval);
 447         tempval = cx_read(MC417_RWD);
 448         dataval |= ((tempval & 0x000000FF) << 16);
 449         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
 450         cx_write(MC417_RWD, regval);
 451 
 452         /* Read data byte 3 */
 453         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE3;
 454         cx_write(MC417_RWD, regval);
 455         regval = MC417_MIWR | MC417_MIRDY | MCI_REGISTER_DATA_BYTE3;
 456         cx_write(MC417_RWD, regval);
 457         tempval = cx_read(MC417_RWD);
 458         dataval |= ((tempval & 0x000000FF) << 24);
 459         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
 460         cx_write(MC417_RWD, regval);
 461 
 462         *value  = dataval;
 463 
 464         return retval;
 465 }
 466 
 467 int mc417_memory_write(struct cx23885_dev *dev, u32 address, u32 value)
 468 {
 469         u32 regval;
 470 
 471         /* Enable MC417 GPIO outputs except for MC417_MIRDY,
 472          * which is an input.
 473          */
 474         cx_write(MC417_OEN, MC417_MIRDY);
 475 
 476         /* Write data byte 0 */
 477         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE0 |
 478                 (value & 0x000000FF);
 479         cx_write(MC417_RWD, regval);
 480 
 481         /* Transition CS/WR to effect write transaction across bus. */
 482         regval |= MC417_MICS | MC417_MIWR;
 483         cx_write(MC417_RWD, regval);
 484 
 485         /* Write data byte 1 */
 486         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE1 |
 487                 ((value >> 8) & 0x000000FF);
 488         cx_write(MC417_RWD, regval);
 489         regval |= MC417_MICS | MC417_MIWR;
 490         cx_write(MC417_RWD, regval);
 491 
 492         /* Write data byte 2 */
 493         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE2 |
 494                 ((value >> 16) & 0x000000FF);
 495         cx_write(MC417_RWD, regval);
 496         regval |= MC417_MICS | MC417_MIWR;
 497         cx_write(MC417_RWD, regval);
 498 
 499         /* Write data byte 3 */
 500         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE3 |
 501                 ((value >> 24) & 0x000000FF);
 502         cx_write(MC417_RWD, regval);
 503         regval |= MC417_MICS | MC417_MIWR;
 504         cx_write(MC417_RWD, regval);
 505 
 506         /* Write address byte 2 */
 507         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE2 |
 508                 MCI_MODE_MEMORY_WRITE | ((address >> 16) & 0x3F);
 509         cx_write(MC417_RWD, regval);
 510         regval |= MC417_MICS | MC417_MIWR;
 511         cx_write(MC417_RWD, regval);
 512 
 513         /* Write address byte 1 */
 514         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE1 |
 515                 ((address >> 8) & 0xFF);
 516         cx_write(MC417_RWD, regval);
 517         regval |= MC417_MICS | MC417_MIWR;
 518         cx_write(MC417_RWD, regval);
 519 
 520         /* Write address byte 0 */
 521         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE0 |
 522                 (address & 0xFF);
 523         cx_write(MC417_RWD, regval);
 524         regval |= MC417_MICS | MC417_MIWR;
 525         cx_write(MC417_RWD, regval);
 526 
 527         /* Wait for the trans to complete (MC417_MIRDY asserted). */
 528         return mc417_wait_ready(dev);
 529 }
 530 
 531 int mc417_memory_read(struct cx23885_dev *dev, u32 address, u32 *value)
 532 {
 533         int retval;
 534         u32 regval;
 535         u32 tempval;
 536         u32 dataval;
 537 
 538         /* Enable MC417 GPIO outputs except for MC417_MIRDY,
 539          * which is an input.
 540          */
 541         cx_write(MC417_OEN, MC417_MIRDY);
 542 
 543         /* Write address byte 2 */
 544         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE2 |
 545                 MCI_MODE_MEMORY_READ | ((address >> 16) & 0x3F);
 546         cx_write(MC417_RWD, regval);
 547         regval |= MC417_MICS | MC417_MIWR;
 548         cx_write(MC417_RWD, regval);
 549 
 550         /* Write address byte 1 */
 551         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE1 |
 552                 ((address >> 8) & 0xFF);
 553         cx_write(MC417_RWD, regval);
 554         regval |= MC417_MICS | MC417_MIWR;
 555         cx_write(MC417_RWD, regval);
 556 
 557         /* Write address byte 0 */
 558         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE0 |
 559                 (address & 0xFF);
 560         cx_write(MC417_RWD, regval);
 561         regval |= MC417_MICS | MC417_MIWR;
 562         cx_write(MC417_RWD, regval);
 563 
 564         /* Wait for the trans to complete (MC417_MIRDY asserted). */
 565         retval = mc417_wait_ready(dev);
 566 
 567         /* switch the DAT0-7 GPIO[10:3] to input mode */
 568         cx_write(MC417_OEN, MC417_MIRDY | MC417_MIDATA);
 569 
 570         /* Read data byte 3 */
 571         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE3;
 572         cx_write(MC417_RWD, regval);
 573 
 574         /* Transition RD to effect read transaction across bus. */
 575         regval = MC417_MIWR | MC417_MIRDY | MCI_MEMORY_DATA_BYTE3;
 576         cx_write(MC417_RWD, regval);
 577 
 578         /* Collect byte */
 579         tempval = cx_read(MC417_RWD);
 580         dataval = ((tempval & 0x000000FF) << 24);
 581 
 582         /* Bring CS and RD high. */
 583         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
 584         cx_write(MC417_RWD, regval);
 585 
 586         /* Read data byte 2 */
 587         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE2;
 588         cx_write(MC417_RWD, regval);
 589         regval = MC417_MIWR | MC417_MIRDY | MCI_MEMORY_DATA_BYTE2;
 590         cx_write(MC417_RWD, regval);
 591         tempval = cx_read(MC417_RWD);
 592         dataval |= ((tempval & 0x000000FF) << 16);
 593         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
 594         cx_write(MC417_RWD, regval);
 595 
 596         /* Read data byte 1 */
 597         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE1;
 598         cx_write(MC417_RWD, regval);
 599         regval = MC417_MIWR | MC417_MIRDY | MCI_MEMORY_DATA_BYTE1;
 600         cx_write(MC417_RWD, regval);
 601         tempval = cx_read(MC417_RWD);
 602         dataval |= ((tempval & 0x000000FF) << 8);
 603         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
 604         cx_write(MC417_RWD, regval);
 605 
 606         /* Read data byte 0 */
 607         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE0;
 608         cx_write(MC417_RWD, regval);
 609         regval = MC417_MIWR | MC417_MIRDY | MCI_MEMORY_DATA_BYTE0;
 610         cx_write(MC417_RWD, regval);
 611         tempval = cx_read(MC417_RWD);
 612         dataval |= (tempval & 0x000000FF);
 613         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
 614         cx_write(MC417_RWD, regval);
 615 
 616         *value  = dataval;
 617 
 618         return retval;
 619 }
 620 
 621 void mc417_gpio_set(struct cx23885_dev *dev, u32 mask)
 622 {
 623         u32 val;
 624 
 625         /* Set the gpio value */
 626         mc417_register_read(dev, 0x900C, &val);
 627         val |= (mask & 0x000ffff);
 628         mc417_register_write(dev, 0x900C, val);
 629 }
 630 
 631 void mc417_gpio_clear(struct cx23885_dev *dev, u32 mask)
 632 {
 633         u32 val;
 634 
 635         /* Clear the gpio value */
 636         mc417_register_read(dev, 0x900C, &val);
 637         val &= ~(mask & 0x0000ffff);
 638         mc417_register_write(dev, 0x900C, val);
 639 }
 640 
 641 void mc417_gpio_enable(struct cx23885_dev *dev, u32 mask, int asoutput)
 642 {
 643         u32 val;
 644 
 645         /* Enable GPIO direction bits */
 646         mc417_register_read(dev, 0x9020, &val);
 647         if (asoutput)
 648                 val |= (mask & 0x0000ffff);
 649         else
 650                 val &= ~(mask & 0x0000ffff);
 651 
 652         mc417_register_write(dev, 0x9020, val);
 653 }
 654 /* ------------------------------------------------------------------ */
 655 
 656 /* MPEG encoder API */
 657 static char *cmd_to_str(int cmd)
 658 {
 659         switch (cmd) {
 660         case CX2341X_ENC_PING_FW:
 661                 return  "PING_FW";
 662         case CX2341X_ENC_START_CAPTURE:
 663                 return  "START_CAPTURE";
 664         case CX2341X_ENC_STOP_CAPTURE:
 665                 return  "STOP_CAPTURE";
 666         case CX2341X_ENC_SET_AUDIO_ID:
 667                 return  "SET_AUDIO_ID";
 668         case CX2341X_ENC_SET_VIDEO_ID:
 669                 return  "SET_VIDEO_ID";
 670         case CX2341X_ENC_SET_PCR_ID:
 671                 return  "SET_PCR_ID";
 672         case CX2341X_ENC_SET_FRAME_RATE:
 673                 return  "SET_FRAME_RATE";
 674         case CX2341X_ENC_SET_FRAME_SIZE:
 675                 return  "SET_FRAME_SIZE";
 676         case CX2341X_ENC_SET_BIT_RATE:
 677                 return  "SET_BIT_RATE";
 678         case CX2341X_ENC_SET_GOP_PROPERTIES:
 679                 return  "SET_GOP_PROPERTIES";
 680         case CX2341X_ENC_SET_ASPECT_RATIO:
 681                 return  "SET_ASPECT_RATIO";
 682         case CX2341X_ENC_SET_DNR_FILTER_MODE:
 683                 return  "SET_DNR_FILTER_MODE";
 684         case CX2341X_ENC_SET_DNR_FILTER_PROPS:
 685                 return  "SET_DNR_FILTER_PROPS";
 686         case CX2341X_ENC_SET_CORING_LEVELS:
 687                 return  "SET_CORING_LEVELS";
 688         case CX2341X_ENC_SET_SPATIAL_FILTER_TYPE:
 689                 return  "SET_SPATIAL_FILTER_TYPE";
 690         case CX2341X_ENC_SET_VBI_LINE:
 691                 return  "SET_VBI_LINE";
 692         case CX2341X_ENC_SET_STREAM_TYPE:
 693                 return  "SET_STREAM_TYPE";
 694         case CX2341X_ENC_SET_OUTPUT_PORT:
 695                 return  "SET_OUTPUT_PORT";
 696         case CX2341X_ENC_SET_AUDIO_PROPERTIES:
 697                 return  "SET_AUDIO_PROPERTIES";
 698         case CX2341X_ENC_HALT_FW:
 699                 return  "HALT_FW";
 700         case CX2341X_ENC_GET_VERSION:
 701                 return  "GET_VERSION";
 702         case CX2341X_ENC_SET_GOP_CLOSURE:
 703                 return  "SET_GOP_CLOSURE";
 704         case CX2341X_ENC_GET_SEQ_END:
 705                 return  "GET_SEQ_END";
 706         case CX2341X_ENC_SET_PGM_INDEX_INFO:
 707                 return  "SET_PGM_INDEX_INFO";
 708         case CX2341X_ENC_SET_VBI_CONFIG:
 709                 return  "SET_VBI_CONFIG";
 710         case CX2341X_ENC_SET_DMA_BLOCK_SIZE:
 711                 return  "SET_DMA_BLOCK_SIZE";
 712         case CX2341X_ENC_GET_PREV_DMA_INFO_MB_10:
 713                 return  "GET_PREV_DMA_INFO_MB_10";
 714         case CX2341X_ENC_GET_PREV_DMA_INFO_MB_9:
 715                 return  "GET_PREV_DMA_INFO_MB_9";
 716         case CX2341X_ENC_SCHED_DMA_TO_HOST:
 717                 return  "SCHED_DMA_TO_HOST";
 718         case CX2341X_ENC_INITIALIZE_INPUT:
 719                 return  "INITIALIZE_INPUT";
 720         case CX2341X_ENC_SET_FRAME_DROP_RATE:
 721                 return  "SET_FRAME_DROP_RATE";
 722         case CX2341X_ENC_PAUSE_ENCODER:
 723                 return  "PAUSE_ENCODER";
 724         case CX2341X_ENC_REFRESH_INPUT:
 725                 return  "REFRESH_INPUT";
 726         case CX2341X_ENC_SET_COPYRIGHT:
 727                 return  "SET_COPYRIGHT";
 728         case CX2341X_ENC_SET_EVENT_NOTIFICATION:
 729                 return  "SET_EVENT_NOTIFICATION";
 730         case CX2341X_ENC_SET_NUM_VSYNC_LINES:
 731                 return  "SET_NUM_VSYNC_LINES";
 732         case CX2341X_ENC_SET_PLACEHOLDER:
 733                 return  "SET_PLACEHOLDER";
 734         case CX2341X_ENC_MUTE_VIDEO:
 735                 return  "MUTE_VIDEO";
 736         case CX2341X_ENC_MUTE_AUDIO:
 737                 return  "MUTE_AUDIO";
 738         case CX2341X_ENC_MISC:
 739                 return  "MISC";
 740         default:
 741                 return "UNKNOWN";
 742         }
 743 }
 744 
 745 static int cx23885_mbox_func(void *priv,
 746                              u32 command,
 747                              int in,
 748                              int out,
 749                              u32 data[CX2341X_MBOX_MAX_DATA])
 750 {
 751         struct cx23885_dev *dev = priv;
 752         unsigned long timeout;
 753         u32 value, flag, retval = 0;
 754         int i;
 755 
 756         dprintk(3, "%s: command(0x%X) = %s\n", __func__, command,
 757                 cmd_to_str(command));
 758 
 759         /* this may not be 100% safe if we can't read any memory location
 760            without side effects */
 761         mc417_memory_read(dev, dev->cx23417_mailbox - 4, &value);
 762         if (value != 0x12345678) {
 763                 pr_err("Firmware and/or mailbox pointer not initialized or corrupted, signature = 0x%x, cmd = %s\n",
 764                         value, cmd_to_str(command));
 765                 return -1;
 766         }
 767 
 768         /* This read looks at 32 bits, but flag is only 8 bits.
 769          * Seems we also bail if CMD or TIMEOUT bytes are set???
 770          */
 771         mc417_memory_read(dev, dev->cx23417_mailbox, &flag);
 772         if (flag) {
 773                 pr_err("ERROR: Mailbox appears to be in use (%x), cmd = %s\n",
 774                        flag, cmd_to_str(command));
 775                 return -1;
 776         }
 777 
 778         flag |= 1; /* tell 'em we're working on it */
 779         mc417_memory_write(dev, dev->cx23417_mailbox, flag);
 780 
 781         /* write command + args + fill remaining with zeros */
 782         /* command code */
 783         mc417_memory_write(dev, dev->cx23417_mailbox + 1, command);
 784         mc417_memory_write(dev, dev->cx23417_mailbox + 3,
 785                 IVTV_API_STD_TIMEOUT); /* timeout */
 786         for (i = 0; i < in; i++) {
 787                 mc417_memory_write(dev, dev->cx23417_mailbox + 4 + i, data[i]);
 788                 dprintk(3, "API Input %d = %d\n", i, data[i]);
 789         }
 790         for (; i < CX2341X_MBOX_MAX_DATA; i++)
 791                 mc417_memory_write(dev, dev->cx23417_mailbox + 4 + i, 0);
 792 
 793         flag |= 3; /* tell 'em we're done writing */
 794         mc417_memory_write(dev, dev->cx23417_mailbox, flag);
 795 
 796         /* wait for firmware to handle the API command */
 797         timeout = jiffies + msecs_to_jiffies(10);
 798         for (;;) {
 799                 mc417_memory_read(dev, dev->cx23417_mailbox, &flag);
 800                 if (0 != (flag & 4))
 801                         break;
 802                 if (time_after(jiffies, timeout)) {
 803                         pr_err("ERROR: API Mailbox timeout\n");
 804                         return -1;
 805                 }
 806                 udelay(10);
 807         }
 808 
 809         /* read output values */
 810         for (i = 0; i < out; i++) {
 811                 mc417_memory_read(dev, dev->cx23417_mailbox + 4 + i, data + i);
 812                 dprintk(3, "API Output %d = %d\n", i, data[i]);
 813         }
 814 
 815         mc417_memory_read(dev, dev->cx23417_mailbox + 2, &retval);
 816         dprintk(3, "API result = %d\n", retval);
 817 
 818         flag = 0;
 819         mc417_memory_write(dev, dev->cx23417_mailbox, flag);
 820 
 821         return retval;
 822 }
 823 
 824 /* We don't need to call the API often, so using just one
 825  * mailbox will probably suffice
 826  */
 827 static int cx23885_api_cmd(struct cx23885_dev *dev,
 828                            u32 command,
 829                            u32 inputcnt,
 830                            u32 outputcnt,
 831                            ...)
 832 {
 833         u32 data[CX2341X_MBOX_MAX_DATA];
 834         va_list vargs;
 835         int i, err;
 836 
 837         dprintk(3, "%s() cmds = 0x%08x\n", __func__, command);
 838 
 839         va_start(vargs, outputcnt);
 840         for (i = 0; i < inputcnt; i++)
 841                 data[i] = va_arg(vargs, int);
 842 
 843         err = cx23885_mbox_func(dev, command, inputcnt, outputcnt, data);
 844         for (i = 0; i < outputcnt; i++) {
 845                 int *vptr = va_arg(vargs, int *);
 846                 *vptr = data[i];
 847         }
 848         va_end(vargs);
 849 
 850         return err;
 851 }
 852 
 853 static int cx23885_api_func(void *priv, u32 cmd, int in, int out, u32 data[CX2341X_MBOX_MAX_DATA])
 854 {
 855         return cx23885_mbox_func(priv, cmd, in, out, data);
 856 }
 857 
 858 static int cx23885_find_mailbox(struct cx23885_dev *dev)
 859 {
 860         u32 signature[4] = {
 861                 0x12345678, 0x34567812, 0x56781234, 0x78123456
 862         };
 863         int signaturecnt = 0;
 864         u32 value;
 865         int i;
 866 
 867         dprintk(2, "%s()\n", __func__);
 868 
 869         for (i = 0; i < CX23885_FIRM_IMAGE_SIZE; i++) {
 870                 mc417_memory_read(dev, i, &value);
 871                 if (value == signature[signaturecnt])
 872                         signaturecnt++;
 873                 else
 874                         signaturecnt = 0;
 875                 if (4 == signaturecnt) {
 876                         dprintk(1, "Mailbox signature found at 0x%x\n", i+1);
 877                         return i+1;
 878                 }
 879         }
 880         pr_err("Mailbox signature values not found!\n");
 881         return -1;
 882 }
 883 
 884 static int cx23885_load_firmware(struct cx23885_dev *dev)
 885 {
 886         static const unsigned char magic[8] = {
 887                 0xa7, 0x0d, 0x00, 0x00, 0x66, 0xbb, 0x55, 0xaa
 888         };
 889         const struct firmware *firmware;
 890         int i, retval = 0;
 891         u32 value = 0;
 892         u32 gpio_output = 0;
 893         u32 gpio_value;
 894         u32 checksum = 0;
 895         u32 *dataptr;
 896 
 897         dprintk(2, "%s()\n", __func__);
 898 
 899         /* Save GPIO settings before reset of APU */
 900         retval |= mc417_memory_read(dev, 0x9020, &gpio_output);
 901         retval |= mc417_memory_read(dev, 0x900C, &gpio_value);
 902 
 903         retval  = mc417_register_write(dev,
 904                 IVTV_REG_VPU, 0xFFFFFFED);
 905         retval |= mc417_register_write(dev,
 906                 IVTV_REG_HW_BLOCKS, IVTV_CMD_HW_BLOCKS_RST);
 907         retval |= mc417_register_write(dev,
 908                 IVTV_REG_ENC_SDRAM_REFRESH, 0x80000800);
 909         retval |= mc417_register_write(dev,
 910                 IVTV_REG_ENC_SDRAM_PRECHARGE, 0x1A);
 911         retval |= mc417_register_write(dev,
 912                 IVTV_REG_APU, 0);
 913 
 914         if (retval != 0) {
 915                 pr_err("%s: Error with mc417_register_write\n",
 916                         __func__);
 917                 return -1;
 918         }
 919 
 920         retval = request_firmware(&firmware, CX23885_FIRM_IMAGE_NAME,
 921                                   &dev->pci->dev);
 922 
 923         if (retval != 0) {
 924                 pr_err("ERROR: Hotplug firmware request failed (%s).\n",
 925                        CX23885_FIRM_IMAGE_NAME);
 926                 pr_err("Please fix your hotplug setup, the board will not work without firmware loaded!\n");
 927                 return -1;
 928         }
 929 
 930         if (firmware->size != CX23885_FIRM_IMAGE_SIZE) {
 931                 pr_err("ERROR: Firmware size mismatch (have %zu, expected %d)\n",
 932                        firmware->size, CX23885_FIRM_IMAGE_SIZE);
 933                 release_firmware(firmware);
 934                 return -1;
 935         }
 936 
 937         if (0 != memcmp(firmware->data, magic, 8)) {
 938                 pr_err("ERROR: Firmware magic mismatch, wrong file?\n");
 939                 release_firmware(firmware);
 940                 return -1;
 941         }
 942 
 943         /* transfer to the chip */
 944         dprintk(2, "Loading firmware ...\n");
 945         dataptr = (u32 *)firmware->data;
 946         for (i = 0; i < (firmware->size >> 2); i++) {
 947                 value = *dataptr;
 948                 checksum += ~value;
 949                 if (mc417_memory_write(dev, i, value) != 0) {
 950                         pr_err("ERROR: Loading firmware failed!\n");
 951                         release_firmware(firmware);
 952                         return -1;
 953                 }
 954                 dataptr++;
 955         }
 956 
 957         /* read back to verify with the checksum */
 958         dprintk(1, "Verifying firmware ...\n");
 959         for (i--; i >= 0; i--) {
 960                 if (mc417_memory_read(dev, i, &value) != 0) {
 961                         pr_err("ERROR: Reading firmware failed!\n");
 962                         release_firmware(firmware);
 963                         return -1;
 964                 }
 965                 checksum -= ~value;
 966         }
 967         if (checksum) {
 968                 pr_err("ERROR: Firmware load failed (checksum mismatch).\n");
 969                 release_firmware(firmware);
 970                 return -1;
 971         }
 972         release_firmware(firmware);
 973         dprintk(1, "Firmware upload successful.\n");
 974 
 975         retval |= mc417_register_write(dev, IVTV_REG_HW_BLOCKS,
 976                 IVTV_CMD_HW_BLOCKS_RST);
 977 
 978         /* F/W power up disturbs the GPIOs, restore state */
 979         retval |= mc417_register_write(dev, 0x9020, gpio_output);
 980         retval |= mc417_register_write(dev, 0x900C, gpio_value);
 981 
 982         retval |= mc417_register_read(dev, IVTV_REG_VPU, &value);
 983         retval |= mc417_register_write(dev, IVTV_REG_VPU, value & 0xFFFFFFE8);
 984 
 985         /* Hardcoded GPIO's here */
 986         retval |= mc417_register_write(dev, 0x9020, 0x4000);
 987         retval |= mc417_register_write(dev, 0x900C, 0x4000);
 988 
 989         mc417_register_read(dev, 0x9020, &gpio_output);
 990         mc417_register_read(dev, 0x900C, &gpio_value);
 991 
 992         if (retval < 0)
 993                 pr_err("%s: Error with mc417_register_write\n",
 994                         __func__);
 995         return 0;
 996 }
 997 
 998 void cx23885_417_check_encoder(struct cx23885_dev *dev)
 999 {
1000         u32 status, seq;
1001 
1002         status = seq = 0;
1003         cx23885_api_cmd(dev, CX2341X_ENC_GET_SEQ_END, 0, 2, &status, &seq);
1004         dprintk(1, "%s() status = %d, seq = %d\n", __func__, status, seq);
1005 }
1006 
1007 static void cx23885_codec_settings(struct cx23885_dev *dev)
1008 {
1009         dprintk(1, "%s()\n", __func__);
1010 
1011         /* Dynamically change the height based on video standard */
1012         if (dev->encodernorm.id & V4L2_STD_525_60)
1013                 dev->ts1.height = 480;
1014         else
1015                 dev->ts1.height = 576;
1016 
1017         /* assign frame size */
1018         cx23885_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0,
1019                                 dev->ts1.height, dev->ts1.width);
1020 
1021         dev->cxhdl.width = dev->ts1.width;
1022         dev->cxhdl.height = dev->ts1.height;
1023         dev->cxhdl.is_50hz =
1024                 (dev->encodernorm.id & V4L2_STD_625_50) != 0;
1025 
1026         cx2341x_handler_setup(&dev->cxhdl);
1027 
1028         cx23885_api_cmd(dev, CX2341X_ENC_MISC, 2, 0, 3, 1);
1029         cx23885_api_cmd(dev, CX2341X_ENC_MISC, 2, 0, 4, 1);
1030 }
1031 
1032 static int cx23885_initialize_codec(struct cx23885_dev *dev, int startencoder)
1033 {
1034         int version;
1035         int retval;
1036         u32 i, data[7];
1037 
1038         dprintk(1, "%s()\n", __func__);
1039 
1040         retval = cx23885_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
1041         if (retval < 0) {
1042                 dprintk(2, "%s() PING OK\n", __func__);
1043                 retval = cx23885_load_firmware(dev);
1044                 if (retval < 0) {
1045                         pr_err("%s() f/w load failed\n", __func__);
1046                         return retval;
1047                 }
1048                 retval = cx23885_find_mailbox(dev);
1049                 if (retval < 0) {
1050                         pr_err("%s() mailbox < 0, error\n",
1051                                 __func__);
1052                         return -1;
1053                 }
1054                 dev->cx23417_mailbox = retval;
1055                 retval = cx23885_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0);
1056                 if (retval < 0) {
1057                         pr_err("ERROR: cx23417 firmware ping failed!\n");
1058                         return -1;
1059                 }
1060                 retval = cx23885_api_cmd(dev, CX2341X_ENC_GET_VERSION, 0, 1,
1061                         &version);
1062                 if (retval < 0) {
1063                         pr_err("ERROR: cx23417 firmware get encoder :version failed!\n");
1064                         return -1;
1065                 }
1066                 dprintk(1, "cx23417 firmware version is 0x%08x\n", version);
1067                 msleep(200);
1068         }
1069 
1070         cx23885_codec_settings(dev);
1071         msleep(60);
1072 
1073         cx23885_api_cmd(dev, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, 0,
1074                 CX23885_FIELD1_SAA7115, CX23885_FIELD2_SAA7115);
1075         cx23885_api_cmd(dev, CX2341X_ENC_SET_PLACEHOLDER, 12, 0,
1076                 CX23885_CUSTOM_EXTENSION_USR_DATA, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1077                 0, 0);
1078 
1079         /* Setup to capture VBI */
1080         data[0] = 0x0001BD00;
1081         data[1] = 1;          /* frames per interrupt */
1082         data[2] = 4;          /* total bufs */
1083         data[3] = 0x91559155; /* start codes */
1084         data[4] = 0x206080C0; /* stop codes */
1085         data[5] = 6;          /* lines */
1086         data[6] = 64;         /* BPL */
1087 
1088         cx23885_api_cmd(dev, CX2341X_ENC_SET_VBI_CONFIG, 7, 0, data[0], data[1],
1089                 data[2], data[3], data[4], data[5], data[6]);
1090 
1091         for (i = 2; i <= 24; i++) {
1092                 int valid;
1093 
1094                 valid = ((i >= 19) && (i <= 21));
1095                 cx23885_api_cmd(dev, CX2341X_ENC_SET_VBI_LINE, 5, 0, i,
1096                                 valid, 0 , 0, 0);
1097                 cx23885_api_cmd(dev, CX2341X_ENC_SET_VBI_LINE, 5, 0,
1098                                 i | 0x80000000, valid, 0, 0, 0);
1099         }
1100 
1101         cx23885_api_cmd(dev, CX2341X_ENC_MUTE_AUDIO, 1, 0, CX23885_UNMUTE);
1102         msleep(60);
1103 
1104         /* initialize the video input */
1105         cx23885_api_cmd(dev, CX2341X_ENC_INITIALIZE_INPUT, 0, 0);
1106         msleep(60);
1107 
1108         /* Enable VIP style pixel invalidation so we work with scaled mode */
1109         mc417_memory_write(dev, 2120, 0x00000080);
1110 
1111         /* start capturing to the host interface */
1112         if (startencoder) {
1113                 cx23885_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0,
1114                         CX23885_MPEG_CAPTURE, CX23885_RAW_BITS_NONE);
1115                 msleep(10);
1116         }
1117 
1118         return 0;
1119 }
1120 
1121 /* ------------------------------------------------------------------ */
1122 
1123 static int queue_setup(struct vb2_queue *q,
1124                            unsigned int *num_buffers, unsigned int *num_planes,
1125                            unsigned int sizes[], struct device *alloc_devs[])
1126 {
1127         struct cx23885_dev *dev = q->drv_priv;
1128 
1129         dev->ts1.ts_packet_size  = mpeglinesize;
1130         dev->ts1.ts_packet_count = mpeglines;
1131         *num_planes = 1;
1132         sizes[0] = mpeglinesize * mpeglines;
1133         *num_buffers = mpegbufs;
1134         return 0;
1135 }
1136 
1137 static int buffer_prepare(struct vb2_buffer *vb)
1138 {
1139         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1140         struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
1141         struct cx23885_buffer *buf =
1142                 container_of(vbuf, struct cx23885_buffer, vb);
1143 
1144         return cx23885_buf_prepare(buf, &dev->ts1);
1145 }
1146 
1147 static void buffer_finish(struct vb2_buffer *vb)
1148 {
1149         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1150         struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
1151         struct cx23885_buffer *buf = container_of(vbuf,
1152                 struct cx23885_buffer, vb);
1153 
1154         cx23885_free_buffer(dev, buf);
1155 }
1156 
1157 static void buffer_queue(struct vb2_buffer *vb)
1158 {
1159         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1160         struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
1161         struct cx23885_buffer   *buf = container_of(vbuf,
1162                 struct cx23885_buffer, vb);
1163 
1164         cx23885_buf_queue(&dev->ts1, buf);
1165 }
1166 
1167 static int cx23885_start_streaming(struct vb2_queue *q, unsigned int count)
1168 {
1169         struct cx23885_dev *dev = q->drv_priv;
1170         struct cx23885_dmaqueue *dmaq = &dev->ts1.mpegq;
1171         unsigned long flags;
1172         int ret;
1173 
1174         ret = cx23885_initialize_codec(dev, 1);
1175         if (ret == 0) {
1176                 struct cx23885_buffer *buf = list_entry(dmaq->active.next,
1177                         struct cx23885_buffer, queue);
1178 
1179                 cx23885_start_dma(&dev->ts1, dmaq, buf);
1180                 return 0;
1181         }
1182         spin_lock_irqsave(&dev->slock, flags);
1183         while (!list_empty(&dmaq->active)) {
1184                 struct cx23885_buffer *buf = list_entry(dmaq->active.next,
1185                         struct cx23885_buffer, queue);
1186 
1187                 list_del(&buf->queue);
1188                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_QUEUED);
1189         }
1190         spin_unlock_irqrestore(&dev->slock, flags);
1191         return ret;
1192 }
1193 
1194 static void cx23885_stop_streaming(struct vb2_queue *q)
1195 {
1196         struct cx23885_dev *dev = q->drv_priv;
1197 
1198         /* stop mpeg capture */
1199         cx23885_api_cmd(dev, CX2341X_ENC_STOP_CAPTURE, 3, 0,
1200                         CX23885_END_NOW, CX23885_MPEG_CAPTURE,
1201                         CX23885_RAW_BITS_NONE);
1202 
1203         msleep(500);
1204         cx23885_417_check_encoder(dev);
1205         cx23885_cancel_buffers(&dev->ts1);
1206 }
1207 
1208 static const struct vb2_ops cx23885_qops = {
1209         .queue_setup    = queue_setup,
1210         .buf_prepare  = buffer_prepare,
1211         .buf_finish = buffer_finish,
1212         .buf_queue    = buffer_queue,
1213         .wait_prepare = vb2_ops_wait_prepare,
1214         .wait_finish = vb2_ops_wait_finish,
1215         .start_streaming = cx23885_start_streaming,
1216         .stop_streaming = cx23885_stop_streaming,
1217 };
1218 
1219 /* ------------------------------------------------------------------ */
1220 
1221 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
1222 {
1223         struct cx23885_dev *dev = video_drvdata(file);
1224 
1225         *id = dev->tvnorm;
1226         return 0;
1227 }
1228 
1229 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
1230 {
1231         struct cx23885_dev *dev = video_drvdata(file);
1232         unsigned int i;
1233         int ret;
1234 
1235         for (i = 0; i < ARRAY_SIZE(cx23885_tvnorms); i++)
1236                 if (id & cx23885_tvnorms[i].id)
1237                         break;
1238         if (i == ARRAY_SIZE(cx23885_tvnorms))
1239                 return -EINVAL;
1240 
1241         ret = cx23885_set_tvnorm(dev, id);
1242         if (!ret)
1243                 dev->encodernorm = cx23885_tvnorms[i];
1244         return ret;
1245 }
1246 
1247 static int vidioc_enum_input(struct file *file, void *priv,
1248         struct v4l2_input *i)
1249 {
1250         struct cx23885_dev *dev = video_drvdata(file);
1251         dprintk(1, "%s()\n", __func__);
1252         return cx23885_enum_input(dev, i);
1253 }
1254 
1255 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1256 {
1257         return cx23885_get_input(file, priv, i);
1258 }
1259 
1260 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1261 {
1262         return cx23885_set_input(file, priv, i);
1263 }
1264 
1265 static int vidioc_g_tuner(struct file *file, void *priv,
1266                                 struct v4l2_tuner *t)
1267 {
1268         struct cx23885_dev *dev = video_drvdata(file);
1269 
1270         if (dev->tuner_type == TUNER_ABSENT)
1271                 return -EINVAL;
1272         if (0 != t->index)
1273                 return -EINVAL;
1274         strscpy(t->name, "Television", sizeof(t->name));
1275         call_all(dev, tuner, g_tuner, t);
1276 
1277         dprintk(1, "VIDIOC_G_TUNER: tuner type %d\n", t->type);
1278 
1279         return 0;
1280 }
1281 
1282 static int vidioc_s_tuner(struct file *file, void *priv,
1283                                 const struct v4l2_tuner *t)
1284 {
1285         struct cx23885_dev *dev = video_drvdata(file);
1286 
1287         if (dev->tuner_type == TUNER_ABSENT)
1288                 return -EINVAL;
1289 
1290         /* Update the A/V core */
1291         call_all(dev, tuner, s_tuner, t);
1292 
1293         return 0;
1294 }
1295 
1296 static int vidioc_g_frequency(struct file *file, void *priv,
1297                                 struct v4l2_frequency *f)
1298 {
1299         struct cx23885_dev *dev = video_drvdata(file);
1300 
1301         if (dev->tuner_type == TUNER_ABSENT)
1302                 return -EINVAL;
1303         f->type = V4L2_TUNER_ANALOG_TV;
1304         f->frequency = dev->freq;
1305 
1306         call_all(dev, tuner, g_frequency, f);
1307 
1308         return 0;
1309 }
1310 
1311 static int vidioc_s_frequency(struct file *file, void *priv,
1312         const struct v4l2_frequency *f)
1313 {
1314         return cx23885_set_frequency(file, priv, f);
1315 }
1316 
1317 static int vidioc_querycap(struct file *file, void  *priv,
1318                                 struct v4l2_capability *cap)
1319 {
1320         struct cx23885_dev *dev = video_drvdata(file);
1321         struct cx23885_tsport  *tsport = &dev->ts1;
1322 
1323         strscpy(cap->driver, dev->name, sizeof(cap->driver));
1324         strscpy(cap->card, cx23885_boards[tsport->dev->board].name,
1325                 sizeof(cap->card));
1326         sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci));
1327         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1328                             V4L2_CAP_STREAMING | V4L2_CAP_VBI_CAPTURE |
1329                             V4L2_CAP_AUDIO | V4L2_CAP_DEVICE_CAPS;
1330         if (dev->tuner_type != TUNER_ABSENT)
1331                 cap->capabilities |= V4L2_CAP_TUNER;
1332 
1333         return 0;
1334 }
1335 
1336 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1337                                         struct v4l2_fmtdesc *f)
1338 {
1339         if (f->index != 0)
1340                 return -EINVAL;
1341 
1342         f->pixelformat = V4L2_PIX_FMT_MPEG;
1343 
1344         return 0;
1345 }
1346 
1347 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1348                                 struct v4l2_format *f)
1349 {
1350         struct cx23885_dev *dev = video_drvdata(file);
1351 
1352         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
1353         f->fmt.pix.bytesperline = 0;
1354         f->fmt.pix.sizeimage    =
1355                 dev->ts1.ts_packet_size * dev->ts1.ts_packet_count;
1356         f->fmt.pix.colorspace   = 0;
1357         f->fmt.pix.width        = dev->ts1.width;
1358         f->fmt.pix.height       = dev->ts1.height;
1359         f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
1360         dprintk(1, "VIDIOC_G_FMT: w: %d, h: %d\n",
1361                 dev->ts1.width, dev->ts1.height);
1362         return 0;
1363 }
1364 
1365 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1366                                 struct v4l2_format *f)
1367 {
1368         struct cx23885_dev *dev = video_drvdata(file);
1369 
1370         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
1371         f->fmt.pix.bytesperline = 0;
1372         f->fmt.pix.sizeimage    =
1373                 dev->ts1.ts_packet_size * dev->ts1.ts_packet_count;
1374         f->fmt.pix.colorspace   = 0;
1375         f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
1376         dprintk(1, "VIDIOC_TRY_FMT: w: %d, h: %d\n",
1377                 dev->ts1.width, dev->ts1.height);
1378         return 0;
1379 }
1380 
1381 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1382                                 struct v4l2_format *f)
1383 {
1384         struct cx23885_dev *dev = video_drvdata(file);
1385 
1386         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
1387         f->fmt.pix.bytesperline = 0;
1388         f->fmt.pix.sizeimage    =
1389                 dev->ts1.ts_packet_size * dev->ts1.ts_packet_count;
1390         f->fmt.pix.colorspace   = 0;
1391         f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
1392         dprintk(1, "VIDIOC_S_FMT: w: %d, h: %d, f: %d\n",
1393                 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
1394         return 0;
1395 }
1396 
1397 static int vidioc_log_status(struct file *file, void *priv)
1398 {
1399         struct cx23885_dev *dev = video_drvdata(file);
1400         char name[32 + 2];
1401 
1402         snprintf(name, sizeof(name), "%s/2", dev->name);
1403         call_all(dev, core, log_status);
1404         v4l2_ctrl_handler_log_status(&dev->cxhdl.hdl, name);
1405         return 0;
1406 }
1407 
1408 static const struct v4l2_file_operations mpeg_fops = {
1409         .owner         = THIS_MODULE,
1410         .open           = v4l2_fh_open,
1411         .release        = vb2_fop_release,
1412         .read           = vb2_fop_read,
1413         .poll           = vb2_fop_poll,
1414         .unlocked_ioctl = video_ioctl2,
1415         .mmap           = vb2_fop_mmap,
1416 };
1417 
1418 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
1419         .vidioc_g_std            = vidioc_g_std,
1420         .vidioc_s_std            = vidioc_s_std,
1421         .vidioc_enum_input       = vidioc_enum_input,
1422         .vidioc_g_input          = vidioc_g_input,
1423         .vidioc_s_input          = vidioc_s_input,
1424         .vidioc_g_tuner          = vidioc_g_tuner,
1425         .vidioc_s_tuner          = vidioc_s_tuner,
1426         .vidioc_g_frequency      = vidioc_g_frequency,
1427         .vidioc_s_frequency      = vidioc_s_frequency,
1428         .vidioc_querycap         = vidioc_querycap,
1429         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1430         .vidioc_g_fmt_vid_cap    = vidioc_g_fmt_vid_cap,
1431         .vidioc_try_fmt_vid_cap  = vidioc_try_fmt_vid_cap,
1432         .vidioc_s_fmt_vid_cap    = vidioc_s_fmt_vid_cap,
1433         .vidioc_reqbufs       = vb2_ioctl_reqbufs,
1434         .vidioc_prepare_buf   = vb2_ioctl_prepare_buf,
1435         .vidioc_querybuf      = vb2_ioctl_querybuf,
1436         .vidioc_qbuf          = vb2_ioctl_qbuf,
1437         .vidioc_dqbuf         = vb2_ioctl_dqbuf,
1438         .vidioc_streamon      = vb2_ioctl_streamon,
1439         .vidioc_streamoff     = vb2_ioctl_streamoff,
1440         .vidioc_log_status       = vidioc_log_status,
1441 #ifdef CONFIG_VIDEO_ADV_DEBUG
1442         .vidioc_g_chip_info      = cx23885_g_chip_info,
1443         .vidioc_g_register       = cx23885_g_register,
1444         .vidioc_s_register       = cx23885_s_register,
1445 #endif
1446 };
1447 
1448 static struct video_device cx23885_mpeg_template = {
1449         .name          = "cx23885",
1450         .fops          = &mpeg_fops,
1451         .ioctl_ops     = &mpeg_ioctl_ops,
1452         .tvnorms       = CX23885_NORMS,
1453 };
1454 
1455 void cx23885_417_unregister(struct cx23885_dev *dev)
1456 {
1457         dprintk(1, "%s()\n", __func__);
1458 
1459         if (dev->v4l_device) {
1460                 if (video_is_registered(dev->v4l_device))
1461                         video_unregister_device(dev->v4l_device);
1462                 else
1463                         video_device_release(dev->v4l_device);
1464                 v4l2_ctrl_handler_free(&dev->cxhdl.hdl);
1465                 dev->v4l_device = NULL;
1466         }
1467 }
1468 
1469 static struct video_device *cx23885_video_dev_alloc(
1470         struct cx23885_tsport *tsport,
1471         struct pci_dev *pci,
1472         struct video_device *template,
1473         char *type)
1474 {
1475         struct video_device *vfd;
1476         struct cx23885_dev *dev = tsport->dev;
1477 
1478         dprintk(1, "%s()\n", __func__);
1479 
1480         vfd = video_device_alloc();
1481         if (NULL == vfd)
1482                 return NULL;
1483         *vfd = *template;
1484         snprintf(vfd->name, sizeof(vfd->name), "%s (%s)",
1485                 cx23885_boards[tsport->dev->board].name, type);
1486         vfd->v4l2_dev = &dev->v4l2_dev;
1487         vfd->release = video_device_release;
1488         return vfd;
1489 }
1490 
1491 int cx23885_417_register(struct cx23885_dev *dev)
1492 {
1493         /* FIXME: Port1 hardcoded here */
1494         int err = -ENODEV;
1495         struct cx23885_tsport *tsport = &dev->ts1;
1496         struct vb2_queue *q;
1497 
1498         dprintk(1, "%s()\n", __func__);
1499 
1500         if (cx23885_boards[dev->board].portb != CX23885_MPEG_ENCODER)
1501                 return err;
1502 
1503         /* Set default TV standard */
1504         dev->encodernorm = cx23885_tvnorms[0];
1505 
1506         if (dev->encodernorm.id & V4L2_STD_525_60)
1507                 tsport->height = 480;
1508         else
1509                 tsport->height = 576;
1510 
1511         tsport->width = 720;
1512         dev->cxhdl.port = CX2341X_PORT_SERIAL;
1513         err = cx2341x_handler_init(&dev->cxhdl, 50);
1514         if (err)
1515                 return err;
1516         dev->cxhdl.priv = dev;
1517         dev->cxhdl.func = cx23885_api_func;
1518         cx2341x_handler_set_50hz(&dev->cxhdl, tsport->height == 576);
1519         v4l2_ctrl_add_handler(&dev->ctrl_handler, &dev->cxhdl.hdl, NULL, false);
1520 
1521         /* Allocate and initialize V4L video device */
1522         dev->v4l_device = cx23885_video_dev_alloc(tsport,
1523                 dev->pci, &cx23885_mpeg_template, "mpeg");
1524         q = &dev->vb2_mpegq;
1525         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1526         q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1527         q->gfp_flags = GFP_DMA32;
1528         q->min_buffers_needed = 2;
1529         q->drv_priv = dev;
1530         q->buf_struct_size = sizeof(struct cx23885_buffer);
1531         q->ops = &cx23885_qops;
1532         q->mem_ops = &vb2_dma_sg_memops;
1533         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1534         q->lock = &dev->lock;
1535         q->dev = &dev->pci->dev;
1536 
1537         err = vb2_queue_init(q);
1538         if (err < 0)
1539                 return err;
1540         video_set_drvdata(dev->v4l_device, dev);
1541         dev->v4l_device->lock = &dev->lock;
1542         dev->v4l_device->queue = q;
1543         dev->v4l_device->device_caps = V4L2_CAP_VIDEO_CAPTURE |
1544                                        V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
1545         if (dev->tuner_type != TUNER_ABSENT)
1546                 dev->v4l_device->device_caps |= V4L2_CAP_TUNER;
1547         err = video_register_device(dev->v4l_device,
1548                 VFL_TYPE_GRABBER, -1);
1549         if (err < 0) {
1550                 pr_info("%s: can't register mpeg device\n", dev->name);
1551                 return err;
1552         }
1553 
1554         pr_info("%s: registered device %s [mpeg]\n",
1555                dev->name, video_device_node_name(dev->v4l_device));
1556 
1557         /* ST: Configure the encoder parameters, but don't begin
1558          * encoding, this resolves an issue where the first time the
1559          * encoder is started video can be choppy.
1560          */
1561         cx23885_initialize_codec(dev, 0);
1562 
1563         return 0;
1564 }
1565 
1566 MODULE_FIRMWARE(CX23885_FIRM_IMAGE_NAME);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/media/pci/cx23885/cx23885-417.c

DEFINITIONS
