SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/pms.c

   1 /*
   2  *      Media Vision Pro Movie Studio
   3  *                      or
   4  *      "all you need is an I2C bus some RAM and a prayer"
   5  *
   6  *      This draws heavily on code
   7  *
   8  *      (c) Wolfgang Koehler,  wolf@first.gmd.de, Dec. 1994
   9  *      Kiefernring 15
  10  *      14478 Potsdam, Germany
  11  *
  12  *      Most of this code is directly derived from his userspace driver.
  13  *      His driver works so send any reports to alan@lxorguk.ukuu.org.uk
  14  *      unless the userspace driver also doesn't work for you...
  15  *
  16  *      Changes:
  17  *      25-11-2009      Hans Verkuil <hverkuil@xs4all.nl>
  18  *                      - converted to version 2 of the V4L API.
  19  *      08/07/2003      Daniele Bellucci <bellucda@tiscali.it>
  20  *                      - pms_capture: report back -EFAULT
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/delay.h>
  25 #include <linux/errno.h>
  26 #include <linux/fs.h>
  27 #include <linux/kernel.h>
  28 #include <linux/slab.h>
  29 #include <linux/mm.h>
  30 #include <linux/ioport.h>
  31 #include <linux/init.h>
  32 #include <linux/version.h>
  33 #include <linux/mutex.h>
  34 #include <linux/uaccess.h>
  35 #include <asm/io.h>
  36
  37 #include <linux/videodev2.h>
  38 #include <media/v4l2-common.h>
  39 #include <media/v4l2-ioctl.h>
  40 #include <media/v4l2-device.h>
  41
  42 MODULE_LICENSE("GPL");
  43
  44
  45 #define MOTOROLA        1
  46 #define PHILIPS2        2               /* SAA7191 */
  47 #define PHILIPS1        3
  48 #define MVVMEMORYWIDTH  0x40            /* 512 bytes */
  49
  50 struct i2c_info {
  51         u8 slave;
  52         u8 sub;
  53         u8 data;
  54         u8 hits;
  55 };
  56
  57 struct pms {
  58         struct v4l2_device v4l2_dev;
  59         struct video_device vdev;
  60         int height;
  61         int width;
  62         int depth;
  63         int input;
  64         s32 brightness, saturation, hue, contrast;
  65         unsigned long in_use;
  66         struct mutex lock;
  67         int i2c_count;
  68         struct i2c_info i2cinfo[64];
  69
  70         int decoder;
  71         int standard;   /* 0 - auto 1 - ntsc 2 - pal 3 - secam */
  72         v4l2_std_id std;
  73         int io;
  74         int data;
  75         void __iomem *mem;
  76 };
  77
  78 static struct pms pms_card;
  79
  80 /*
  81  *      I/O ports and Shared Memory
  82  */
  83
  84 static int io_port = 0x250;
  85 module_param(io_port, int, 0);
  86
  87 static int mem_base = 0xc8000;
  88 module_param(mem_base, int, 0);
  89
  90 static int video_nr = -1;
  91 module_param(video_nr, int, 0);
  92
  93
  94 static inline void mvv_write(struct pms *dev, u8 index, u8 value)
  95 {
  96         outw(index | (value << 8), dev->io);
  97 }
  98
  99 static inline u8 mvv_read(struct pms *dev, u8 index)
 100 {
 101         outb(index, dev->io);
 102         return inb(dev->data);
 103 }
 104
 105 static int pms_i2c_stat(struct pms *dev, u8 slave)
 106 {
 107         int counter = 0;
 108         int i;
 109
 110         outb(0x28, dev->io);
 111
 112         while ((inb(dev->data) & 0x01) == 0)
 113                 if (counter++ == 256)
 114                         break;
 115
 116         while ((inb(dev->data) & 0x01) != 0)
 117                 if (counter++ == 256)
 118                         break;
 119
 120         outb(slave, dev->io);
 121
 122         counter = 0;
 123         while ((inb(dev->data) & 0x01) == 0)
 124                 if (counter++ == 256)
 125                         break;
 126
 127         while ((inb(dev->data) & 0x01) != 0)
 128                 if (counter++ == 256)
 129                         break;
 130
 131         for (i = 0; i < 12; i++) {
 132                 char st = inb(dev->data);
 133
 134                 if ((st & 2) != 0)
 135                         return -1;
 136                 if ((st & 1) == 0)
 137                         break;
 138         }
 139         outb(0x29, dev->io);
 140         return inb(dev->data);
 141 }
 142
 143 static int pms_i2c_write(struct pms *dev, u16 slave, u16 sub, u16 data)
 144 {
 145         int skip = 0;
 146         int count;
 147         int i;
 148
 149         for (i = 0; i < dev->i2c_count; i++) {
 150                 if ((dev->i2cinfo[i].slave == slave) &&
 151                     (dev->i2cinfo[i].sub == sub)) {
 152                         if (dev->i2cinfo[i].data == data)
 153                                 skip = 1;
 154                         dev->i2cinfo[i].data = data;
 155                         i = dev->i2c_count + 1;
 156                 }
 157         }
 158
 159         if (i == dev->i2c_count && dev->i2c_count < 64) {
 160                 dev->i2cinfo[dev->i2c_count].slave = slave;
 161                 dev->i2cinfo[dev->i2c_count].sub = sub;
 162                 dev->i2cinfo[dev->i2c_count].data = data;
 163                 dev->i2c_count++;
 164         }
 165
 166         if (skip)
 167                 return 0;
 168
 169         mvv_write(dev, 0x29, sub);
 170         mvv_write(dev, 0x2A, data);
 171         mvv_write(dev, 0x28, slave);
 172
 173         outb(0x28, dev->io);
 174
 175         count = 0;
 176         while ((inb(dev->data) & 1) == 0)
 177                 if (count > 255)
 178                         break;
 179         while ((inb(dev->data) & 1) != 0)
 180                 if (count > 255)
 181                         break;
 182
 183         count = inb(dev->data);
 184
 185         if (count & 2)
 186                 return -1;
 187         return count;
 188 }
 189
 190 static int pms_i2c_read(struct pms *dev, int slave, int sub)
 191 {
 192         int i;
 193
 194         for (i = 0; i < dev->i2c_count; i++) {
 195                 if (dev->i2cinfo[i].slave == slave && dev->i2cinfo[i].sub == sub)
 196                         return dev->i2cinfo[i].data;
 197         }
 198         return 0;
 199 }
 200
 201
 202 static void pms_i2c_andor(struct pms *dev, int slave, int sub, int and, int or)
 203 {
 204         u8 tmp;
 205
 206         tmp = pms_i2c_read(dev, slave, sub);
 207         tmp = (tmp & and) | or;
 208         pms_i2c_write(dev, slave, sub, tmp);
 209 }
 210
 211 /*
 212  *      Control functions
 213  */
 214
 215
 216 static void pms_videosource(struct pms *dev, short source)
 217 {
 218         switch (dev->decoder) {
 219         case MOTOROLA:
 220                 break;
 221         case PHILIPS2:
 222                 pms_i2c_andor(dev, 0x8a, 0x06, 0x7f, source ? 0x80 : 0);
 223                 break;
 224         case PHILIPS1:
 225                 break;
 226         }
 227         mvv_write(dev, 0x2E, 0x31);
 228         /* Was: mvv_write(dev, 0x2E, source ? 0x31 : 0x30);
 229            But could not make this work correctly. Only Composite input
 230            worked for me. */
 231 }
 232
 233 static void pms_hue(struct pms *dev, short hue)
 234 {
 235         switch (dev->decoder) {
 236         case MOTOROLA:
 237                 pms_i2c_write(dev, 0x8a, 0x00, hue);
 238                 break;
 239         case PHILIPS2:
 240                 pms_i2c_write(dev, 0x8a, 0x07, hue);
 241                 break;
 242         case PHILIPS1:
 243                 pms_i2c_write(dev, 0x42, 0x07, hue);
 244                 break;
 245         }
 246 }
 247
 248 static void pms_saturation(struct pms *dev, short sat)
 249 {
 250         switch (dev->decoder) {
 251         case MOTOROLA:
 252                 pms_i2c_write(dev, 0x8a, 0x00, sat);
 253                 break;
 254         case PHILIPS1:
 255                 pms_i2c_write(dev, 0x42, 0x12, sat);
 256                 break;
 257         }
 258 }
 259
 260
 261 static void pms_contrast(struct pms *dev, short contrast)
 262 {
 263         switch (dev->decoder) {
 264         case MOTOROLA:
 265                 pms_i2c_write(dev, 0x8a, 0x00, contrast);
 266                 break;
 267         case PHILIPS1:
 268                 pms_i2c_write(dev, 0x42, 0x13, contrast);
 269                 break;
 270         }
 271 }
 272
 273 static void pms_brightness(struct pms *dev, short brightness)
 274 {
 275         switch (dev->decoder) {
 276         case MOTOROLA:
 277                 pms_i2c_write(dev, 0x8a, 0x00, brightness);
 278                 pms_i2c_write(dev, 0x8a, 0x00, brightness);
 279                 pms_i2c_write(dev, 0x8a, 0x00, brightness);
 280                 break;
 281         case PHILIPS1:
 282                 pms_i2c_write(dev, 0x42, 0x19, brightness);
 283                 break;
 284         }
 285 }
 286
 287
 288 static void pms_format(struct pms *dev, short format)
 289 {
 290         int target;
 291
 292         dev->standard = format;
 293
 294         if (dev->decoder == PHILIPS1)
 295                 target = 0x42;
 296         else if (dev->decoder == PHILIPS2)
 297                 target = 0x8a;
 298         else
 299                 return;
 300
 301         switch (format) {
 302         case 0: /* Auto */
 303                 pms_i2c_andor(dev, target, 0x0d, 0xfe, 0x00);
 304                 pms_i2c_andor(dev, target, 0x0f, 0x3f, 0x80);
 305                 break;
 306         case 1: /* NTSC */
 307                 pms_i2c_andor(dev, target, 0x0d, 0xfe, 0x00);
 308                 pms_i2c_andor(dev, target, 0x0f, 0x3f, 0x40);
 309                 break;
 310         case 2: /* PAL */
 311                 pms_i2c_andor(dev, target, 0x0d, 0xfe, 0x00);
 312                 pms_i2c_andor(dev, target, 0x0f, 0x3f, 0x00);
 313                 break;
 314         case 3: /* SECAM */
 315                 pms_i2c_andor(dev, target, 0x0d, 0xfe, 0x01);
 316                 pms_i2c_andor(dev, target, 0x0f, 0x3f, 0x00);
 317                 break;
 318         }
 319 }
 320
 321 #ifdef FOR_FUTURE_EXPANSION
 322
 323 /*
 324  *      These features of the PMS card are not currently exposes. They
 325  *      could become a private v4l ioctl for PMSCONFIG or somesuch if
 326  *      people need it. We also don't yet use the PMS interrupt.
 327  */
 328
 329 static void pms_hstart(struct pms *dev, short start)
 330 {
 331         switch (dev->decoder) {
 332         case PHILIPS1:
 333                 pms_i2c_write(dev, 0x8a, 0x05, start);
 334                 pms_i2c_write(dev, 0x8a, 0x18, start);
 335                 break;
 336         case PHILIPS2:
 337                 pms_i2c_write(dev, 0x42, 0x05, start);
 338                 pms_i2c_write(dev, 0x42, 0x18, start);
 339                 break;
 340         }
 341 }
 342
 343 /*
 344  *      Bandpass filters
 345  */
 346
 347 static void pms_bandpass(struct pms *dev, short pass)
 348 {
 349         if (dev->decoder == PHILIPS2)
 350                 pms_i2c_andor(dev, 0x8a, 0x06, 0xcf, (pass & 0x03) << 4);
 351         else if (dev->decoder == PHILIPS1)
 352                 pms_i2c_andor(dev, 0x42, 0x06, 0xcf, (pass & 0x03) << 4);
 353 }
 354
 355 static void pms_antisnow(struct pms *dev, short snow)
 356 {
 357         if (dev->decoder == PHILIPS2)
 358                 pms_i2c_andor(dev, 0x8a, 0x06, 0xf3, (snow & 0x03) << 2);
 359         else if (dev->decoder == PHILIPS1)
 360                 pms_i2c_andor(dev, 0x42, 0x06, 0xf3, (snow & 0x03) << 2);
 361 }
 362
 363 static void pms_sharpness(struct pms *dev, short sharp)
 364 {
 365         if (dev->decoder == PHILIPS2)
 366                 pms_i2c_andor(dev, 0x8a, 0x06, 0xfc, sharp & 0x03);
 367         else if (dev->decoder == PHILIPS1)
 368                 pms_i2c_andor(dev, 0x42, 0x06, 0xfc, sharp & 0x03);
 369 }
 370
 371 static void pms_chromaagc(struct pms *dev, short agc)
 372 {
 373         if (dev->decoder == PHILIPS2)
 374                 pms_i2c_andor(dev, 0x8a, 0x0c, 0x9f, (agc & 0x03) << 5);
 375         else if (dev->decoder == PHILIPS1)
 376                 pms_i2c_andor(dev, 0x42, 0x0c, 0x9f, (agc & 0x03) << 5);
 377 }
 378
 379 static void pms_vertnoise(struct pms *dev, short noise)
 380 {
 381         if (dev->decoder == PHILIPS2)
 382                 pms_i2c_andor(dev, 0x8a, 0x10, 0xfc, noise & 3);
 383         else if (dev->decoder == PHILIPS1)
 384                 pms_i2c_andor(dev, 0x42, 0x10, 0xfc, noise & 3);
 385 }
 386
 387 static void pms_forcecolour(struct pms *dev, short colour)
 388 {
 389         if (dev->decoder == PHILIPS2)
 390                 pms_i2c_andor(dev, 0x8a, 0x0c, 0x7f, (colour & 1) << 7);
 391         else if (dev->decoder == PHILIPS1)
 392                 pms_i2c_andor(dev, 0x42, 0x0c, 0x7, (colour & 1) << 7);
 393 }
 394
 395 static void pms_antigamma(struct pms *dev, short gamma)
 396 {
 397         if (dev->decoder == PHILIPS2)
 398                 pms_i2c_andor(dev, 0xb8, 0x00, 0x7f, (gamma & 1) << 7);
 399         else if (dev->decoder == PHILIPS1)
 400                 pms_i2c_andor(dev, 0x42, 0x20, 0x7, (gamma & 1) << 7);
 401 }
 402
 403 static void pms_prefilter(struct pms *dev, short filter)
 404 {
 405         if (dev->decoder == PHILIPS2)
 406                 pms_i2c_andor(dev, 0x8a, 0x06, 0xbf, (filter & 1) << 6);
 407         else if (dev->decoder == PHILIPS1)
 408                 pms_i2c_andor(dev, 0x42, 0x06, 0xbf, (filter & 1) << 6);
 409 }
 410
 411 static void pms_hfilter(struct pms *dev, short filter)
 412 {
 413         if (dev->decoder == PHILIPS2)
 414                 pms_i2c_andor(dev, 0xb8, 0x04, 0x1f, (filter & 7) << 5);
 415         else if (dev->decoder == PHILIPS1)
 416                 pms_i2c_andor(dev, 0x42, 0x24, 0x1f, (filter & 7) << 5);
 417 }
 418
 419 static void pms_vfilter(struct pms *dev, short filter)
 420 {
 421         if (dev->decoder == PHILIPS2)
 422                 pms_i2c_andor(dev, 0xb8, 0x08, 0x9f, (filter & 3) << 5);
 423         else if (dev->decoder == PHILIPS1)
 424                 pms_i2c_andor(dev, 0x42, 0x28, 0x9f, (filter & 3) << 5);
 425 }
 426
 427 static void pms_killcolour(struct pms *dev, short colour)
 428 {
 429         if (dev->decoder == PHILIPS2) {
 430                 pms_i2c_andor(dev, 0x8a, 0x08, 0x07, (colour & 0x1f) << 3);
 431                 pms_i2c_andor(dev, 0x8a, 0x09, 0x07, (colour & 0x1f) << 3);
 432         } else if (dev->decoder == PHILIPS1) {
 433                 pms_i2c_andor(dev, 0x42, 0x08, 0x07, (colour & 0x1f) << 3);
 434                 pms_i2c_andor(dev, 0x42, 0x09, 0x07, (colour & 0x1f) << 3);
 435         }
 436 }
 437
 438 static void pms_chromagain(struct pms *dev, short chroma)
 439 {
 440         if (dev->decoder == PHILIPS2)
 441                 pms_i2c_write(dev, 0x8a, 0x11, chroma);
 442         else if (dev->decoder == PHILIPS1)
 443                 pms_i2c_write(dev, 0x42, 0x11, chroma);
 444 }
 445
 446
 447 static void pms_spacialcompl(struct pms *dev, short data)
 448 {
 449         mvv_write(dev, 0x3b, data);
 450 }
 451
 452 static void pms_spacialcomph(struct pms *dev, short data)
 453 {
 454         mvv_write(dev, 0x3a, data);
 455 }
 456
 457 static void pms_vstart(struct pms *dev, short start)
 458 {
 459         mvv_write(dev, 0x16, start);
 460         mvv_write(dev, 0x17, (start >> 8) & 0x01);
 461 }
 462
 463 #endif
 464
 465 static void pms_secamcross(struct pms *dev, short cross)
 466 {
 467         if (dev->decoder == PHILIPS2)
 468                 pms_i2c_andor(dev, 0x8a, 0x0f, 0xdf, (cross & 1) << 5);
 469         else if (dev->decoder == PHILIPS1)
 470                 pms_i2c_andor(dev, 0x42, 0x0f, 0xdf, (cross & 1) << 5);
 471 }
 472
 473
 474 static void pms_swsense(struct pms *dev, short sense)
 475 {
 476         if (dev->decoder == PHILIPS2) {
 477                 pms_i2c_write(dev, 0x8a, 0x0a, sense);
 478                 pms_i2c_write(dev, 0x8a, 0x0b, sense);
 479         } else if (dev->decoder == PHILIPS1) {
 480                 pms_i2c_write(dev, 0x42, 0x0a, sense);
 481                 pms_i2c_write(dev, 0x42, 0x0b, sense);
 482         }
 483 }
 484
 485
 486 static void pms_framerate(struct pms *dev, short frr)
 487 {
 488         int fps = (dev->std & V4L2_STD_525_60) ? 30 : 25;
 489
 490         if (frr == 0)
 491                 return;
 492         fps = fps/frr;
 493         mvv_write(dev, 0x14, 0x80 | fps);
 494         mvv_write(dev, 0x15, 1);
 495 }
 496
 497 static void pms_vert(struct pms *dev, u8 deciden, u8 decinum)
 498 {
 499         mvv_write(dev, 0x1c, deciden);  /* Denominator */
 500         mvv_write(dev, 0x1d, decinum);  /* Numerator */
 501 }
 502
 503 /*
 504  *      Turn 16bit ratios into best small ratio the chipset can grok
 505  */
 506
 507 static void pms_vertdeci(struct pms *dev, unsigned short decinum, unsigned short deciden)
 508 {
 509         /* Knock it down by / 5 once */
 510         if (decinum % 5 == 0) {
 511                 deciden /= 5;
 512                 decinum /= 5;
 513         }
 514         /*
 515          *      3's
 516          */
 517         while (decinum % 3 == 0 && deciden % 3 == 0) {
 518                 deciden /= 3;
 519                 decinum /= 3;
 520         }
 521         /*
 522          *      2's
 523          */
 524         while (decinum % 2 == 0 && deciden % 2 == 0) {
 525                 decinum /= 2;
 526                 deciden /= 2;
 527         }
 528         /*
 529          *      Fudgyify
 530          */
 531         while (deciden > 32) {
 532                 deciden /= 2;
 533                 decinum = (decinum + 1) / 2;
 534         }
 535         if (deciden == 32)
 536                 deciden--;
 537         pms_vert(dev, deciden, decinum);
 538 }
 539
 540 static void pms_horzdeci(struct pms *dev, short decinum, short deciden)
 541 {
 542         if (decinum <= 512) {
 543                 if (decinum % 5 == 0) {
 544                         decinum /= 5;
 545                         deciden /= 5;
 546                 }
 547         } else {
 548                 decinum = 512;
 549                 deciden = 640;  /* 768 would be ideal */
 550         }
 551
 552         while (((decinum | deciden) & 1) == 0) {
 553                 decinum >>= 1;
 554                 deciden >>= 1;
 555         }
 556         while (deciden > 32) {
 557                 deciden >>= 1;
 558                 decinum = (decinum + 1) >> 1;
 559         }
 560         if (deciden == 32)
 561                 deciden--;
 562
 563         mvv_write(dev, 0x24, 0x80 | deciden);
 564         mvv_write(dev, 0x25, decinum);
 565 }
 566
 567 static void pms_resolution(struct pms *dev, short width, short height)
 568 {
 569         int fg_height;
 570
 571         fg_height = height;
 572         if (fg_height > 280)
 573                 fg_height = 280;
 574
 575         mvv_write(dev, 0x18, fg_height);
 576         mvv_write(dev, 0x19, fg_height >> 8);
 577
 578         if (dev->std & V4L2_STD_525_60) {
 579                 mvv_write(dev, 0x1a, 0xfc);
 580                 mvv_write(dev, 0x1b, 0x00);
 581                 if (height > fg_height)
 582                         pms_vertdeci(dev, 240, 240);
 583                 else
 584                         pms_vertdeci(dev, fg_height, 240);
 585         } else {
 586                 mvv_write(dev, 0x1a, 0x1a);
 587                 mvv_write(dev, 0x1b, 0x01);
 588                 if (fg_height > 256)
 589                         pms_vertdeci(dev, 270, 270);
 590                 else
 591                         pms_vertdeci(dev, fg_height, 270);
 592         }
 593         mvv_write(dev, 0x12, 0);
 594         mvv_write(dev, 0x13, MVVMEMORYWIDTH);
 595         mvv_write(dev, 0x42, 0x00);
 596         mvv_write(dev, 0x43, 0x00);
 597         mvv_write(dev, 0x44, MVVMEMORYWIDTH);
 598
 599         mvv_write(dev, 0x22, width + 8);
 600         mvv_write(dev, 0x23, (width + 8) >> 8);
 601
 602         if (dev->std & V4L2_STD_525_60)
 603                 pms_horzdeci(dev, width, 640);
 604         else
 605                 pms_horzdeci(dev, width + 8, 768);
 606
 607         mvv_write(dev, 0x30, mvv_read(dev, 0x30) & 0xfe);
 608         mvv_write(dev, 0x08, mvv_read(dev, 0x08) | 0x01);
 609         mvv_write(dev, 0x01, mvv_read(dev, 0x01) & 0xfd);
 610         mvv_write(dev, 0x32, 0x00);
 611         mvv_write(dev, 0x33, MVVMEMORYWIDTH);
 612 }
 613
 614
 615 /*
 616  *      Set Input
 617  */
 618
 619 static void pms_vcrinput(struct pms *dev, short input)
 620 {
 621         if (dev->decoder == PHILIPS2)
 622                 pms_i2c_andor(dev, 0x8a, 0x0d, 0x7f, (input & 1) << 7);
 623         else if (dev->decoder == PHILIPS1)
 624                 pms_i2c_andor(dev, 0x42, 0x0d, 0x7f, (input & 1) << 7);
 625 }
 626
 627
 628 static int pms_capture(struct pms *dev, char __user *buf, int rgb555, int count)
 629 {
 630         int y;
 631         int dw = 2 * dev->width;
 632         char tmp[dw + 32]; /* using a temp buffer is faster than direct  */
 633         int cnt = 0;
 634         int len = 0;
 635         unsigned char r8 = 0x5;  /* value for reg8  */
 636
 637         if (rgb555)
 638                 r8 |= 0x20; /* else use untranslated rgb = 565 */
 639         mvv_write(dev, 0x08, r8); /* capture rgb555/565, init DRAM, PC enable */
 640
 641 /*      printf("%d %d %d %d %d %x %x\n",width,height,voff,nom,den,mvv_buf); */
 642
 643         for (y = 0; y < dev->height; y++) {
 644                 writeb(0, dev->mem);  /* synchronisiert neue Zeile */
 645
 646                 /*
 647                  *      This is in truth a fifo, be very careful as if you
 648                  *      forgot this odd things will occur 8)
 649                  */
 650
 651                 memcpy_fromio(tmp, dev->mem, dw + 32); /* discard 16 word   */
 652                 cnt -= dev->height;
 653                 while (cnt <= 0) {
 654                         /*
 655                          *      Don't copy too far
 656                          */
 657                         int dt = dw;
 658                         if (dt + len > count)
 659                                 dt = count - len;
 660                         cnt += dev->height;
 661                         if (copy_to_user(buf, tmp + 32, dt))
 662                                 return len ? len : -EFAULT;
 663                         buf += dt;
 664                         len += dt;
 665                 }
 666         }
 667         return len;
 668 }
 669
 670
 671 /*
 672  *      Video4linux interfacing
 673  */
 674
 675 static int pms_querycap(struct file *file, void  *priv,
 676                                         struct v4l2_capability *vcap)
 677 {
 678         struct pms *dev = video_drvdata(file);
 679
 680         strlcpy(vcap->driver, dev->v4l2_dev.name, sizeof(vcap->driver));
 681         strlcpy(vcap->card, "Mediavision PMS", sizeof(vcap->card));
 682         strlcpy(vcap->bus_info, "ISA", sizeof(vcap->bus_info));
 683         vcap->version = KERNEL_VERSION(0, 0, 3);
 684         vcap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
 685         return 0;
 686 }
 687
 688 static int pms_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
 689 {
 690         static const char *inputs[4] = {
 691                 "Composite",
 692                 "S-Video",
 693                 "Composite (VCR)",
 694                 "S-Video (VCR)"
 695         };
 696
 697         if (vin->index > 3)
 698                 return -EINVAL;
 699         strlcpy(vin->name, inputs[vin->index], sizeof(vin->name));
 700         vin->type = V4L2_INPUT_TYPE_CAMERA;
 701         vin->audioset = 0;
 702         vin->tuner = 0;
 703         vin->std = V4L2_STD_ALL;
 704         vin->status = 0;
 705         return 0;
 706 }
 707
 708 static int pms_g_input(struct file *file, void *fh, unsigned int *inp)
 709 {
 710         struct pms *dev = video_drvdata(file);
 711
 712         *inp = dev->input;
 713         return 0;
 714 }
 715
 716 static int pms_s_input(struct file *file, void *fh, unsigned int inp)
 717 {
 718         struct pms *dev = video_drvdata(file);
 719
 720         if (inp > 3)
 721                 return -EINVAL;
 722
 723         mutex_lock(&dev->lock);
 724         dev->input = inp;
 725         pms_videosource(dev, inp & 1);
 726         pms_vcrinput(dev, inp >> 1);
 727         mutex_unlock(&dev->lock);
 728         return 0;
 729 }
 730
 731 static int pms_g_std(struct file *file, void *fh, v4l2_std_id *std)
 732 {
 733         struct pms *dev = video_drvdata(file);
 734
 735         *std = dev->std;
 736         return 0;
 737 }
 738
 739 static int pms_s_std(struct file *file, void *fh, v4l2_std_id *std)
 740 {
 741         struct pms *dev = video_drvdata(file);
 742         int ret = 0;
 743
 744         dev->std = *std;
 745         mutex_lock(&dev->lock);
 746         if (dev->std & V4L2_STD_NTSC) {
 747                 pms_framerate(dev, 30);
 748                 pms_secamcross(dev, 0);
 749                 pms_format(dev, 1);
 750         } else if (dev->std & V4L2_STD_PAL) {
 751                 pms_framerate(dev, 25);
 752                 pms_secamcross(dev, 0);
 753                 pms_format(dev, 2);
 754         } else if (dev->std & V4L2_STD_SECAM) {
 755                 pms_framerate(dev, 25);
 756                 pms_secamcross(dev, 1);
 757                 pms_format(dev, 2);
 758         } else {
 759                 ret = -EINVAL;
 760         }
 761         /*
 762         switch (v->mode) {
 763         case VIDEO_MODE_AUTO:
 764                 pms_framerate(dev, 25);
 765                 pms_secamcross(dev, 0);
 766                 pms_format(dev, 0);
 767                 break;
 768         }*/
 769         mutex_unlock(&dev->lock);
 770         return 0;
 771 }
 772
 773 static int pms_queryctrl(struct file *file, void *priv,
 774                                         struct v4l2_queryctrl *qc)
 775 {
 776         switch (qc->id) {
 777         case V4L2_CID_BRIGHTNESS:
 778                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 139);
 779         case V4L2_CID_CONTRAST:
 780                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 70);
 781         case V4L2_CID_SATURATION:
 782                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 64);
 783         case V4L2_CID_HUE:
 784                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 0);
 785         }
 786         return -EINVAL;
 787 }
 788
 789 static int pms_g_ctrl(struct file *file, void *priv,
 790                                         struct v4l2_control *ctrl)
 791 {
 792         struct pms *dev = video_drvdata(file);
 793         int ret = 0;
 794
 795         switch (ctrl->id) {
 796         case V4L2_CID_BRIGHTNESS:
 797                 ctrl->value = dev->brightness;
 798                 break;
 799         case V4L2_CID_CONTRAST:
 800                 ctrl->value = dev->contrast;
 801                 break;
 802         case V4L2_CID_SATURATION:
 803                 ctrl->value = dev->saturation;
 804                 break;
 805         case V4L2_CID_HUE:
 806                 ctrl->value = dev->hue;
 807                 break;
 808         default:
 809                 ret = -EINVAL;
 810                 break;
 811         }
 812         return ret;
 813 }
 814
 815 static int pms_s_ctrl(struct file *file, void *priv,
 816                                         struct v4l2_control *ctrl)
 817 {
 818         struct pms *dev = video_drvdata(file);
 819         int ret = 0;
 820
 821         mutex_lock(&dev->lock);
 822         switch (ctrl->id) {
 823         case V4L2_CID_BRIGHTNESS:
 824                 dev->brightness = ctrl->value;
 825                 pms_brightness(dev, dev->brightness);
 826                 break;
 827         case V4L2_CID_CONTRAST:
 828                 dev->contrast = ctrl->value;
 829                 pms_contrast(dev, dev->contrast);
 830                 break;
 831         case V4L2_CID_SATURATION:
 832                 dev->saturation = ctrl->value;
 833                 pms_saturation(dev, dev->saturation);
 834                 break;
 835         case V4L2_CID_HUE:
 836                 dev->hue = ctrl->value;
 837                 pms_hue(dev, dev->hue);
 838                 break;
 839         default:
 840                 ret = -EINVAL;
 841                 break;
 842         }
 843         mutex_unlock(&dev->lock);
 844         return ret;
 845 }
 846
 847 static int pms_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 848 {
 849         struct pms *dev = video_drvdata(file);
 850         struct v4l2_pix_format *pix = &fmt->fmt.pix;
 851
 852         pix->width = dev->width;
 853         pix->height = dev->height;
 854         pix->pixelformat = dev->width == 15 ?
 855                             V4L2_PIX_FMT_RGB555 : V4L2_PIX_FMT_RGB565;
 856         pix->field = V4L2_FIELD_NONE;
 857         pix->bytesperline = 2 * dev->width;
 858         pix->sizeimage = 2 * dev->width * dev->height;
 859         /* Just a guess */
 860         pix->colorspace = V4L2_COLORSPACE_SRGB;
 861         return 0;
 862 }
 863
 864 static int pms_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 865 {
 866         struct v4l2_pix_format *pix = &fmt->fmt.pix;
 867
 868         if (pix->height < 16 || pix->height > 480)
 869                 return -EINVAL;
 870         if (pix->width < 16 || pix->width > 640)
 871                 return -EINVAL;
 872         if (pix->pixelformat != V4L2_PIX_FMT_RGB555 &&
 873             pix->pixelformat != V4L2_PIX_FMT_RGB565)
 874                 return -EINVAL;
 875         pix->field = V4L2_FIELD_NONE;
 876         pix->bytesperline = 2 * pix->width;
 877         pix->sizeimage = 2 * pix->width * pix->height;
 878         /* Just a guess */
 879         pix->colorspace = V4L2_COLORSPACE_SRGB;
 880         return 0;
 881 }
 882
 883 static int pms_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 884 {
 885         struct pms *dev = video_drvdata(file);
 886         struct v4l2_pix_format *pix = &fmt->fmt.pix;
 887         int ret = pms_try_fmt_vid_cap(file, fh, fmt);
 888
 889         if (ret)
 890                 return ret;
 891         mutex_lock(&dev->lock);
 892         dev->width = pix->width;
 893         dev->height = pix->height;
 894         dev->depth = (pix->pixelformat == V4L2_PIX_FMT_RGB555) ? 15 : 16;
 895         pms_resolution(dev, dev->width, dev->height);
 896         /* Ok we figured out what to use from our wide choice */
 897         mutex_unlock(&dev->lock);
 898         return 0;
 899 }
 900
 901 static int pms_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 902 {
 903         static struct v4l2_fmtdesc formats[] = {
 904                 { 0, 0, 0,
 905                   "RGB 5:5:5", V4L2_PIX_FMT_RGB555,
 906                   { 0, 0, 0, 0 }
 907                 },
 908                 { 0, 0, 0,
 909                   "RGB 5:6:5", V4L2_PIX_FMT_RGB565,
 910                   { 0, 0, 0, 0 }
 911                 },
 912         };
 913         enum v4l2_buf_type type = fmt->type;
 914
 915         if (fmt->index > 1)
 916                 return -EINVAL;
 917
 918         *fmt = formats[fmt->index];
 919         fmt->type = type;
 920         return 0;
 921 }
 922
 923 static ssize_t pms_read(struct file *file, char __user *buf,
 924                     size_t count, loff_t *ppos)
 925 {
 926         struct pms *dev = video_drvdata(file);
 927         int len;
 928
 929         mutex_lock(&dev->lock);
 930         len = pms_capture(dev, buf, (dev->depth == 15), count);
 931         mutex_unlock(&dev->lock);
 932         return len;
 933 }
 934
 935 static int pms_exclusive_open(struct file *file)
 936 {
 937         struct pms *dev = video_drvdata(file);
 938
 939         return test_and_set_bit(0, &dev->in_use) ? -EBUSY : 0;
 940 }
 941
 942 static int pms_exclusive_release(struct file *file)
 943 {
 944         struct pms *dev = video_drvdata(file);
 945
 946         clear_bit(0, &dev->in_use);
 947         return 0;
 948 }
 949
 950 static const struct v4l2_file_operations pms_fops = {
 951         .owner          = THIS_MODULE,
 952         .open           = pms_exclusive_open,
 953         .release        = pms_exclusive_release,
 954         .ioctl          = video_ioctl2,
 955         .read           = pms_read,
 956 };
 957
 958 static const struct v4l2_ioctl_ops pms_ioctl_ops = {
 959         .vidioc_querycap                    = pms_querycap,
 960         .vidioc_g_input                     = pms_g_input,
 961         .vidioc_s_input                     = pms_s_input,
 962         .vidioc_enum_input                  = pms_enum_input,
 963         .vidioc_g_std                       = pms_g_std,
 964         .vidioc_s_std                       = pms_s_std,
 965         .vidioc_queryctrl                   = pms_queryctrl,
 966         .vidioc_g_ctrl                      = pms_g_ctrl,
 967         .vidioc_s_ctrl                      = pms_s_ctrl,
 968         .vidioc_enum_fmt_vid_cap            = pms_enum_fmt_vid_cap,
 969         .vidioc_g_fmt_vid_cap               = pms_g_fmt_vid_cap,
 970         .vidioc_s_fmt_vid_cap               = pms_s_fmt_vid_cap,
 971         .vidioc_try_fmt_vid_cap             = pms_try_fmt_vid_cap,
 972 };
 973
 974 /*
 975  *      Probe for and initialise the Mediavision PMS
 976  */
 977
 978 static int init_mediavision(struct pms *dev)
 979 {
 980         int id;
 981         int idec, decst;
 982         int i;
 983         static const unsigned char i2c_defs[] = {
 984                 0x4c, 0x30, 0x00, 0xe8,
 985                 0xb6, 0xe2, 0x00, 0x00,
 986                 0xff, 0xff, 0x00, 0x00,
 987                 0x00, 0x00, 0x78, 0x98,
 988                 0x00, 0x00, 0x00, 0x00,
 989                 0x34, 0x0a, 0xf4, 0xce,
 990                 0xe4
 991         };
 992
 993         dev->mem = ioremap(mem_base, 0x800);
 994         if (!dev->mem)
 995                 return -ENOMEM;
 996
 997         if (!request_region(0x9a01, 1, "Mediavision PMS config")) {
 998                 printk(KERN_WARNING "mediavision: unable to detect: 0x9a01 in use.\n");
 999                 iounmap(dev->mem);
1000                 return -EBUSY;
1001         }
1002         if (!request_region(dev->io, 3, "Mediavision PMS")) {
1003                 printk(KERN_WARNING "mediavision: I/O port %d in use.\n", dev->io);
1004                 release_region(0x9a01, 1);
1005                 iounmap(dev->mem);
1006                 return -EBUSY;
1007         }
1008         outb(0xb8, 0x9a01);             /* Unlock */
1009         outb(dev->io >> 4, 0x9a01);     /* Set IO port */
1010
1011
1012         id = mvv_read(dev, 3);
1013         decst = pms_i2c_stat(dev, 0x43);
1014
1015         if (decst != -1)
1016                 idec = 2;
1017         else if (pms_i2c_stat(dev, 0xb9) != -1)
1018                 idec = 3;
1019         else if (pms_i2c_stat(dev, 0x8b) != -1)
1020                 idec = 1;
1021         else
1022                 idec = 0;
1023
1024         printk(KERN_INFO "PMS type is %d\n", idec);
1025         if (idec == 0) {
1026                 release_region(dev->io, 3);
1027                 release_region(0x9a01, 1);
1028                 iounmap(dev->mem);
1029                 return -ENODEV;
1030         }
1031
1032         /*
1033          *      Ok we have a PMS of some sort
1034          */
1035
1036         mvv_write(dev, 0x04, mem_base >> 12);   /* Set the memory area */
1037
1038         /* Ok now load the defaults */
1039
1040         for (i = 0; i < 0x19; i++) {
1041                 if (i2c_defs[i] == 0xff)
1042                         pms_i2c_andor(dev, 0x8a, i, 0x07, 0x00);
1043                 else
1044                         pms_i2c_write(dev, 0x8a, i, i2c_defs[i]);
1045         }
1046
1047         pms_i2c_write(dev, 0xb8, 0x00, 0x12);
1048         pms_i2c_write(dev, 0xb8, 0x04, 0x00);
1049         pms_i2c_write(dev, 0xb8, 0x07, 0x00);
1050         pms_i2c_write(dev, 0xb8, 0x08, 0x00);
1051         pms_i2c_write(dev, 0xb8, 0x09, 0xff);
1052         pms_i2c_write(dev, 0xb8, 0x0a, 0x00);
1053         pms_i2c_write(dev, 0xb8, 0x0b, 0x10);
1054         pms_i2c_write(dev, 0xb8, 0x10, 0x03);
1055
1056         mvv_write(dev, 0x01, 0x00);
1057         mvv_write(dev, 0x05, 0xa0);
1058         mvv_write(dev, 0x08, 0x25);
1059         mvv_write(dev, 0x09, 0x00);
1060         mvv_write(dev, 0x0a, 0x20 | MVVMEMORYWIDTH);
1061
1062         mvv_write(dev, 0x10, 0x02);
1063         mvv_write(dev, 0x1e, 0x0c);
1064         mvv_write(dev, 0x1f, 0x03);
1065         mvv_write(dev, 0x26, 0x06);
1066
1067         mvv_write(dev, 0x2b, 0x00);
1068         mvv_write(dev, 0x2c, 0x20);
1069         mvv_write(dev, 0x2d, 0x00);
1070         mvv_write(dev, 0x2f, 0x70);
1071         mvv_write(dev, 0x32, 0x00);
1072         mvv_write(dev, 0x33, MVVMEMORYWIDTH);
1073         mvv_write(dev, 0x34, 0x00);
1074         mvv_write(dev, 0x35, 0x00);
1075         mvv_write(dev, 0x3a, 0x80);
1076         mvv_write(dev, 0x3b, 0x10);
1077         mvv_write(dev, 0x20, 0x00);
1078         mvv_write(dev, 0x21, 0x00);
1079         mvv_write(dev, 0x30, 0x22);
1080         return 0;
1081 }
1082
1083 /*
1084  *      Initialization and module stuff
1085  */
1086
1087 #ifndef MODULE
1088 static int enable;
1089 module_param(enable, int, 0);
1090 #endif
1091
1092 static int __init pms_init(void)
1093 {
1094         struct pms *dev = &pms_card;
1095         struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
1096         int res;
1097
1098         strlcpy(v4l2_dev->name, "pms", sizeof(v4l2_dev->name));
1099
1100         v4l2_info(v4l2_dev, "Mediavision Pro Movie Studio driver 0.03\n");
1101
1102 #ifndef MODULE
1103         if (!enable) {
1104                 v4l2_err(v4l2_dev,
1105                         "PMS: not enabled, use pms.enable=1 to probe\n");
1106                 return -ENODEV;
1107         }
1108 #endif
1109
1110         dev->decoder = PHILIPS2;
1111         dev->io = io_port;
1112         dev->data = io_port + 1;
1113
1114         if (init_mediavision(dev)) {
1115                 v4l2_err(v4l2_dev, "Board not found.\n");
1116                 return -ENODEV;
1117         }
1118
1119         res = v4l2_device_register(NULL, v4l2_dev);
1120         if (res < 0) {
1121                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1122                 return res;
1123         }
1124
1125         strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));
1126         dev->vdev.v4l2_dev = v4l2_dev;
1127         dev->vdev.fops = &pms_fops;
1128         dev->vdev.ioctl_ops = &pms_ioctl_ops;
1129         dev->vdev.release = video_device_release_empty;
1130         video_set_drvdata(&dev->vdev, dev);
1131         mutex_init(&dev->lock);
1132         dev->std = V4L2_STD_NTSC_M;
1133         dev->height = 240;
1134         dev->width = 320;
1135         dev->depth = 15;
1136         dev->brightness = 139;
1137         dev->contrast = 70;
1138         dev->hue = 0;
1139         dev->saturation = 64;
1140         pms_swsense(dev, 75);
1141         pms_resolution(dev, 320, 240);
1142         pms_videosource(dev, 0);
1143         pms_vcrinput(dev, 0);
1144         if (video_register_device(&dev->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
1145                 v4l2_device_unregister(&dev->v4l2_dev);
1146                 release_region(dev->io, 3);
1147                 release_region(0x9a01, 1);
1148                 iounmap(dev->mem);
1149                 return -EINVAL;
1150         }
1151         return 0;
1152 }
1153
1154 static void __exit pms_exit(void)
1155 {
1156         struct pms *dev = &pms_card;
1157
1158         video_unregister_device(&dev->vdev);
1159         release_region(dev->io, 3);
1160         release_region(0x9a01, 1);
1161         iounmap(dev->mem);
1162 }
1163
1164 module_init(pms_init);
1165 module_exit(pms_exit);