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