git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/ivtv/ivtv-vbi.c

   1 /*
   2     Vertical Blank Interval support functions
   3     Copyright (C) 2004-2007  Hans Verkuil <hverkuil@xs4all.nl>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include "ivtv-driver.h"
  21 #include "ivtv-i2c.h"
  22 #include "ivtv-ioctl.h"
  23 #include "ivtv-queue.h"
  24 #include "ivtv-vbi.h"
  25
  26 static void ivtv_set_vps(struct ivtv *itv, int enabled, u8 vps1, u8 vps2, u8 vps3,
  27                   u8 vps4, u8 vps5)
  28 {
  29         struct v4l2_sliced_vbi_data data;
  30
  31         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
  32                 return;
  33         data.id = V4L2_SLICED_VPS;
  34         data.field = 0;
  35         data.line = enabled ? 16 : 0;
  36         data.data[4] = vps1;
  37         data.data[10] = vps2;
  38         data.data[11] = vps3;
  39         data.data[12] = vps4;
  40         data.data[13] = vps5;
  41         ivtv_saa7127(itv, VIDIOC_INT_S_VBI_DATA, &data);
  42 }
  43
  44 static void ivtv_set_cc(struct ivtv *itv, int mode, u8 cc1, u8 cc2, u8 cc3, u8 cc4)
  45 {
  46         struct v4l2_sliced_vbi_data data;
  47
  48         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
  49                 return;
  50         data.id = V4L2_SLICED_CAPTION_525;
  51         data.field = 0;
  52         data.line = (mode & 1) ? 21 : 0;
  53         data.data[0] = cc1;
  54         data.data[1] = cc2;
  55         ivtv_saa7127(itv, VIDIOC_INT_S_VBI_DATA, &data);
  56         data.field = 1;
  57         data.line = (mode & 2) ? 21 : 0;
  58         data.data[0] = cc3;
  59         data.data[1] = cc4;
  60         ivtv_saa7127(itv, VIDIOC_INT_S_VBI_DATA, &data);
  61 }
  62
  63 static void ivtv_set_wss(struct ivtv *itv, int enabled, int mode)
  64 {
  65         struct v4l2_sliced_vbi_data data;
  66
  67         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
  68                 return;
  69         /* When using a 50 Hz system, always turn on the
  70            wide screen signal with 4x3 ratio as the default.
  71            Turning this signal on and off can confuse certain
  72            TVs. As far as I can tell there is no reason not to
  73            transmit this signal. */
  74         if ((itv->std & V4L2_STD_625_50) && !enabled) {
  75                 enabled = 1;
  76                 mode = 0x08;  /* 4x3 full format */
  77         }
  78         data.id = V4L2_SLICED_WSS_625;
  79         data.field = 0;
  80         data.line = enabled ? 23 : 0;
  81         data.data[0] = mode & 0xff;
  82         data.data[1] = (mode >> 8) & 0xff;
  83         ivtv_saa7127(itv, VIDIOC_INT_S_VBI_DATA, &data);
  84 }
  85
  86 static int odd_parity(u8 c)
  87 {
  88         c ^= (c >> 4);
  89         c ^= (c >> 2);
  90         c ^= (c >> 1);
  91
  92         return c & 1;
  93 }
  94
  95 static void passthrough_vbi_data(struct ivtv *itv, int cnt)
  96 {
  97         int wss = 0;
  98         u8 cc[4] = { 0x80, 0x80, 0x80, 0x80 };
  99         u8 vps[13];
 100         int found_cc = 0;
 101         int found_wss = 0;
 102         int found_vps = 0;
 103         int cc_pos = itv->vbi.cc_pos;
 104         int i;
 105
 106         for (i = 0; i < cnt; i++) {
 107                 struct v4l2_sliced_vbi_data *d = itv->vbi.sliced_dec_data + i;
 108
 109                 if (d->id == V4L2_SLICED_CAPTION_525 && d->line == 21) {
 110                         found_cc = 1;
 111                         if (d->field) {
 112                                 cc[2] = d->data[0];
 113                                 cc[3] = d->data[1];
 114                         } else {
 115                                 cc[0] = d->data[0];
 116                                 cc[1] = d->data[1];
 117                         }
 118                 }
 119                 else if (d->id == V4L2_SLICED_VPS && d->line == 16 && d->field == 0) {
 120                         memcpy(vps, d->data, sizeof(vps));
 121                         found_vps = 1;
 122                 }
 123                 else if (d->id == V4L2_SLICED_WSS_625 && d->line == 23 && d->field == 0) {
 124                         wss = d->data[0] | d->data[1] << 8;
 125                         found_wss = 1;
 126                 }
 127         }
 128
 129         if (itv->vbi.wss_found != found_wss || itv->vbi.wss != wss) {
 130                 itv->vbi.wss = wss;
 131                 itv->vbi.wss_found = found_wss;
 132                 set_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags);
 133         }
 134
 135         if (found_vps || itv->vbi.vps_found) {
 136                 itv->vbi.vps[0] = vps[2];
 137                 itv->vbi.vps[1] = vps[8];
 138                 itv->vbi.vps[2] = vps[9];
 139                 itv->vbi.vps[3] = vps[10];
 140                 itv->vbi.vps[4] = vps[11];
 141                 itv->vbi.vps_found = found_vps;
 142                 set_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags);
 143         }
 144
 145         if (found_cc && cc_pos < sizeof(itv->vbi.cc_data_even)) {
 146                 itv->vbi.cc_data_odd[cc_pos] = cc[0];
 147                 itv->vbi.cc_data_odd[cc_pos + 1] = cc[1];
 148                 itv->vbi.cc_data_even[cc_pos] = cc[2];
 149                 itv->vbi.cc_data_even[cc_pos + 1] = cc[3];
 150                 itv->vbi.cc_pos = cc_pos + 2;
 151                 set_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 152         }
 153 }
 154
 155 static void copy_vbi_data(struct ivtv *itv, int lines, u32 pts_stamp)
 156 {
 157         int line = 0;
 158         int i;
 159         u32 linemask[2] = { 0, 0 };
 160         unsigned short size;
 161         static const u8 mpeg_hdr_data[] = {
 162                 0x00, 0x00, 0x01, 0xba, 0x44, 0x00, 0x0c, 0x66,
 163                 0x24, 0x01, 0x01, 0xd1, 0xd3, 0xfa, 0xff, 0xff,
 164                 0x00, 0x00, 0x01, 0xbd, 0x00, 0x1a, 0x84, 0x80,
 165                 0x07, 0x21, 0x00, 0x5d, 0x63, 0xa7, 0xff, 0xff
 166         };
 167         const int sd = sizeof(mpeg_hdr_data);   /* start of vbi data */
 168         int idx = itv->vbi.frame % IVTV_VBI_FRAMES;
 169         u8 *dst = &itv->vbi.sliced_mpeg_data[idx][0];
 170
 171         for (i = 0; i < lines; i++) {
 172                 int f, l;
 173
 174                 if (itv->vbi.sliced_data[i].id == 0)
 175                         continue;
 176
 177                 l = itv->vbi.sliced_data[i].line - 6;
 178                 f = itv->vbi.sliced_data[i].field;
 179                 if (f)
 180                         l += 18;
 181                 if (l < 32)
 182                         linemask[0] |= (1 << l);
 183                 else
 184                         linemask[1] |= (1 << (l - 32));
 185                 dst[sd + 12 + line * 43] = service2vbi(itv->vbi.sliced_data[i].id);
 186                 memcpy(dst + sd + 12 + line * 43 + 1, itv->vbi.sliced_data[i].data, 42);
 187                 line++;
 188         }
 189         memcpy(dst, mpeg_hdr_data, sizeof(mpeg_hdr_data));
 190         if (line == 36) {
 191                 /* All lines are used, so there is no space for the linemask
 192                    (the max size of the VBI data is 36 * 43 + 4 bytes).
 193                    So in this case we use the magic number 'ITV0'. */
 194                 memcpy(dst + sd, "ITV0", 4);
 195                 memcpy(dst + sd + 4, dst + sd + 12, line * 43);
 196                 size = 4 + ((43 * line + 3) & ~3);
 197         } else {
 198                 memcpy(dst + sd, "itv0", 4);
 199                 memcpy(dst + sd + 4, &linemask[0], 8);
 200                 size = 12 + ((43 * line + 3) & ~3);
 201         }
 202         dst[4+16] = (size + 10) >> 8;
 203         dst[5+16] = (size + 10) & 0xff;
 204         dst[9+16] = 0x21 | ((pts_stamp >> 29) & 0x6);
 205         dst[10+16] = (pts_stamp >> 22) & 0xff;
 206         dst[11+16] = 1 | ((pts_stamp >> 14) & 0xff);
 207         dst[12+16] = (pts_stamp >> 7) & 0xff;
 208         dst[13+16] = 1 | ((pts_stamp & 0x7f) << 1);
 209         itv->vbi.sliced_mpeg_size[idx] = sd + size;
 210 }
 211
 212 static int ivtv_convert_ivtv_vbi(struct ivtv *itv, u8 *p)
 213 {
 214         u32 linemask[2];
 215         int i, l, id2;
 216         int line = 0;
 217
 218         if (!memcmp(p, "itv0", 4)) {
 219                 memcpy(linemask, p + 4, 8);
 220                 p += 12;
 221         } else if (!memcmp(p, "ITV0", 4)) {
 222                 linemask[0] = 0xffffffff;
 223                 linemask[1] = 0xf;
 224                 p += 4;
 225         } else {
 226                 /* unknown VBI data, convert to empty VBI frame */
 227                 linemask[0] = linemask[1] = 0;
 228         }
 229         for (i = 0; i < 36; i++) {
 230                 int err = 0;
 231
 232                 if (i < 32 && !(linemask[0] & (1 << i)))
 233                         continue;
 234                 if (i >= 32 && !(linemask[1] & (1 << (i - 32))))
 235                         continue;
 236                 id2 = *p & 0xf;
 237                 switch (id2) {
 238                 case IVTV_SLICED_TYPE_TELETEXT_B:
 239                         id2 = V4L2_SLICED_TELETEXT_B;
 240                         break;
 241                 case IVTV_SLICED_TYPE_CAPTION_525:
 242                         id2 = V4L2_SLICED_CAPTION_525;
 243                         err = !odd_parity(p[1]) || !odd_parity(p[2]);
 244                         break;
 245                 case IVTV_SLICED_TYPE_VPS:
 246                         id2 = V4L2_SLICED_VPS;
 247                         break;
 248                 case IVTV_SLICED_TYPE_WSS_625:
 249                         id2 = V4L2_SLICED_WSS_625;
 250                         break;
 251                 default:
 252                         id2 = 0;
 253                         break;
 254                 }
 255                 if (err == 0) {
 256                         l = (i < 18) ? i + 6 : i - 18 + 6;
 257                         itv->vbi.sliced_dec_data[line].line = l;
 258                         itv->vbi.sliced_dec_data[line].field = i >= 18;
 259                         itv->vbi.sliced_dec_data[line].id = id2;
 260                         memcpy(itv->vbi.sliced_dec_data[line].data, p + 1, 42);
 261                         line++;
 262                 }
 263                 p += 43;
 264         }
 265         while (line < 36) {
 266                 itv->vbi.sliced_dec_data[line].id = 0;
 267                 itv->vbi.sliced_dec_data[line].line = 0;
 268                 itv->vbi.sliced_dec_data[line].field = 0;
 269                 line++;
 270         }
 271         return line * sizeof(itv->vbi.sliced_dec_data[0]);
 272 }
 273
 274 ssize_t ivtv_write_vbi(struct ivtv *itv, const char __user *ubuf, size_t count)
 275 {
 276         /* Should be a __user pointer, but sparse doesn't parse this bit correctly. */
 277         const struct v4l2_sliced_vbi_data *p = (const struct v4l2_sliced_vbi_data *)ubuf;
 278         u8 cc[4] = { 0x80, 0x80, 0x80, 0x80 };
 279         int found_cc = 0;
 280         int cc_pos = itv->vbi.cc_pos;
 281
 282         while (count >= sizeof(struct v4l2_sliced_vbi_data)) {
 283                 switch (p->id) {
 284                 case V4L2_SLICED_CAPTION_525:
 285                         if (p->line == 21) {
 286                                 found_cc = 1;
 287                                 if (p->field) {
 288                                         cc[2] = p->data[0];
 289                                         cc[3] = p->data[1];
 290                                 } else {
 291                                         cc[0] = p->data[0];
 292                                         cc[1] = p->data[1];
 293                                 }
 294                         }
 295                         break;
 296
 297                 case V4L2_SLICED_VPS:
 298                         if (p->line == 16 && p->field == 0) {
 299                                 itv->vbi.vps[0] = p->data[2];
 300                                 itv->vbi.vps[1] = p->data[8];
 301                                 itv->vbi.vps[2] = p->data[9];
 302                                 itv->vbi.vps[3] = p->data[10];
 303                                 itv->vbi.vps[4] = p->data[11];
 304                                 itv->vbi.vps_found = 1;
 305                                 set_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags);
 306                         }
 307                         break;
 308
 309                 case V4L2_SLICED_WSS_625:
 310                         if (p->line == 23 && p->field == 0) {
 311                                 /* No lock needed for WSS */
 312                                 itv->vbi.wss = p->data[0] | (p->data[1] << 8);
 313                                 itv->vbi.wss_found = 1;
 314                                 set_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags);
 315                         }
 316                         break;
 317
 318                 default:
 319                         break;
 320                 }
 321                 count -= sizeof(*p);
 322                 p++;
 323         }
 324
 325         if (found_cc && cc_pos < sizeof(itv->vbi.cc_data_even)) {
 326                 itv->vbi.cc_data_odd[cc_pos] = cc[0];
 327                 itv->vbi.cc_data_odd[cc_pos + 1] = cc[1];
 328                 itv->vbi.cc_data_even[cc_pos] = cc[2];
 329                 itv->vbi.cc_data_even[cc_pos + 1] = cc[3];
 330                 itv->vbi.cc_pos = cc_pos + 2;
 331                 set_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 332         }
 333
 334         return (const char __user *)p - ubuf;
 335 }
 336
 337 /* Compress raw VBI format, removes leading SAV codes and surplus space after the
 338    field.
 339    Returns new compressed size. */
 340 static u32 compress_raw_buf(struct ivtv *itv, u8 *buf, u32 size)
 341 {
 342         u32 line_size = itv->vbi.raw_decoder_line_size;
 343         u32 lines = itv->vbi.count;
 344         u8 sav1 = itv->vbi.raw_decoder_sav_odd_field;
 345         u8 sav2 = itv->vbi.raw_decoder_sav_even_field;
 346         u8 *q = buf;
 347         u8 *p;
 348         int i;
 349
 350         for (i = 0; i < lines; i++) {
 351                 p = buf + i * line_size;
 352
 353                 /* Look for SAV code */
 354                 if (p[0] != 0xff || p[1] || p[2] || (p[3] != sav1 && p[3] != sav2)) {
 355                         break;
 356                 }
 357                 memcpy(q, p + 4, line_size - 4);
 358                 q += line_size - 4;
 359         }
 360         return lines * (line_size - 4);
 361 }
 362
 363
 364 /* Compressed VBI format, all found sliced blocks put next to one another
 365    Returns new compressed size */
 366 static u32 compress_sliced_buf(struct ivtv *itv, u32 line, u8 *buf, u32 size, u8 sav)
 367 {
 368         u32 line_size = itv->vbi.sliced_decoder_line_size;
 369         struct v4l2_decode_vbi_line vbi;
 370         int i;
 371
 372         /* find the first valid line */
 373         for (i = 0; i < size; i++, buf++) {
 374                 if (buf[0] == 0xff && !buf[1] && !buf[2] && buf[3] == sav)
 375                         break;
 376         }
 377
 378         size -= i;
 379         if (size < line_size) {
 380                 return line;
 381         }
 382         for (i = 0; i < size / line_size; i++) {
 383                 u8 *p = buf + i * line_size;
 384
 385                 /* Look for SAV code  */
 386                 if (p[0] != 0xff || p[1] || p[2] || p[3] != sav) {
 387                         continue;
 388                 }
 389                 vbi.p = p + 4;
 390                 itv->video_dec_func(itv, VIDIOC_INT_DECODE_VBI_LINE, &vbi);
 391                 if (vbi.type) {
 392                         itv->vbi.sliced_data[line].id = vbi.type;
 393                         itv->vbi.sliced_data[line].field = vbi.is_second_field;
 394                         itv->vbi.sliced_data[line].line = vbi.line;
 395                         memcpy(itv->vbi.sliced_data[line].data, vbi.p, 42);
 396                         line++;
 397                 }
 398         }
 399         return line;
 400 }
 401
 402 void ivtv_process_vbi_data(struct ivtv *itv, struct ivtv_buffer *buf,
 403                            u64 pts_stamp, int streamtype)
 404 {
 405         u8 *p = (u8 *) buf->buf;
 406         u32 size = buf->bytesused;
 407         int y;
 408
 409         /* Raw VBI data */
 410         if (streamtype == IVTV_ENC_STREAM_TYPE_VBI && itv->vbi.sliced_in->service_set == 0) {
 411                 u8 type;
 412
 413                 ivtv_buf_swap(buf);
 414
 415                 type = p[3];
 416
 417                 size = buf->bytesused = compress_raw_buf(itv, p, size);
 418
 419                 /* second field of the frame? */
 420                 if (type == itv->vbi.raw_decoder_sav_even_field) {
 421                         /* Dirty hack needed for backwards
 422                            compatibility of old VBI software. */
 423                         p += size - 4;
 424                         memcpy(p, &itv->vbi.frame, 4);
 425                         itv->vbi.frame++;
 426                 }
 427                 return;
 428         }
 429
 430         /* Sliced VBI data with data insertion */
 431         if (streamtype == IVTV_ENC_STREAM_TYPE_VBI) {
 432                 int lines;
 433
 434                 ivtv_buf_swap(buf);
 435
 436                 /* first field */
 437                 lines = compress_sliced_buf(itv, 0, p, size / 2,
 438                         itv->vbi.sliced_decoder_sav_odd_field);
 439                 /* second field */
 440                 /* experimentation shows that the second half does not always begin
 441                    at the exact address. So start a bit earlier (hence 32). */
 442                 lines = compress_sliced_buf(itv, lines, p + size / 2 - 32, size / 2 + 32,
 443                         itv->vbi.sliced_decoder_sav_even_field);
 444                 /* always return at least one empty line */
 445                 if (lines == 0) {
 446                         itv->vbi.sliced_data[0].id = 0;
 447                         itv->vbi.sliced_data[0].line = 0;
 448                         itv->vbi.sliced_data[0].field = 0;
 449                         lines = 1;
 450                 }
 451                 buf->bytesused = size = lines * sizeof(itv->vbi.sliced_data[0]);
 452                 memcpy(p, &itv->vbi.sliced_data[0], size);
 453
 454                 if (itv->vbi.insert_mpeg) {
 455                         copy_vbi_data(itv, lines, pts_stamp);
 456                 }
 457                 itv->vbi.frame++;
 458                 return;
 459         }
 460
 461         /* Sliced VBI re-inserted from an MPEG stream */
 462         if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
 463                 /* If the size is not 4-byte aligned, then the starting address
 464                    for the swapping is also shifted. After swapping the data the
 465                    real start address of the VBI data is exactly 4 bytes after the
 466                    original start. It's a bit fiddly but it works like a charm.
 467                    Non-4-byte alignment happens when an lseek is done on the input
 468                    mpeg file to a non-4-byte aligned position. So on arrival here
 469                    the VBI data is also non-4-byte aligned. */
 470                 int offset = size & 3;
 471                 int cnt;
 472
 473                 if (offset) {
 474                         p += 4 - offset;
 475                 }
 476                 /* Swap Buffer */
 477                 for (y = 0; y < size; y += 4) {
 478                        swab32s((u32 *)(p + y));
 479                 }
 480
 481                 cnt = ivtv_convert_ivtv_vbi(itv, p + offset);
 482                 memcpy(buf->buf, itv->vbi.sliced_dec_data, cnt);
 483                 buf->bytesused = cnt;
 484
 485                 passthrough_vbi_data(itv, cnt / sizeof(itv->vbi.sliced_dec_data[0]));
 486                 return;
 487         }
 488 }
 489
 490 void ivtv_disable_vbi(struct ivtv *itv)
 491 {
 492         clear_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags);
 493         clear_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags);
 494         clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 495         ivtv_set_wss(itv, 0, 0);
 496         ivtv_set_cc(itv, 0, 0, 0, 0, 0);
 497         ivtv_set_vps(itv, 0, 0, 0, 0, 0, 0);
 498         itv->vbi.vps_found = itv->vbi.wss_found = 0;
 499         itv->vbi.wss = 0;
 500         itv->vbi.cc_pos = 0;
 501 }
 502
 503
 504 void ivtv_vbi_work_handler(struct ivtv *itv)
 505 {
 506         struct v4l2_sliced_vbi_data data;
 507
 508         /* Lock */
 509         if (itv->output_mode == OUT_PASSTHROUGH) {
 510                 /* Note: currently only the saa7115 is used in a PVR350,
 511                    so these commands are for now saa7115 specific. */
 512                 if (itv->is_50hz) {
 513                         data.id = V4L2_SLICED_WSS_625;
 514                         data.field = 0;
 515
 516                         if (itv->video_dec_func(itv, VIDIOC_INT_G_VBI_DATA, &data) == 0) {
 517                                 ivtv_set_wss(itv, 1, data.data[0] & 0xf);
 518                                 itv->vbi.wss_no_update = 0;
 519                         } else if (itv->vbi.wss_no_update == 4) {
 520                                 ivtv_set_wss(itv, 1, 0x8);  /* 4x3 full format */
 521                         } else {
 522                                 itv->vbi.wss_no_update++;
 523                         }
 524                 }
 525                 else {
 526                         u8 c1 = 0, c2 = 0, c3 = 0, c4 = 0;
 527                         int mode = 0;
 528
 529                         data.id = V4L2_SLICED_CAPTION_525;
 530                         data.field = 0;
 531                         if (itv->video_dec_func(itv, VIDIOC_INT_G_VBI_DATA, &data) == 0) {
 532                                 mode |= 1;
 533                                 c1 = data.data[0];
 534                                 c2 = data.data[1];
 535                         }
 536                         data.field = 1;
 537                         if (itv->video_dec_func(itv, VIDIOC_INT_G_VBI_DATA, &data) == 0) {
 538                                 mode |= 2;
 539                                 c3 = data.data[0];
 540                                 c4 = data.data[1];
 541                         }
 542                         if (mode) {
 543                                 itv->vbi.cc_no_update = 0;
 544                                 ivtv_set_cc(itv, mode, c1, c2, c3, c4);
 545                         } else if (itv->vbi.cc_no_update == 4) {
 546                                 ivtv_set_cc(itv, 0, 0, 0, 0, 0);
 547                         } else {
 548                                 itv->vbi.cc_no_update++;
 549                         }
 550                 }
 551                 return;
 552         }
 553
 554         if (test_and_clear_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags)) {
 555                 /* Lock */
 556                 ivtv_set_wss(itv, itv->vbi.wss_found, itv->vbi.wss & 0xf);
 557         }
 558
 559         if (test_and_clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags)) {
 560                 if (itv->vbi.cc_pos == 0) {
 561                         ivtv_set_cc(itv, 3, 0x80, 0x80, 0x80, 0x80);
 562                 }
 563                 while (itv->vbi.cc_pos) {
 564                         u8 cc_odd0 = itv->vbi.cc_data_odd[0];
 565                         u8 cc_odd1 = itv->vbi.cc_data_odd[1];
 566                         u8 cc_even0 = itv->vbi.cc_data_even[0];
 567                         u8 cc_even1 = itv->vbi.cc_data_even[1];
 568
 569                         memcpy(itv->vbi.cc_data_odd, itv->vbi.cc_data_odd + 2, sizeof(itv->vbi.cc_data_odd) - 2);
 570                         memcpy(itv->vbi.cc_data_even, itv->vbi.cc_data_even + 2, sizeof(itv->vbi.cc_data_even) - 2);
 571                         itv->vbi.cc_pos -= 2;
 572                         if (itv->vbi.cc_pos && cc_odd0 == 0x80 && cc_odd1 == 0x80)
 573                                 continue;
 574
 575                         /* Send to Saa7127 */
 576                         ivtv_set_cc(itv, 3, cc_odd0, cc_odd1, cc_even0, cc_even1);
 577                         if (itv->vbi.cc_pos == 0)
 578                                 set_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 579                         break;
 580                 }
 581         }
 582
 583         if (test_and_clear_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags)) {
 584                 /* Lock */
 585                 ivtv_set_vps(itv, itv->vbi.vps_found,
 586                         itv->vbi.vps[0], itv->vbi.vps[1],
 587                         itv->vbi.vps[2], itv->vbi.vps[3], itv->vbi.vps[4]);
 588         }
 589 }