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