drivers/media/pci/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-cards.h"
  25 #include "ivtv-vbi.h"
  26
  27 static void ivtv_set_vps(struct ivtv *itv, int enabled)
  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[2] = itv->vbi.vps_payload.data[0];
  37         data.data[8] = itv->vbi.vps_payload.data[1];
  38         data.data[9] = itv->vbi.vps_payload.data[2];
  39         data.data[10] = itv->vbi.vps_payload.data[3];
  40         data.data[11] = itv->vbi.vps_payload.data[4];
  41         ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
  42 }
  43
  44 static void ivtv_set_cc(struct ivtv *itv, int mode, const struct vbi_cc *cc)
  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] = cc->odd[0];
  54         data.data[1] = cc->odd[1];
  55         ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
  56         data.field = 1;
  57         data.line = (mode & 2) ? 21 : 0;
  58         data.data[0] = cc->even[0];
  59         data.data[1] = cc->even[1];
  60         ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, 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_out & 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_call_hw(itv, IVTV_HW_SAA7127, vbi, 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 ivtv_write_vbi_line(struct ivtv *itv,
  96                                 const struct v4l2_sliced_vbi_data *d,
  97                                 struct vbi_cc *cc, int *found_cc)
  98 {
  99         struct vbi_info *vi = &itv->vbi;
 100
 101         if (d->id == V4L2_SLICED_CAPTION_525 && d->line == 21) {
 102                 if (d->field) {
 103                         cc->even[0] = d->data[0];
 104                         cc->even[1] = d->data[1];
 105                 } else {
 106                         cc->odd[0] = d->data[0];
 107                         cc->odd[1] = d->data[1];
 108                 }
 109                 *found_cc = 1;
 110         } else if (d->id == V4L2_SLICED_VPS && d->line == 16 && d->field == 0) {
 111                 struct vbi_vps vps;
 112
 113                 vps.data[0] = d->data[2];
 114                 vps.data[1] = d->data[8];
 115                 vps.data[2] = d->data[9];
 116                 vps.data[3] = d->data[10];
 117                 vps.data[4] = d->data[11];
 118                 if (memcmp(&vps, &vi->vps_payload, sizeof(vps))) {
 119                         vi->vps_payload = vps;
 120                         set_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags);
 121                 }
 122         } else if (d->id == V4L2_SLICED_WSS_625 &&
 123                    d->line == 23 && d->field == 0) {
 124                 int wss = d->data[0] | d->data[1] << 8;
 125
 126                 if (vi->wss_payload != wss) {
 127                         vi->wss_payload = wss;
 128                         set_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags);
 129                 }
 130         }
 131 }
 132
 133 static void ivtv_write_vbi_cc_lines(struct ivtv *itv, const struct vbi_cc *cc)
 134 {
 135         struct vbi_info *vi = &itv->vbi;
 136
 137         if (vi->cc_payload_idx < ARRAY_SIZE(vi->cc_payload)) {
 138                 memcpy(&vi->cc_payload[vi->cc_payload_idx], cc,
 139                        sizeof(struct vbi_cc));
 140                 vi->cc_payload_idx++;
 141                 set_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 142         }
 143 }
 144
 145 static void ivtv_write_vbi(struct ivtv *itv,
 146                            const struct v4l2_sliced_vbi_data *sliced,
 147                            size_t cnt)
 148 {
 149         struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
 150         int found_cc = 0;
 151         size_t i;
 152
 153         for (i = 0; i < cnt; i++)
 154                 ivtv_write_vbi_line(itv, sliced + i, &cc, &found_cc);
 155
 156         if (found_cc)
 157                 ivtv_write_vbi_cc_lines(itv, &cc);
 158 }
 159
 160 ssize_t
 161 ivtv_write_vbi_from_user(struct ivtv *itv,
 162                          const struct v4l2_sliced_vbi_data __user *sliced,
 163                          size_t cnt)
 164 {
 165         struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
 166         int found_cc = 0;
 167         size_t i;
 168         struct v4l2_sliced_vbi_data d;
 169         ssize_t ret = cnt * sizeof(struct v4l2_sliced_vbi_data);
 170
 171         for (i = 0; i < cnt; i++) {
 172                 if (copy_from_user(&d, sliced + i,
 173                                    sizeof(struct v4l2_sliced_vbi_data))) {
 174                         ret = -EFAULT;
 175                         break;
 176                 }
 177                 ivtv_write_vbi_line(itv, &d, &cc, &found_cc);
 178         }
 179
 180         if (found_cc)
 181                 ivtv_write_vbi_cc_lines(itv, &cc);
 182
 183         return ret;
 184 }
 185
 186 static void copy_vbi_data(struct ivtv *itv, int lines, u32 pts_stamp)
 187 {
 188         int line = 0;
 189         int i;
 190         u32 linemask[2] = { 0, 0 };
 191         unsigned short size;
 192         static const u8 mpeg_hdr_data[] = {
 193                 0x00, 0x00, 0x01, 0xba, 0x44, 0x00, 0x0c, 0x66,
 194                 0x24, 0x01, 0x01, 0xd1, 0xd3, 0xfa, 0xff, 0xff,
 195                 0x00, 0x00, 0x01, 0xbd, 0x00, 0x1a, 0x84, 0x80,
 196                 0x07, 0x21, 0x00, 0x5d, 0x63, 0xa7, 0xff, 0xff
 197         };
 198         const int sd = sizeof(mpeg_hdr_data);   /* start of vbi data */
 199         int idx = itv->vbi.frame % IVTV_VBI_FRAMES;
 200         u8 *dst = &itv->vbi.sliced_mpeg_data[idx][0];
 201
 202         for (i = 0; i < lines; i++) {
 203                 int f, l;
 204
 205                 if (itv->vbi.sliced_data[i].id == 0)
 206                         continue;
 207
 208                 l = itv->vbi.sliced_data[i].line - 6;
 209                 f = itv->vbi.sliced_data[i].field;
 210                 if (f)
 211                         l += 18;
 212                 if (l < 32)
 213                         linemask[0] |= (1 << l);
 214                 else
 215                         linemask[1] |= (1 << (l - 32));
 216                 dst[sd + 12 + line * 43] =
 217                         ivtv_service2vbi(itv->vbi.sliced_data[i].id);
 218                 memcpy(dst + sd + 12 + line * 43 + 1, itv->vbi.sliced_data[i].data, 42);
 219                 line++;
 220         }
 221         memcpy(dst, mpeg_hdr_data, sizeof(mpeg_hdr_data));
 222         if (line == 36) {
 223                 /* All lines are used, so there is no space for the linemask
 224                    (the max size of the VBI data is 36 * 43 + 4 bytes).
 225                    So in this case we use the magic number 'ITV0'. */
 226                 memcpy(dst + sd, "ITV0", 4);
 227                 memmove(dst + sd + 4, dst + sd + 12, line * 43);
 228                 size = 4 + ((43 * line + 3) & ~3);
 229         } else {
 230                 memcpy(dst + sd, "itv0", 4);
 231                 cpu_to_le32s(&linemask[0]);
 232                 cpu_to_le32s(&linemask[1]);
 233                 memcpy(dst + sd + 4, &linemask[0], 8);
 234                 size = 12 + ((43 * line + 3) & ~3);
 235         }
 236         dst[4+16] = (size + 10) >> 8;
 237         dst[5+16] = (size + 10) & 0xff;
 238         dst[9+16] = 0x21 | ((pts_stamp >> 29) & 0x6);
 239         dst[10+16] = (pts_stamp >> 22) & 0xff;
 240         dst[11+16] = 1 | ((pts_stamp >> 14) & 0xff);
 241         dst[12+16] = (pts_stamp >> 7) & 0xff;
 242         dst[13+16] = 1 | ((pts_stamp & 0x7f) << 1);
 243         itv->vbi.sliced_mpeg_size[idx] = sd + size;
 244 }
 245
 246 static int ivtv_convert_ivtv_vbi(struct ivtv *itv, u8 *p)
 247 {
 248         u32 linemask[2];
 249         int i, l, id2;
 250         int line = 0;
 251
 252         if (!memcmp(p, "itv0", 4)) {
 253                 memcpy(linemask, p + 4, 8);
 254                 p += 12;
 255         } else if (!memcmp(p, "ITV0", 4)) {
 256                 linemask[0] = 0xffffffff;
 257                 linemask[1] = 0xf;
 258                 p += 4;
 259         } else {
 260                 /* unknown VBI data, convert to empty VBI frame */
 261                 linemask[0] = linemask[1] = 0;
 262         }
 263         for (i = 0; i < 36; i++) {
 264                 int err = 0;
 265
 266                 if (i < 32 && !(linemask[0] & (1 << i)))
 267                         continue;
 268                 if (i >= 32 && !(linemask[1] & (1 << (i - 32))))
 269                         continue;
 270                 id2 = *p & 0xf;
 271                 switch (id2) {
 272                 case IVTV_SLICED_TYPE_TELETEXT_B:
 273                         id2 = V4L2_SLICED_TELETEXT_B;
 274                         break;
 275                 case IVTV_SLICED_TYPE_CAPTION_525:
 276                         id2 = V4L2_SLICED_CAPTION_525;
 277                         err = !odd_parity(p[1]) || !odd_parity(p[2]);
 278                         break;
 279                 case IVTV_SLICED_TYPE_VPS:
 280                         id2 = V4L2_SLICED_VPS;
 281                         break;
 282                 case IVTV_SLICED_TYPE_WSS_625:
 283                         id2 = V4L2_SLICED_WSS_625;
 284                         break;
 285                 default:
 286                         id2 = 0;
 287                         break;
 288                 }
 289                 if (err == 0) {
 290                         l = (i < 18) ? i + 6 : i - 18 + 6;
 291                         itv->vbi.sliced_dec_data[line].line = l;
 292                         itv->vbi.sliced_dec_data[line].field = i >= 18;
 293                         itv->vbi.sliced_dec_data[line].id = id2;
 294                         memcpy(itv->vbi.sliced_dec_data[line].data, p + 1, 42);
 295                         line++;
 296                 }
 297                 p += 43;
 298         }
 299         while (line < 36) {
 300                 itv->vbi.sliced_dec_data[line].id = 0;
 301                 itv->vbi.sliced_dec_data[line].line = 0;
 302                 itv->vbi.sliced_dec_data[line].field = 0;
 303                 line++;
 304         }
 305         return line * sizeof(itv->vbi.sliced_dec_data[0]);
 306 }
 307
 308 /* Compress raw VBI format, removes leading SAV codes and surplus space after the
 309    field.
 310    Returns new compressed size. */
 311 static u32 compress_raw_buf(struct ivtv *itv, u8 *buf, u32 size)
 312 {
 313         u32 line_size = itv->vbi.raw_decoder_line_size;
 314         u32 lines = itv->vbi.count;
 315         u8 sav1 = itv->vbi.raw_decoder_sav_odd_field;
 316         u8 sav2 = itv->vbi.raw_decoder_sav_even_field;
 317         u8 *q = buf;
 318         u8 *p;
 319         int i;
 320
 321         for (i = 0; i < lines; i++) {
 322                 p = buf + i * line_size;
 323
 324                 /* Look for SAV code */
 325                 if (p[0] != 0xff || p[1] || p[2] || (p[3] != sav1 && p[3] != sav2)) {
 326                         break;
 327                 }
 328                 memcpy(q, p + 4, line_size - 4);
 329                 q += line_size - 4;
 330         }
 331         return lines * (line_size - 4);
 332 }
 333
 334
 335 /* Compressed VBI format, all found sliced blocks put next to one another
 336    Returns new compressed size */
 337 static u32 compress_sliced_buf(struct ivtv *itv, u32 line, u8 *buf, u32 size, u8 sav)
 338 {
 339         u32 line_size = itv->vbi.sliced_decoder_line_size;
 340         struct v4l2_decode_vbi_line vbi;
 341         int i;
 342         unsigned lines = 0;
 343
 344         /* find the first valid line */
 345         for (i = 0; i < size; i++, buf++) {
 346                 if (buf[0] == 0xff && !buf[1] && !buf[2] && buf[3] == sav)
 347                         break;
 348         }
 349
 350         size -= i;
 351         if (size < line_size) {
 352                 return line;
 353         }
 354         for (i = 0; i < size / line_size; i++) {
 355                 u8 *p = buf + i * line_size;
 356
 357                 /* Look for SAV code  */
 358                 if (p[0] != 0xff || p[1] || p[2] || p[3] != sav) {
 359                         continue;
 360                 }
 361                 vbi.p = p + 4;
 362                 v4l2_subdev_call(itv->sd_video, vbi, decode_vbi_line, &vbi);
 363                 if (vbi.type && !(lines & (1 << vbi.line))) {
 364                         lines |= 1 << vbi.line;
 365                         itv->vbi.sliced_data[line].id = vbi.type;
 366                         itv->vbi.sliced_data[line].field = vbi.is_second_field;
 367                         itv->vbi.sliced_data[line].line = vbi.line;
 368                         memcpy(itv->vbi.sliced_data[line].data, vbi.p, 42);
 369                         line++;
 370                 }
 371         }
 372         return line;
 373 }
 374
 375 void ivtv_process_vbi_data(struct ivtv *itv, struct ivtv_buffer *buf,
 376                            u64 pts_stamp, int streamtype)
 377 {
 378         u8 *p = (u8 *) buf->buf;
 379         u32 size = buf->bytesused;
 380         int y;
 381
 382         /* Raw VBI data */
 383         if (streamtype == IVTV_ENC_STREAM_TYPE_VBI && ivtv_raw_vbi(itv)) {
 384                 u8 type;
 385
 386                 ivtv_buf_swap(buf);
 387
 388                 type = p[3];
 389
 390                 size = buf->bytesused = compress_raw_buf(itv, p, size);
 391
 392                 /* second field of the frame? */
 393                 if (type == itv->vbi.raw_decoder_sav_even_field) {
 394                         /* Dirty hack needed for backwards
 395                            compatibility of old VBI software. */
 396                         p += size - 4;
 397                         memcpy(p, &itv->vbi.frame, 4);
 398                         itv->vbi.frame++;
 399                 }
 400                 return;
 401         }
 402
 403         /* Sliced VBI data with data insertion */
 404         if (streamtype == IVTV_ENC_STREAM_TYPE_VBI) {
 405                 int lines;
 406
 407                 ivtv_buf_swap(buf);
 408
 409                 /* first field */
 410                 lines = compress_sliced_buf(itv, 0, p, size / 2,
 411                         itv->vbi.sliced_decoder_sav_odd_field);
 412                 /* second field */
 413                 /* experimentation shows that the second half does not always begin
 414                    at the exact address. So start a bit earlier (hence 32). */
 415                 lines = compress_sliced_buf(itv, lines, p + size / 2 - 32, size / 2 + 32,
 416                         itv->vbi.sliced_decoder_sav_even_field);
 417                 /* always return at least one empty line */
 418                 if (lines == 0) {
 419                         itv->vbi.sliced_data[0].id = 0;
 420                         itv->vbi.sliced_data[0].line = 0;
 421                         itv->vbi.sliced_data[0].field = 0;
 422                         lines = 1;
 423                 }
 424                 buf->bytesused = size = lines * sizeof(itv->vbi.sliced_data[0]);
 425                 memcpy(p, &itv->vbi.sliced_data[0], size);
 426
 427                 if (itv->vbi.insert_mpeg) {
 428                         copy_vbi_data(itv, lines, pts_stamp);
 429                 }
 430                 itv->vbi.frame++;
 431                 return;
 432         }
 433
 434         /* Sliced VBI re-inserted from an MPEG stream */
 435         if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
 436                 /* If the size is not 4-byte aligned, then the starting address
 437                    for the swapping is also shifted. After swapping the data the
 438                    real start address of the VBI data is exactly 4 bytes after the
 439                    original start. It's a bit fiddly but it works like a charm.
 440                    Non-4-byte alignment happens when an lseek is done on the input
 441                    mpeg file to a non-4-byte aligned position. So on arrival here
 442                    the VBI data is also non-4-byte aligned. */
 443                 int offset = size & 3;
 444                 int cnt;
 445
 446                 if (offset) {
 447                         p += 4 - offset;
 448                 }
 449                 /* Swap Buffer */
 450                 for (y = 0; y < size; y += 4) {
 451                        swab32s((u32 *)(p + y));
 452                 }
 453
 454                 cnt = ivtv_convert_ivtv_vbi(itv, p + offset);
 455                 memcpy(buf->buf, itv->vbi.sliced_dec_data, cnt);
 456                 buf->bytesused = cnt;
 457
 458                 ivtv_write_vbi(itv, itv->vbi.sliced_dec_data,
 459                                cnt / sizeof(itv->vbi.sliced_dec_data[0]));
 460                 return;
 461         }
 462 }
 463
 464 void ivtv_disable_cc(struct ivtv *itv)
 465 {
 466         struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
 467
 468         clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 469         ivtv_set_cc(itv, 0, &cc);
 470         itv->vbi.cc_payload_idx = 0;
 471 }
 472
 473
 474 void ivtv_vbi_work_handler(struct ivtv *itv)
 475 {
 476         struct vbi_info *vi = &itv->vbi;
 477         struct v4l2_sliced_vbi_data data;
 478         struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
 479
 480         /* Lock */
 481         if (itv->output_mode == OUT_PASSTHROUGH) {
 482                 if (itv->is_50hz) {
 483                         data.id = V4L2_SLICED_WSS_625;
 484                         data.field = 0;
 485
 486                         if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) {
 487                                 ivtv_set_wss(itv, 1, data.data[0] & 0xf);
 488                                 vi->wss_missing_cnt = 0;
 489                         } else if (vi->wss_missing_cnt == 4) {
 490                                 ivtv_set_wss(itv, 1, 0x8);  /* 4x3 full format */
 491                         } else {
 492                                 vi->wss_missing_cnt++;
 493                         }
 494                 }
 495                 else {
 496                         int mode = 0;
 497
 498                         data.id = V4L2_SLICED_CAPTION_525;
 499                         data.field = 0;
 500                         if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) {
 501                                 mode |= 1;
 502                                 cc.odd[0] = data.data[0];
 503                                 cc.odd[1] = data.data[1];
 504                         }
 505                         data.field = 1;
 506                         if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) {
 507                                 mode |= 2;
 508                                 cc.even[0] = data.data[0];
 509                                 cc.even[1] = data.data[1];
 510                         }
 511                         if (mode) {
 512                                 vi->cc_missing_cnt = 0;
 513                                 ivtv_set_cc(itv, mode, &cc);
 514                         } else if (vi->cc_missing_cnt == 4) {
 515                                 ivtv_set_cc(itv, 0, &cc);
 516                         } else {
 517                                 vi->cc_missing_cnt++;
 518                         }
 519                 }
 520                 return;
 521         }
 522
 523         if (test_and_clear_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags)) {
 524                 ivtv_set_wss(itv, 1, vi->wss_payload & 0xf);
 525         }
 526
 527         if (test_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags)) {
 528                 if (vi->cc_payload_idx == 0) {
 529                         clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 530                         ivtv_set_cc(itv, 3, &cc);
 531                 }
 532                 while (vi->cc_payload_idx) {
 533                         cc = vi->cc_payload[0];
 534
 535                         memmove(vi->cc_payload, vi->cc_payload + 1,
 536                                         sizeof(vi->cc_payload) - sizeof(vi->cc_payload[0]));
 537                         vi->cc_payload_idx--;
 538                         if (vi->cc_payload_idx && cc.odd[0] == 0x80 && cc.odd[1] == 0x80)
 539                                 continue;
 540
 541                         ivtv_set_cc(itv, 3, &cc);
 542                         break;
 543                 }
 544         }
 545
 546         if (test_and_clear_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags)) {
 547                 ivtv_set_vps(itv, 1);
 548         }
 549 }