drivers/media/video/pvrusb2/pvrusb2-encoder.c

   1 /*
   2  *
   3  *  $Id$
   4  *
   5  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
   6  *  Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  */
  22
  23 #include <linux/device.h>   // for linux/firmware.h
  24 #include <linux/firmware.h>
  25 #include "pvrusb2-util.h"
  26 #include "pvrusb2-encoder.h"
  27 #include "pvrusb2-hdw-internal.h"
  28 #include "pvrusb2-debug.h"
  29 #include "pvrusb2-fx2-cmd.h"
  30
  31
  32
  33 /* Firmware mailbox flags - definitions found from ivtv */
  34 #define IVTV_MBOX_FIRMWARE_DONE 0x00000004
  35 #define IVTV_MBOX_DRIVER_DONE 0x00000002
  36 #define IVTV_MBOX_DRIVER_BUSY 0x00000001
  37
  38 #define MBOX_BASE 0x44
  39
  40
  41 static int pvr2_encoder_write_words(struct pvr2_hdw *hdw,
  42                                     unsigned int offs,
  43                                     const u32 *data, unsigned int dlen)
  44 {
  45         unsigned int idx,addr;
  46         unsigned int bAddr;
  47         int ret;
  48         unsigned int chunkCnt;
  49
  50         /*
  51
  52         Format: First byte must be 0x01.  Remaining 32 bit words are
  53         spread out into chunks of 7 bytes each, with the first 4 bytes
  54         being the data word (little endian), and the next 3 bytes
  55         being the address where that data word is to be written (big
  56         endian).  Repeat request for additional words, with offset
  57         adjusted accordingly.
  58
  59         */
  60         while (dlen) {
  61                 chunkCnt = 8;
  62                 if (chunkCnt > dlen) chunkCnt = dlen;
  63                 memset(hdw->cmd_buffer,0,sizeof(hdw->cmd_buffer));
  64                 bAddr = 0;
  65                 hdw->cmd_buffer[bAddr++] = FX2CMD_MEM_WRITE_DWORD;
  66                 for (idx = 0; idx < chunkCnt; idx++) {
  67                         addr = idx + offs;
  68                         hdw->cmd_buffer[bAddr+6] = (addr & 0xffu);
  69                         hdw->cmd_buffer[bAddr+5] = ((addr>>8) & 0xffu);
  70                         hdw->cmd_buffer[bAddr+4] = ((addr>>16) & 0xffu);
  71                         PVR2_DECOMPOSE_LE(hdw->cmd_buffer, bAddr,data[idx]);
  72                         bAddr += 7;
  73                 }
  74                 ret = pvr2_send_request(hdw,
  75                                         hdw->cmd_buffer,1+(chunkCnt*7),
  76                                         NULL,0);
  77                 if (ret) return ret;
  78                 data += chunkCnt;
  79                 dlen -= chunkCnt;
  80                 offs += chunkCnt;
  81         }
  82
  83         return 0;
  84 }
  85
  86
  87 static int pvr2_encoder_read_words(struct pvr2_hdw *hdw,
  88                                    unsigned int offs,
  89                                    u32 *data, unsigned int dlen)
  90 {
  91         unsigned int idx;
  92         int ret;
  93         unsigned int chunkCnt;
  94
  95         /*
  96
  97         Format: First byte must be 0x02 (status check) or 0x28 (read
  98         back block of 32 bit words).  Next 6 bytes must be zero,
  99         followed by a single byte of MBOX_BASE+offset for portion to
 100         be read.  Returned data is packed set of 32 bits words that
 101         were read.
 102
 103         */
 104
 105         while (dlen) {
 106                 chunkCnt = 16;
 107                 if (chunkCnt > dlen) chunkCnt = dlen;
 108                 if (chunkCnt < 16) chunkCnt = 1;
 109                 hdw->cmd_buffer[0] =
 110                         ((chunkCnt == 1) ?
 111                          FX2CMD_MEM_READ_DWORD : FX2CMD_MEM_READ_64BYTES);
 112                 hdw->cmd_buffer[1] = 0;
 113                 hdw->cmd_buffer[2] = 0;
 114                 hdw->cmd_buffer[3] = 0;
 115                 hdw->cmd_buffer[4] = 0;
 116                 hdw->cmd_buffer[5] = ((offs>>16) & 0xffu);
 117                 hdw->cmd_buffer[6] = ((offs>>8) & 0xffu);
 118                 hdw->cmd_buffer[7] = (offs & 0xffu);
 119                 ret = pvr2_send_request(hdw,
 120                                         hdw->cmd_buffer,8,
 121                                         hdw->cmd_buffer,
 122                                         (chunkCnt == 1 ? 4 : 16 * 4));
 123                 if (ret) return ret;
 124
 125                 for (idx = 0; idx < chunkCnt; idx++) {
 126                         data[idx] = PVR2_COMPOSE_LE(hdw->cmd_buffer,idx*4);
 127                 }
 128                 data += chunkCnt;
 129                 dlen -= chunkCnt;
 130                 offs += chunkCnt;
 131         }
 132
 133         return 0;
 134 }
 135
 136
 137 /* This prototype is set up to be compatible with the
 138    cx2341x_mbox_func prototype in cx2341x.h, which should be in
 139    kernels 2.6.18 or later.  We do this so that we can enable
 140    cx2341x.ko to write to our encoder (by handing it a pointer to this
 141    function).  For earlier kernels this doesn't really matter. */
 142 static int pvr2_encoder_cmd(void *ctxt,
 143                             int cmd,
 144                             int arg_cnt_send,
 145                             int arg_cnt_recv,
 146                             u32 *argp)
 147 {
 148         unsigned int poll_count;
 149         unsigned int try_count = 0;
 150         int retry_flag;
 151         int ret = 0;
 152         unsigned int idx;
 153         /* These sizes look to be limited by the FX2 firmware implementation */
 154         u32 wrData[16];
 155         u32 rdData[16];
 156         struct pvr2_hdw *hdw = (struct pvr2_hdw *)ctxt;
 157
 158
 159         /*
 160
 161         The encoder seems to speak entirely using blocks 32 bit words.
 162         In ivtv driver terms, this is a mailbox at MBOX_BASE which we
 163         populate with data and watch what the hardware does with it.
 164         The first word is a set of flags used to control the
 165         transaction, the second word is the command to execute, the
 166         third byte is zero (ivtv driver suggests that this is some
 167         kind of return value), and the fourth byte is a specified
 168         timeout (windows driver always uses 0x00060000 except for one
 169         case when it is zero).  All successive words are the argument
 170         words for the command.
 171
 172         First, write out the entire set of words, with the first word
 173         being zero.
 174
 175         Next, write out just the first word again, but set it to
 176         IVTV_MBOX_DRIVER_DONE | IVTV_DRIVER_BUSY this time (which
 177         probably means "go").
 178
 179         Next, read back the return count words.  Check the first word,
 180         which should have IVTV_MBOX_FIRMWARE_DONE set.  If however
 181         that bit is not set, then the command isn't done so repeat the
 182         read until it is set.
 183
 184         Finally, write out just the first word again, but set it to
 185         0x0 this time (which probably means "idle").
 186
 187         */
 188
 189         if (arg_cnt_send > (ARRAY_SIZE(wrData) - 4)) {
 190                 pvr2_trace(
 191                         PVR2_TRACE_ERROR_LEGS,
 192                         "Failed to write cx23416 command"
 193                         " - too many input arguments"
 194                         " (was given %u limit %lu)",
 195                         arg_cnt_send, (long unsigned) ARRAY_SIZE(wrData) - 4);
 196                 return -EINVAL;
 197         }
 198
 199         if (arg_cnt_recv > (ARRAY_SIZE(rdData) - 4)) {
 200                 pvr2_trace(
 201                         PVR2_TRACE_ERROR_LEGS,
 202                         "Failed to write cx23416 command"
 203                         " - too many return arguments"
 204                         " (was given %u limit %lu)",
 205                         arg_cnt_recv, (long unsigned) ARRAY_SIZE(rdData) - 4);
 206                 return -EINVAL;
 207         }
 208
 209
 210         LOCK_TAKE(hdw->ctl_lock); do {
 211
 212                 if (!hdw->flag_encoder_ok) {
 213                         ret = -EIO;
 214                         break;
 215                 }
 216
 217                 retry_flag = 0;
 218                 try_count++;
 219                 ret = 0;
 220                 wrData[0] = 0;
 221                 wrData[1] = cmd;
 222                 wrData[2] = 0;
 223                 wrData[3] = 0x00060000;
 224                 for (idx = 0; idx < arg_cnt_send; idx++) {
 225                         wrData[idx+4] = argp[idx];
 226                 }
 227                 for (; idx < ARRAY_SIZE(wrData) - 4; idx++) {
 228                         wrData[idx+4] = 0;
 229                 }
 230
 231                 ret = pvr2_encoder_write_words(hdw,MBOX_BASE,wrData,idx);
 232                 if (ret) break;
 233                 wrData[0] = IVTV_MBOX_DRIVER_DONE|IVTV_MBOX_DRIVER_BUSY;
 234                 ret = pvr2_encoder_write_words(hdw,MBOX_BASE,wrData,1);
 235                 if (ret) break;
 236                 poll_count = 0;
 237                 while (1) {
 238                         poll_count++;
 239                         ret = pvr2_encoder_read_words(hdw,MBOX_BASE,rdData,
 240                                                       arg_cnt_recv+4);
 241                         if (ret) {
 242                                 break;
 243                         }
 244                         if (rdData[0] & IVTV_MBOX_FIRMWARE_DONE) {
 245                                 break;
 246                         }
 247                         if (rdData[0] && (poll_count < 1000)) continue;
 248                         if (!rdData[0]) {
 249                                 retry_flag = !0;
 250                                 pvr2_trace(
 251                                         PVR2_TRACE_ERROR_LEGS,
 252                                         "Encoder timed out waiting for us"
 253                                         "; arranging to retry");
 254                         } else {
 255                                 pvr2_trace(
 256                                         PVR2_TRACE_ERROR_LEGS,
 257                                         "***WARNING*** device's encoder"
 258                                         " appears to be stuck"
 259                                         " (status=0x%08x)",rdData[0]);
 260                         }
 261                         pvr2_trace(
 262                                 PVR2_TRACE_ERROR_LEGS,
 263                                 "Encoder command: 0x%02x",cmd);
 264                         for (idx = 4; idx < arg_cnt_send; idx++) {
 265                                 pvr2_trace(
 266                                         PVR2_TRACE_ERROR_LEGS,
 267                                         "Encoder arg%d: 0x%08x",
 268                                         idx-3,wrData[idx]);
 269                         }
 270                         ret = -EBUSY;
 271                         break;
 272                 }
 273                 if (retry_flag) {
 274                         if (try_count < 20) continue;
 275                         pvr2_trace(
 276                                 PVR2_TRACE_ERROR_LEGS,
 277                                 "Too many retries...");
 278                         ret = -EBUSY;
 279                 }
 280                 if (ret) {
 281                         hdw->flag_encoder_ok = 0;
 282                         pvr2_trace(
 283                                 PVR2_TRACE_ERROR_LEGS,
 284                                 "Giving up on command."
 285                                 "  It is likely that"
 286                                 " this is a bad idea...");
 287                         break;
 288                 }
 289                 wrData[0] = 0x7;
 290                 for (idx = 0; idx < arg_cnt_recv; idx++) {
 291                         argp[idx] = rdData[idx+4];
 292                 }
 293
 294                 wrData[0] = 0x0;
 295                 ret = pvr2_encoder_write_words(hdw,MBOX_BASE,wrData,1);
 296                 if (ret) break;
 297
 298         } while(0); LOCK_GIVE(hdw->ctl_lock);
 299
 300         return ret;
 301 }
 302
 303
 304 static int pvr2_encoder_vcmd(struct pvr2_hdw *hdw, int cmd,
 305                              int args, ...)
 306 {
 307         va_list vl;
 308         unsigned int idx;
 309         u32 data[12];
 310
 311         if (args > ARRAY_SIZE(data)) {
 312                 pvr2_trace(
 313                         PVR2_TRACE_ERROR_LEGS,
 314                         "Failed to write cx23416 command"
 315                         " - too many arguments"
 316                         " (was given %u limit %lu)",
 317                         args, (long unsigned) ARRAY_SIZE(data));
 318                 return -EINVAL;
 319         }
 320
 321         va_start(vl, args);
 322         for (idx = 0; idx < args; idx++) {
 323                 data[idx] = va_arg(vl, u32);
 324         }
 325         va_end(vl);
 326
 327         return pvr2_encoder_cmd(hdw,cmd,args,0,data);
 328 }
 329
 330
 331 /* This implements some extra setup for the encoder that seems to be
 332    specific to the PVR USB2 hardware. */
 333 static int pvr2_encoder_prep_config(struct pvr2_hdw *hdw)
 334 {
 335         int ret = 0;
 336         int encMisc3Arg = 0;
 337
 338 #if 0
 339         /* This inexplicable bit happens in the Hauppage windows
 340            driver (for both 24xxx and 29xxx devices).  However I
 341            currently see no difference in behavior with or without
 342            this stuff.  Leave this here as a note of its existence,
 343            but don't use it. */
 344         LOCK_TAKE(hdw->ctl_lock); do {
 345                 u32 dat[1];
 346                 dat[0] = 0x80000640;
 347                 pvr2_encoder_write_words(hdw,0x01fe,dat,1);
 348                 pvr2_encoder_write_words(hdw,0x023e,dat,1);
 349         } while(0); LOCK_GIVE(hdw->ctl_lock);
 350 #endif
 351
 352         /* Mike Isely <isely@pobox.com> 26-Jan-2006 The windows driver
 353            sends the following list of ENC_MISC commands (for both
 354            24xxx and 29xxx devices).  Meanings are not entirely clear,
 355            however without the ENC_MISC(3,1) command then we risk
 356            random perpetual video corruption whenever the video input
 357            breaks up for a moment (like when switching channels). */
 358
 359
 360 #if 0
 361         /* This ENC_MISC(5,0) command seems to hurt 29xxx sync
 362            performance on channel changes, but is not a problem on
 363            24xxx devices. */
 364         ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 5,0,0,0);
 365 #endif
 366
 367         /* This ENC_MISC(3,encMisc3Arg) command is critical - without
 368            it there will eventually be video corruption.  Also, the
 369            29xxx case is strange - the Windows driver is passing 1
 370            regardless of device type but if we have 1 for 29xxx device
 371            the video turns sluggish.  */
 372         switch (hdw->hdw_type) {
 373         case PVR2_HDW_TYPE_24XXX: encMisc3Arg = 1; break;
 374         case PVR2_HDW_TYPE_29XXX: encMisc3Arg = 0; break;
 375         default: break;
 376         }
 377         ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 3,
 378                                  encMisc3Arg,0,0);
 379
 380         ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 8,0,0,0);
 381
 382 #if 0
 383         /* This ENC_MISC(4,1) command is poisonous, so it is commented
 384            out.  But I'm leaving it here anyway to document its
 385            existence in the Windows driver.  The effect of this
 386            command is that apps displaying the stream become sluggish
 387            with stuttering video. */
 388         ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 4,1,0,0);
 389 #endif
 390
 391         ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 0,3,0,0);
 392         ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4,15,0,0,0);
 393
 394         return ret;
 395 }
 396
 397 int pvr2_encoder_configure(struct pvr2_hdw *hdw)
 398 {
 399         int ret;
 400         int val;
 401         pvr2_trace(PVR2_TRACE_ENCODER,"pvr2_encoder_configure"
 402                    " (cx2341x module)");
 403         hdw->enc_ctl_state.port = CX2341X_PORT_STREAMING;
 404         hdw->enc_ctl_state.width = hdw->res_hor_val;
 405         hdw->enc_ctl_state.height = hdw->res_ver_val;
 406         hdw->enc_ctl_state.is_50hz = ((hdw->std_mask_cur & V4L2_STD_525_60) ?
 407                                       0 : 1);
 408
 409         ret = 0;
 410
 411         ret |= pvr2_encoder_prep_config(hdw);
 412
 413         /* saa7115: 0xf0 */
 414         val = 0xf0;
 415         if (hdw->hdw_type == PVR2_HDW_TYPE_24XXX) {
 416                 /* ivtv cx25840: 0x140 */
 417                 val = 0x140;
 418         }
 419
 420         if (!ret) ret = pvr2_encoder_vcmd(
 421                 hdw,CX2341X_ENC_SET_NUM_VSYNC_LINES, 2,
 422                 val, val);
 423
 424         /* setup firmware to notify us about some events (don't know why...) */
 425         if (!ret) ret = pvr2_encoder_vcmd(
 426                 hdw,CX2341X_ENC_SET_EVENT_NOTIFICATION, 4,
 427                 0, 0, 0x10000000, 0xffffffff);
 428
 429         if (!ret) ret = pvr2_encoder_vcmd(
 430                 hdw,CX2341X_ENC_SET_VBI_LINE, 5,
 431                 0xffffffff,0,0,0,0);
 432
 433         if (ret) {
 434                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 435                            "Failed to configure cx23416");
 436                 return ret;
 437         }
 438
 439         ret = cx2341x_update(hdw,pvr2_encoder_cmd,
 440                              (hdw->enc_cur_valid ? &hdw->enc_cur_state : NULL),
 441                              &hdw->enc_ctl_state);
 442         if (ret) {
 443                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 444                            "Error from cx2341x module code=%d",ret);
 445                 return ret;
 446         }
 447
 448         ret = 0;
 449
 450         if (!ret) ret = pvr2_encoder_vcmd(
 451                 hdw, CX2341X_ENC_INITIALIZE_INPUT, 0);
 452
 453         if (ret) {
 454                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 455                            "Failed to initialize cx23416 video input");
 456                 return ret;
 457         }
 458
 459         hdw->subsys_enabled_mask |= (1<<PVR2_SUBSYS_B_ENC_CFG);
 460         memcpy(&hdw->enc_cur_state,&hdw->enc_ctl_state,
 461                sizeof(struct cx2341x_mpeg_params));
 462         hdw->enc_cur_valid = !0;
 463         return 0;
 464 }
 465
 466
 467 int pvr2_encoder_start(struct pvr2_hdw *hdw)
 468 {
 469         int status;
 470
 471         /* unmask some interrupts */
 472         pvr2_write_register(hdw, 0x0048, 0xbfffffff);
 473
 474         /* change some GPIO data */
 475         pvr2_hdw_gpio_chg_dir(hdw,0xffffffff,0x00000481);
 476         pvr2_hdw_gpio_chg_out(hdw,0xffffffff,0x00000000);
 477
 478         pvr2_encoder_vcmd(hdw,CX2341X_ENC_MUTE_VIDEO,1,
 479                           hdw->input_val == PVR2_CVAL_INPUT_RADIO ? 1 : 0);
 480
 481         switch (hdw->config) {
 482         case pvr2_config_vbi:
 483                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_START_CAPTURE,2,
 484                                            0x01,0x14);
 485                 break;
 486         case pvr2_config_mpeg:
 487                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_START_CAPTURE,2,
 488                                            0,0x13);
 489                 break;
 490         default: /* Unhandled cases for now */
 491                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_START_CAPTURE,2,
 492                                            0,0x13);
 493                 break;
 494         }
 495         if (!status) {
 496                 hdw->subsys_enabled_mask |= (1<<PVR2_SUBSYS_B_ENC_RUN);
 497         }
 498         return status;
 499 }
 500
 501 int pvr2_encoder_stop(struct pvr2_hdw *hdw)
 502 {
 503         int status;
 504
 505         /* mask all interrupts */
 506         pvr2_write_register(hdw, 0x0048, 0xffffffff);
 507
 508         switch (hdw->config) {
 509         case pvr2_config_vbi:
 510                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_STOP_CAPTURE,3,
 511                                            0x01,0x01,0x14);
 512                 break;
 513         case pvr2_config_mpeg:
 514                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_STOP_CAPTURE,3,
 515                                            0x01,0,0x13);
 516                 break;
 517         default: /* Unhandled cases for now */
 518                 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_STOP_CAPTURE,3,
 519                                            0x01,0,0x13);
 520                 break;
 521         }
 522
 523         /* change some GPIO data */
 524         /* Note: Bit d7 of dir appears to control the LED.  So we shut it
 525            off here. */
 526         pvr2_hdw_gpio_chg_dir(hdw,0xffffffff,0x00000401);
 527         pvr2_hdw_gpio_chg_out(hdw,0xffffffff,0x00000000);
 528
 529         if (!status) {
 530                 hdw->subsys_enabled_mask &= ~(1<<PVR2_SUBSYS_B_ENC_RUN);
 531         }
 532         return status;
 533 }
 534
 535
 536 /*
 537   Stuff for Emacs to see, in order to encourage consistent editing style:
 538   *** Local Variables: ***
 539   *** mode: c ***
 540   *** fill-column: 70 ***
 541   *** tab-width: 8 ***
 542   *** c-basic-offset: 8 ***
 543   *** End: ***
 544   */