1 files changed, 191 insertions, 78 deletions

diff --git a/drivers/media/video/pvrusb2/pvrusb2-encoder.c b/drivers/media/video/pvrusb2/pvrusb2-encoder.c
index c94f97b79392..5786faf9b3b8 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-encoder.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-encoder.c
@@ -26,6 +26,7 @@
 #include "pvrusb2-encoder.h"
 #include "pvrusb2-hdw-internal.h"
 #include "pvrusb2-debug.h"
+#include "pvrusb2-fx2-cmd.h"
 
 
 
@@ -34,34 +35,41 @@
 #define IVTV_MBOX_DRIVER_DONE 0x00000002
 #define IVTV_MBOX_DRIVER_BUSY 0x00000001
 
+#define MBOX_BASE 0x44
+
 
 static int pvr2_encoder_write_words(struct pvr2_hdw *hdw,
+                                    unsigned int offs,
                                     const u32 *data, unsigned int dlen)
 {
-        unsigned int idx;
+        unsigned int idx,addr;
+        unsigned int bAddr;
         int ret;
-        unsigned int offs = 0;
         unsigned int chunkCnt;
 
         /*
 
         Format: First byte must be 0x01.  Remaining 32 bit words are
-        spread out into chunks of 7 bytes each, little-endian ordered,
-        offset at zero within each 2 blank bytes following and a
-        single byte that is 0x44 plus the offset of the word.  Repeat
-        request for additional words, with offset adjusted
-        accordingly.
+        spread out into chunks of 7 bytes each, with the first 4 bytes
+        being the data word (little endian), and the next 3 bytes
+        being the address where that data word is to be written (big
+        endian).  Repeat request for additional words, with offset
+        adjusted accordingly.
 
         */
         while (dlen) {
                 chunkCnt = 8;
                 if (chunkCnt > dlen) chunkCnt = dlen;
                 memset(hdw->cmd_buffer,0,sizeof(hdw->cmd_buffer));
-                hdw->cmd_buffer[0] = 0x01;
+                bAddr = 0;
+                hdw->cmd_buffer[bAddr++] = FX2CMD_MEM_WRITE_DWORD;
                 for (idx = 0; idx < chunkCnt; idx++) {
-                        hdw->cmd_buffer[1+(idx*7)+6] = 0x44 + idx + offs;
-                        PVR2_DECOMPOSE_LE(hdw->cmd_buffer, 1+(idx*7),
-                                          data[idx]);
+                        addr = idx + offs;
+                        hdw->cmd_buffer[bAddr+6] = (addr & 0xffu);
+                        hdw->cmd_buffer[bAddr+5] = ((addr>>8) & 0xffu);
+                        hdw->cmd_buffer[bAddr+4] = ((addr>>16) & 0xffu);
+                        PVR2_DECOMPOSE_LE(hdw->cmd_buffer, bAddr,data[idx]);
+                        bAddr += 7;
                 }
                 ret = pvr2_send_request(hdw,
                                         hdw->cmd_buffer,1+(chunkCnt*7),
@@ -76,33 +84,42 @@ static int pvr2_encoder_write_words(struct pvr2_hdw *hdw,
 }
 
 
-static int pvr2_encoder_read_words(struct pvr2_hdw *hdw,int statusFl,
+static int pvr2_encoder_read_words(struct pvr2_hdw *hdw,
+                                   unsigned int offs,
                                    u32 *data, unsigned int dlen)
 {
         unsigned int idx;
         int ret;
-        unsigned int offs = 0;
         unsigned int chunkCnt;
 
         /*
 
         Format: First byte must be 0x02 (status check) or 0x28 (read
         back block of 32 bit words).  Next 6 bytes must be zero,
-        followed by a single byte of 0x44+offset for portion to be
-        read.  Returned data is packed set of 32 bits words that were
-        read.
+        followed by a single byte of MBOX_BASE+offset for portion to
+        be read.  Returned data is packed set of 32 bits words that
+        were read.
 
         */
 
         while (dlen) {
                 chunkCnt = 16;
                 if (chunkCnt > dlen) chunkCnt = dlen;
-                memset(hdw->cmd_buffer,0,sizeof(hdw->cmd_buffer));
-                hdw->cmd_buffer[0] = statusFl ? 0x02 : 0x28;
-                hdw->cmd_buffer[7] = 0x44 + offs;
+                if (chunkCnt < 16) chunkCnt = 1;
+                hdw->cmd_buffer[0] =
+                        ((chunkCnt == 1) ?
+                         FX2CMD_MEM_READ_DWORD : FX2CMD_MEM_READ_64BYTES);
+                hdw->cmd_buffer[1] = 0;
+                hdw->cmd_buffer[2] = 0;
+                hdw->cmd_buffer[3] = 0;
+                hdw->cmd_buffer[4] = 0;
+                hdw->cmd_buffer[5] = ((offs>>16) & 0xffu);
+                hdw->cmd_buffer[6] = ((offs>>8) & 0xffu);
+                hdw->cmd_buffer[7] = (offs & 0xffu);
                 ret = pvr2_send_request(hdw,
                                         hdw->cmd_buffer,8,
-                                        hdw->cmd_buffer,chunkCnt * 4);
+                                        hdw->cmd_buffer,
+                                        (chunkCnt == 1 ? 4 : 16 * 4));
                 if (ret) return ret;
 
                 for (idx = 0; idx < chunkCnt; idx++) {
@@ -129,6 +146,8 @@ static int pvr2_encoder_cmd(void *ctxt,
                             u32 *argp)
 {
         unsigned int poll_count;
+        unsigned int try_count = 0;
+        int retry_flag;
         int ret = 0;
         unsigned int idx;
         /* These sizes look to be limited by the FX2 firmware implementation */
@@ -140,14 +159,15 @@ static int pvr2_encoder_cmd(void *ctxt,
         /*
 
         The encoder seems to speak entirely using blocks 32 bit words.
-        In ivtv driver terms, this is a mailbox which we populate with
-        data and watch what the hardware does with it.  The first word
-        is a set of flags used to control the transaction, the second
-        word is the command to execute, the third byte is zero (ivtv
-        driver suggests that this is some kind of return value), and
-        the fourth byte is a specified timeout (windows driver always
-        uses 0x00060000 except for one case when it is zero).  All
-        successive words are the argument words for the command.
+        In ivtv driver terms, this is a mailbox at MBOX_BASE which we
+        populate with data and watch what the hardware does with it.
+        The first word is a set of flags used to control the
+        transaction, the second word is the command to execute, the
+        third byte is zero (ivtv driver suggests that this is some
+        kind of return value), and the fourth byte is a specified
+        timeout (windows driver always uses 0x00060000 except for one
+        case when it is zero).  All successive words are the argument
+        words for the command.
 
         First, write out the entire set of words, with the first word
         being zero.
@@ -156,44 +176,42 @@ static int pvr2_encoder_cmd(void *ctxt,
         IVTV_MBOX_DRIVER_DONE | IVTV_DRIVER_BUSY this time (which
         probably means "go").
 
-        Next, read back 16 words as status.  Check the first word,
+        Next, read back the return count words.  Check the first word,
         which should have IVTV_MBOX_FIRMWARE_DONE set.  If however
         that bit is not set, then the command isn't done so repeat the
-        read.
-
-        Next, read back 32 words and compare with the original
-        arugments.  Hopefully they will match.
+        read until it is set.
 
         Finally, write out just the first word again, but set it to
         0x0 this time (which probably means "idle").
 
         */
 
-        if (arg_cnt_send > (sizeof(wrData)/sizeof(wrData[0]))-4) {
+        if (arg_cnt_send > (ARRAY_SIZE(wrData) - 4)) {
                 pvr2_trace(
                         PVR2_TRACE_ERROR_LEGS,
                         "Failed to write cx23416 command"
                         " - too many input arguments"
-                        " (was given %u limit %u)",
-                        arg_cnt_send,
-                        (unsigned int)(sizeof(wrData)/sizeof(wrData[0])) - 4);
+                        " (was given %u limit %lu)",
+                        arg_cnt_send, (long unsigned) ARRAY_SIZE(wrData) - 4);
                 return -EINVAL;
         }
 
-        if (arg_cnt_recv > (sizeof(rdData)/sizeof(rdData[0]))-4) {
+        if (arg_cnt_recv > (ARRAY_SIZE(rdData) - 4)) {
                 pvr2_trace(
                         PVR2_TRACE_ERROR_LEGS,
                         "Failed to write cx23416 command"
                         " - too many return arguments"
-                        " (was given %u limit %u)",
-                        arg_cnt_recv,
-                        (unsigned int)(sizeof(rdData)/sizeof(rdData[0])) - 4);
+                        " (was given %u limit %lu)",
+                        arg_cnt_recv, (long unsigned) ARRAY_SIZE(rdData) - 4);
                 return -EINVAL;
         }
 
 
         LOCK_TAKE(hdw->ctl_lock); do {
 
+                retry_flag = 0;
+                try_count++;
+                ret = 0;
                 wrData[0] = 0;
                 wrData[1] = cmd;
                 wrData[2] = 0;
@@ -201,59 +219,74 @@ static int pvr2_encoder_cmd(void *ctxt,
                 for (idx = 0; idx < arg_cnt_send; idx++) {
                         wrData[idx+4] = argp[idx];
                 }
-                for (; idx < (sizeof(wrData)/sizeof(wrData[0]))-4; idx++) {
+                for (; idx < ARRAY_SIZE(wrData) - 4; idx++) {
                         wrData[idx+4] = 0;
                 }
 
-                ret = pvr2_encoder_write_words(hdw,wrData,idx);
+                ret = pvr2_encoder_write_words(hdw,MBOX_BASE,wrData,idx);
                 if (ret) break;
                 wrData[0] = IVTV_MBOX_DRIVER_DONE|IVTV_MBOX_DRIVER_BUSY;
-                ret = pvr2_encoder_write_words(hdw,wrData,1);
+                ret = pvr2_encoder_write_words(hdw,MBOX_BASE,wrData,1);
                 if (ret) break;
                 poll_count = 0;
                 while (1) {
-                        if (poll_count < 10000000) poll_count++;
-                        ret = pvr2_encoder_read_words(hdw,!0,rdData,1);
-                        if (ret) break;
+                        poll_count++;
+                        ret = pvr2_encoder_read_words(hdw,MBOX_BASE,rdData,
+                                                      arg_cnt_recv+4);
+                        if (ret) {
+                                break;
+                        }
                         if (rdData[0] & IVTV_MBOX_FIRMWARE_DONE) {
                                 break;
                         }
-                        if (poll_count == 100) {
+                        if (rdData[0] && (poll_count < 1000)) continue;
+                        if (!rdData[0]) {
+                                retry_flag = !0;
                                 pvr2_trace(
                                         PVR2_TRACE_ERROR_LEGS,
-                                        "***WARNING*** device's encoder"
-                                        " appears to be stuck"
-                                        " (status=0%08x)",rdData[0]);
+                                        "Encoder timed out waiting for us"
+                                        "; arranging to retry");
+                        } else {
                                 pvr2_trace(
                                         PVR2_TRACE_ERROR_LEGS,
-                                        "Encoder command: 0x%02x",cmd);
-                                for (idx = 4; idx < arg_cnt_send; idx++) {
-                                        pvr2_trace(
-                                                PVR2_TRACE_ERROR_LEGS,
-                                                "Encoder arg%d: 0x%08x",
-                                                idx-3,wrData[idx]);
-                                }
+                                        "***WARNING*** device's encoder"
+                                        " appears to be stuck"
+                                        " (status=0x%08x)",rdData[0]);
+                        }
+                        pvr2_trace(
+                                PVR2_TRACE_ERROR_LEGS,
+                                "Encoder command: 0x%02x",cmd);
+                        for (idx = 4; idx < arg_cnt_send; idx++) {
                                 pvr2_trace(
                                         PVR2_TRACE_ERROR_LEGS,
-                                        "Giving up waiting."
-                                        "  It is likely that"
-                                        " this is a bad idea...");
-                                ret = -EBUSY;
-                                break;
+                                        "Encoder arg%d: 0x%08x",
+                                        idx-3,wrData[idx]);
                         }
+                        ret = -EBUSY;
+                        break;
+                }
+                if (retry_flag) {
+                        if (try_count < 20) continue;
+                        pvr2_trace(
+                                PVR2_TRACE_ERROR_LEGS,
+                                "Too many retries...");
+                        ret = -EBUSY;
+                }
+                if (ret) {
+                        pvr2_trace(
+                                PVR2_TRACE_ERROR_LEGS,
+                                "Giving up on command."
+                                "  It is likely that"
+                                " this is a bad idea...");
+                        break;
                 }
-                if (ret) break;
                 wrData[0] = 0x7;
-                ret = pvr2_encoder_read_words(
-                        hdw,0,rdData,
-                        sizeof(rdData)/sizeof(rdData[0]));
-                if (ret) break;
                 for (idx = 0; idx < arg_cnt_recv; idx++) {
                         argp[idx] = rdData[idx+4];
                 }
 
                 wrData[0] = 0x0;
-                ret = pvr2_encoder_write_words(hdw,wrData,1);
+                ret = pvr2_encoder_write_words(hdw,MBOX_BASE,wrData,1);
                 if (ret) break;
 
         } while(0); LOCK_GIVE(hdw->ctl_lock);
@@ -269,13 +302,13 @@ static int pvr2_encoder_vcmd(struct pvr2_hdw *hdw, int cmd,
         unsigned int idx;
         u32 data[12];
 
-        if (args > sizeof(data)/sizeof(data[0])) {
+        if (args > ARRAY_SIZE(data)) {
                 pvr2_trace(
                         PVR2_TRACE_ERROR_LEGS,
                         "Failed to write cx23416 command"
                         " - too many arguments"
-                        " (was given %u limit %u)",
-                        args,(unsigned int)(sizeof(data)/sizeof(data[0])));
+                        " (was given %u limit %lu)",
+                        args, (long unsigned) ARRAY_SIZE(data));
                 return -EINVAL;
         }
 
@@ -288,6 +321,73 @@ static int pvr2_encoder_vcmd(struct pvr2_hdw *hdw, int cmd,
         return pvr2_encoder_cmd(hdw,cmd,args,0,data);
 }
 
+
+/* This implements some extra setup for the encoder that seems to be
+   specific to the PVR USB2 hardware. */
+int pvr2_encoder_prep_config(struct pvr2_hdw *hdw)
+{
+        int ret = 0;
+        int encMisc3Arg = 0;
+
+#if 0
+        /* This inexplicable bit happens in the Hauppage windows
+           driver (for both 24xxx and 29xxx devices).  However I
+           currently see no difference in behavior with or without
+           this stuff.  Leave this here as a note of its existence,
+           but don't use it. */
+        LOCK_TAKE(hdw->ctl_lock); do {
+                u32 dat[1];
+                dat[0] = 0x80000640;
+                pvr2_encoder_write_words(hdw,0x01fe,dat,1);
+                pvr2_encoder_write_words(hdw,0x023e,dat,1);
+        } while(0); LOCK_GIVE(hdw->ctl_lock);
+#endif
+
+        /* Mike Isely <isely@pobox.com> 26-Jan-2006 The windows driver
+           sends the following list of ENC_MISC commands (for both
+           24xxx and 29xxx devices).  Meanings are not entirely clear,
+           however without the ENC_MISC(3,1) command then we risk
+           random perpetual video corruption whenever the video input
+           breaks up for a moment (like when switching channels). */
+
+
+#if 0
+        /* This ENC_MISC(5,0) command seems to hurt 29xxx sync
+           performance on channel changes, but is not a problem on
+           24xxx devices. */
+        ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 5,0,0,0);
+#endif
+
+        /* This ENC_MISC(3,encMisc3Arg) command is critical - without
+           it there will eventually be video corruption.  Also, the
+           29xxx case is strange - the Windows driver is passing 1
+           regardless of device type but if we have 1 for 29xxx device
+           the video turns sluggish.  */
+        switch (hdw->hdw_type) {
+        case PVR2_HDW_TYPE_24XXX: encMisc3Arg = 1; break;
+        case PVR2_HDW_TYPE_29XXX: encMisc3Arg = 0; break;
+        default: break;
+        }
+        ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 3,
+                                 encMisc3Arg,0,0);
+
+        ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 8,0,0,0);
+
+#if 0
+        /* This ENC_MISC(4,1) command is poisonous, so it is commented
+           out.  But I'm leaving it here anyway to document its
+           existence in the Windows driver.  The effect of this
+           command is that apps displaying the stream become sluggish
+           with stuttering video. */
+        ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 4,1,0,0);
+#endif
+
+        ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 0,3,0,0);
+        ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4,15,0,0,0);
+
+        return ret;
+}
+
 int pvr2_encoder_configure(struct pvr2_hdw *hdw)
 {
         int ret;
@@ -302,6 +402,8 @@ int pvr2_encoder_configure(struct pvr2_hdw *hdw)
 
         ret = 0;
 
+        ret |= pvr2_encoder_prep_config(hdw);
+
         if (!ret) ret = pvr2_encoder_vcmd(
                 hdw,CX2341X_ENC_SET_NUM_VSYNC_LINES, 2,
                 0xf0, 0xf0);
@@ -360,15 +462,22 @@ int pvr2_encoder_start(struct pvr2_hdw *hdw)
         pvr2_hdw_gpio_chg_dir(hdw,0xffffffff,0x00000481);
         pvr2_hdw_gpio_chg_out(hdw,0xffffffff,0x00000000);
 
-        if (hdw->config == pvr2_config_vbi) {
+        pvr2_encoder_vcmd(hdw,CX2341X_ENC_MUTE_VIDEO,1,
+                          hdw->input_val == PVR2_CVAL_INPUT_RADIO ? 1 : 0);
+
+        switch (hdw->config) {
+        case pvr2_config_vbi:
                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_START_CAPTURE,2,
                                            0x01,0x14);
-        } else if (hdw->config == pvr2_config_mpeg) {
+                break;
+        case pvr2_config_mpeg:
                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_START_CAPTURE,2,
                                            0,0x13);
-        } else {
+                break;
+        default: /* Unhandled cases for now */
                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_START_CAPTURE,2,
                                            0,0x13);
+                break;
         }
         if (!status) {
                 hdw->subsys_enabled_mask |= (1<<PVR2_SUBSYS_B_ENC_RUN);
@@ -383,15 +492,19 @@ int pvr2_encoder_stop(struct pvr2_hdw *hdw)
         /* mask all interrupts */
         pvr2_write_register(hdw, 0x0048, 0xffffffff);
 
-        if (hdw->config == pvr2_config_vbi) {
+        switch (hdw->config) {
+        case pvr2_config_vbi:
                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_STOP_CAPTURE,3,
                                            0x01,0x01,0x14);
-        } else if (hdw->config == pvr2_config_mpeg) {
+                break;
+        case pvr2_config_mpeg:
                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_STOP_CAPTURE,3,
                                            0x01,0,0x13);
-        } else {
+                break;
+        default: /* Unhandled cases for now */
                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_STOP_CAPTURE,3,
                                            0x01,0,0x13);
+                break;
         }
 
         /* change some GPIO data */