drivers/media/video/zoran_card.c

   1 /*
   2  * Zoran zr36057/zr36067 PCI controller driver, for the
   3  * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
   4  * Media Labs LML33/LML33R10.
   5  *
   6  * This part handles card-specific data and detection
   7  *
   8  * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
   9  *
  10  * Currently maintained by:
  11  *   Ronald Bultje    <rbultje@ronald.bitfreak.net>
  12  *   Laurent Pinchart <laurent.pinchart@skynet.be>
  13  *   Mailinglist      <mjpeg-users@lists.sf.net>
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28  */
  29
  30 #include <linux/delay.h>
  31
  32 #include <linux/types.h>
  33 #include <linux/kernel.h>
  34 #include <linux/module.h>
  35 #include <linux/init.h>
  36 #include <linux/vmalloc.h>
  37
  38 #include <linux/proc_fs.h>
  39 #include <linux/i2c.h>
  40 #include <linux/i2c-algo-bit.h>
  41 #include <linux/videodev.h>
  42 #include <media/v4l2-common.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/sem.h>
  45 #include <linux/kmod.h>
  46 #include <linux/wait.h>
  47
  48 #include <linux/pci.h>
  49 #include <linux/interrupt.h>
  50 #include <linux/video_decoder.h>
  51 #include <linux/video_encoder.h>
  52 #include <linux/mutex.h>
  53
  54 #include <asm/io.h>
  55
  56 #include "videocodec.h"
  57 #include "zoran.h"
  58 #include "zoran_card.h"
  59 #include "zoran_device.h"
  60 #include "zoran_procfs.h"
  61
  62 #define I2C_NAME(x) (x)->name
  63
  64 extern const struct zoran_format zoran_formats[];
  65
  66 static int card[BUZ_MAX] = { -1, -1, -1, -1 };
  67 module_param_array(card, int, NULL, 0444);
  68 MODULE_PARM_DESC(card, "The type of card");
  69
  70 static int encoder[BUZ_MAX] = { -1, -1, -1, -1 };
  71 module_param_array(encoder, int, NULL, 0444);
  72 MODULE_PARM_DESC(encoder, "i2c TV encoder");
  73
  74 static int decoder[BUZ_MAX] = { -1, -1, -1, -1 };
  75 module_param_array(decoder, int, NULL, 0444);
  76 MODULE_PARM_DESC(decoder, "i2c TV decoder");
  77
  78 /*
  79    The video mem address of the video card.
  80    The driver has a little database for some videocards
  81    to determine it from there. If your video card is not in there
  82    you have either to give it to the driver as a parameter
  83    or set in in a VIDIOCSFBUF ioctl
  84  */
  85
  86 static unsigned long vidmem = 0;        /* Video memory base address */
  87 module_param(vidmem, ulong, 0444);
  88 MODULE_PARM_DESC(vidmem, "Default video memory base address");
  89
  90 /*
  91    Default input and video norm at startup of the driver.
  92 */
  93
  94 static unsigned int default_input = 0;  /* 0=Composite, 1=S-Video */
  95 module_param(default_input, uint, 0444);
  96 MODULE_PARM_DESC(default_input,
  97                  "Default input (0=Composite, 1=S-Video, 2=Internal)");
  98
  99 static int default_mux = 1;     /* 6 Eyes input selection */
 100 module_param(default_mux, int, 0644);
 101 MODULE_PARM_DESC(default_mux,
 102                  "Default 6 Eyes mux setting (Input selection)");
 103
 104 static int default_norm = 0;    /* 0=PAL, 1=NTSC 2=SECAM */
 105 module_param(default_norm, int, 0444);
 106 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
 107
 108 /* /dev/videoN, -1 for autodetect */
 109 static int video_nr[BUZ_MAX] = {-1, -1, -1, -1};
 110 module_param_array(video_nr, int, NULL, 0444);
 111 MODULE_PARM_DESC(video_nr, "video device number (-1=Auto)");
 112
 113 /*
 114    Number and size of grab buffers for Video 4 Linux
 115    The vast majority of applications should not need more than 2,
 116    the very popular BTTV driver actually does ONLY have 2.
 117    Time sensitive applications might need more, the maximum
 118    is VIDEO_MAX_FRAME (defined in <linux/videodev.h>).
 119
 120    The size is set so that the maximum possible request
 121    can be satisfied. Decrease  it, if bigphys_area alloc'd
 122    memory is low. If you don't have the bigphys_area patch,
 123    set it to 128 KB. Will you allow only to grab small
 124    images with V4L, but that's better than nothing.
 125
 126    v4l_bufsize has to be given in KB !
 127
 128 */
 129
 130 int v4l_nbufs = 2;
 131 int v4l_bufsize = 128;          /* Everybody should be able to work with this setting */
 132 module_param(v4l_nbufs, int, 0644);
 133 MODULE_PARM_DESC(v4l_nbufs, "Maximum number of V4L buffers to use");
 134 module_param(v4l_bufsize, int, 0644);
 135 MODULE_PARM_DESC(v4l_bufsize, "Maximum size per V4L buffer (in kB)");
 136
 137 int jpg_nbufs = 32;
 138 int jpg_bufsize = 512;          /* max size for 100% quality full-PAL frame */
 139 module_param(jpg_nbufs, int, 0644);
 140 MODULE_PARM_DESC(jpg_nbufs, "Maximum number of JPG buffers to use");
 141 module_param(jpg_bufsize, int, 0644);
 142 MODULE_PARM_DESC(jpg_bufsize, "Maximum size per JPG buffer (in kB)");
 143
 144 int pass_through = 0;           /* 1=Pass through TV signal when device is not used */
 145                                 /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */
 146 module_param(pass_through, int, 0644);
 147 MODULE_PARM_DESC(pass_through,
 148                  "Pass TV signal through to TV-out when idling");
 149
 150 int zr36067_debug = 1;
 151 module_param_named(debug, zr36067_debug, int, 0644);
 152 MODULE_PARM_DESC(debug, "Debug level (0-5)");
 153
 154 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
 155 MODULE_AUTHOR("Serguei Miridonov");
 156 MODULE_LICENSE("GPL");
 157
 158 static struct pci_device_id zr36067_pci_tbl[] = {
 159         {PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057,
 160          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 161         {0}
 162 };
 163 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
 164
 165 int zoran_num;                  /* number of Buzs in use */
 166 struct zoran zoran[BUZ_MAX];
 167
 168 /* videocodec bus functions ZR36060 */
 169 static u32
 170 zr36060_read (struct videocodec *codec,
 171               u16                reg)
 172 {
 173         struct zoran *zr = (struct zoran *) codec->master_data->data;
 174         __u32 data;
 175
 176         if (post_office_wait(zr)
 177             || post_office_write(zr, 0, 1, reg >> 8)
 178             || post_office_write(zr, 0, 2, reg & 0xff)) {
 179                 return -1;
 180         }
 181
 182         data = post_office_read(zr, 0, 3) & 0xff;
 183         return data;
 184 }
 185
 186 static void
 187 zr36060_write (struct videocodec *codec,
 188                u16                reg,
 189                u32                val)
 190 {
 191         struct zoran *zr = (struct zoran *) codec->master_data->data;
 192
 193         if (post_office_wait(zr)
 194             || post_office_write(zr, 0, 1, reg >> 8)
 195             || post_office_write(zr, 0, 2, reg & 0xff)) {
 196                 return;
 197         }
 198
 199         post_office_write(zr, 0, 3, val & 0xff);
 200 }
 201
 202 /* videocodec bus functions ZR36050 */
 203 static u32
 204 zr36050_read (struct videocodec *codec,
 205               u16                reg)
 206 {
 207         struct zoran *zr = (struct zoran *) codec->master_data->data;
 208         __u32 data;
 209
 210         if (post_office_wait(zr)
 211             || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
 212                 return -1;
 213         }
 214
 215         data = post_office_read(zr, 0, reg & 0x03) & 0xff;      // reg. LOWBYTES + read
 216         return data;
 217 }
 218
 219 static void
 220 zr36050_write (struct videocodec *codec,
 221                u16                reg,
 222                u32                val)
 223 {
 224         struct zoran *zr = (struct zoran *) codec->master_data->data;
 225
 226         if (post_office_wait(zr)
 227             || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
 228                 return;
 229         }
 230
 231         post_office_write(zr, 0, reg & 0x03, val & 0xff);       // reg. LOWBYTES + wr. data
 232 }
 233
 234 /* videocodec bus functions ZR36016 */
 235 static u32
 236 zr36016_read (struct videocodec *codec,
 237               u16                reg)
 238 {
 239         struct zoran *zr = (struct zoran *) codec->master_data->data;
 240         __u32 data;
 241
 242         if (post_office_wait(zr)) {
 243                 return -1;
 244         }
 245
 246         data = post_office_read(zr, 2, reg & 0x03) & 0xff;      // read
 247         return data;
 248 }
 249
 250 /* hack for in zoran_device.c */
 251 void
 252 zr36016_write (struct videocodec *codec,
 253                u16                reg,
 254                u32                val)
 255 {
 256         struct zoran *zr = (struct zoran *) codec->master_data->data;
 257
 258         if (post_office_wait(zr)) {
 259                 return;
 260         }
 261
 262         post_office_write(zr, 2, reg & 0x03, val & 0x0ff);      // wr. data
 263 }
 264
 265 /*
 266  * Board specific information
 267  */
 268
 269 static void
 270 dc10_init (struct zoran *zr)
 271 {
 272         dprintk(3, KERN_DEBUG "%s: dc10_init()\n", ZR_DEVNAME(zr));
 273
 274         /* Pixel clock selection */
 275         GPIO(zr, 4, 0);
 276         GPIO(zr, 5, 1);
 277         /* Enable the video bus sync signals */
 278         GPIO(zr, 7, 0);
 279 }
 280
 281 static void
 282 dc10plus_init (struct zoran *zr)
 283 {
 284         dprintk(3, KERN_DEBUG "%s: dc10plus_init()\n", ZR_DEVNAME(zr));
 285 }
 286
 287 static void
 288 buz_init (struct zoran *zr)
 289 {
 290         dprintk(3, KERN_DEBUG "%s: buz_init()\n", ZR_DEVNAME(zr));
 291
 292         /* some stuff from Iomega */
 293         pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
 294         pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
 295         pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
 296 }
 297
 298 static void
 299 lml33_init (struct zoran *zr)
 300 {
 301         dprintk(3, KERN_DEBUG "%s: lml33_init()\n", ZR_DEVNAME(zr));
 302
 303         GPIO(zr, 2, 1);         // Set Composite input/output
 304 }
 305
 306 static void
 307 avs6eyes_init (struct zoran *zr)
 308 {
 309         // AverMedia 6-Eyes original driver by Christer Weinigel
 310
 311         // Lifted straight from Christer's old driver and
 312         // modified slightly by Martin Samuelsson.
 313
 314         int mux = default_mux; /* 1 = BT866, 7 = VID1 */
 315
 316         GPIO(zr, 4, 1); /* Bt866 SLEEP on */
 317         udelay(2);
 318
 319         GPIO(zr, 0, 1); /* ZR36060 /RESET on */
 320         GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */
 321         GPIO(zr, 2, mux & 1);   /* MUX S0 */
 322         GPIO(zr, 3, 0); /* /FRAME on */
 323         GPIO(zr, 4, 0); /* Bt866 SLEEP off */
 324         GPIO(zr, 5, mux & 2);   /* MUX S1 */
 325         GPIO(zr, 6, 0); /* ? */
 326         GPIO(zr, 7, mux & 4);   /* MUX S2 */
 327
 328 }
 329
 330 static char *
 331 i2cid_to_modulename (u16 i2c_id)
 332 {
 333         char *name = NULL;
 334
 335         switch (i2c_id) {
 336         case I2C_DRIVERID_SAA7110:
 337                 name = "saa7110";
 338                 break;
 339         case I2C_DRIVERID_SAA7111A:
 340                 name = "saa7111";
 341                 break;
 342         case I2C_DRIVERID_SAA7114:
 343                 name = "saa7114";
 344                 break;
 345         case I2C_DRIVERID_SAA7185B:
 346                 name = "saa7185";
 347                 break;
 348         case I2C_DRIVERID_ADV7170:
 349                 name = "adv7170";
 350                 break;
 351         case I2C_DRIVERID_ADV7175:
 352                 name = "adv7175";
 353                 break;
 354         case I2C_DRIVERID_BT819:
 355                 name = "bt819";
 356                 break;
 357         case I2C_DRIVERID_BT856:
 358                 name = "bt856";
 359                 break;
 360         case I2C_DRIVERID_VPX3220:
 361                 name = "vpx3220";
 362                 break;
 363 /*      case I2C_DRIVERID_VPX3224:
 364                 name = "vpx3224";
 365                 break;
 366         case I2C_DRIVERID_MSE3000:
 367                 name = "mse3000";
 368                 break;*/
 369         default:
 370                 break;
 371         }
 372
 373         return name;
 374 }
 375
 376 static char *
 377 codecid_to_modulename (u16 codecid)
 378 {
 379         char *name = NULL;
 380
 381         switch (codecid) {
 382         case CODEC_TYPE_ZR36060:
 383                 name = "zr36060";
 384                 break;
 385         case CODEC_TYPE_ZR36050:
 386                 name = "zr36050";
 387                 break;
 388         case CODEC_TYPE_ZR36016:
 389                 name = "zr36016";
 390                 break;
 391         default:
 392                 break;
 393         }
 394
 395         return name;
 396 }
 397
 398 // struct tvnorm {
 399 //      u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
 400 // };
 401
 402 static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
 403 static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
 404 static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
 405 static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
 406
 407 static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 };
 408 static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 };
 409
 410 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
 411 static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
 412 static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
 413
 414 /* FIXME: I cannot swap U and V in saa7114, so i do one
 415  * pixel left shift in zoran (75 -> 74)
 416  * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */
 417 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
 418 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
 419
 420 /* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
 421  * copy Maxim's left shift hack for the 6 Eyes.
 422  *
 423  * Christer's driver used the unshifted norms, though...
 424  * /Sam  */
 425 static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
 426 static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
 427
 428 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
 429         {
 430                 .type = DC10_old,
 431                 .name = "DC10(old)",
 432                 .i2c_decoder = I2C_DRIVERID_VPX3220,
 433                 /*.i2c_encoder = I2C_DRIVERID_MSE3000,*/
 434                 .video_codec = CODEC_TYPE_ZR36050,
 435                 .video_vfe = CODEC_TYPE_ZR36016,
 436
 437                 .inputs = 3,
 438                 .input = {
 439                         { 1, "Composite" },
 440                         { 2, "S-Video" },
 441                         { 0, "Internal/comp" }
 442                 },
 443                 .norms = 3,
 444                 .tvn = {
 445                         &f50sqpixel_dc10,
 446                         &f60sqpixel_dc10,
 447                         &f50sqpixel_dc10
 448                 },
 449                 .jpeg_int = 0,
 450                 .vsync_int = ZR36057_ISR_GIRQ1,
 451                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
 452                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
 453                 .gpcs = { -1, 0 },
 454                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 455                 .gws_not_connected = 0,
 456                 .input_mux = 0,
 457                 .init = &dc10_init,
 458         }, {
 459                 .type = DC10_new,
 460                 .name = "DC10(new)",
 461                 .i2c_decoder = I2C_DRIVERID_SAA7110,
 462                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 463                 .video_codec = CODEC_TYPE_ZR36060,
 464
 465                 .inputs = 3,
 466                 .input = {
 467                                 { 0, "Composite" },
 468                                 { 7, "S-Video" },
 469                                 { 5, "Internal/comp" }
 470                         },
 471                 .norms = 3,
 472                 .tvn = {
 473                                 &f50sqpixel,
 474                                 &f60sqpixel,
 475                                 &f50sqpixel},
 476                 .jpeg_int = ZR36057_ISR_GIRQ0,
 477                 .vsync_int = ZR36057_ISR_GIRQ1,
 478                 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
 479                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 480                 .gpcs = { -1, 1},
 481                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
 482                 .gws_not_connected = 0,
 483                 .input_mux = 0,
 484                 .init = &dc10plus_init,
 485         }, {
 486                 .type = DC10plus,
 487                 .name = "DC10plus",
 488                 .vendor_id = PCI_VENDOR_ID_MIRO,
 489                 .device_id = PCI_DEVICE_ID_MIRO_DC10PLUS,
 490                 .i2c_decoder = I2C_DRIVERID_SAA7110,
 491                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 492                 .video_codec = CODEC_TYPE_ZR36060,
 493
 494                 .inputs = 3,
 495                 .input = {
 496                         { 0, "Composite" },
 497                         { 7, "S-Video" },
 498                         { 5, "Internal/comp" }
 499                 },
 500                 .norms = 3,
 501                 .tvn = {
 502                         &f50sqpixel,
 503                         &f60sqpixel,
 504                         &f50sqpixel
 505                 },
 506                 .jpeg_int = ZR36057_ISR_GIRQ0,
 507                 .vsync_int = ZR36057_ISR_GIRQ1,
 508                 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
 509                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 510                 .gpcs = { -1, 1 },
 511                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
 512                 .gws_not_connected = 0,
 513                 .input_mux = 0,
 514                 .init = &dc10plus_init,
 515         }, {
 516                 .type = DC30,
 517                 .name = "DC30",
 518                 .i2c_decoder = I2C_DRIVERID_VPX3220,
 519                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 520                 .video_codec = CODEC_TYPE_ZR36050,
 521                 .video_vfe = CODEC_TYPE_ZR36016,
 522
 523                 .inputs = 3,
 524                 .input = {
 525                         { 1, "Composite" },
 526                         { 2, "S-Video" },
 527                         { 0, "Internal/comp" }
 528                 },
 529                 .norms = 3,
 530                 .tvn = {
 531                         &f50sqpixel_dc10,
 532                         &f60sqpixel_dc10,
 533                         &f50sqpixel_dc10
 534                 },
 535                 .jpeg_int = 0,
 536                 .vsync_int = ZR36057_ISR_GIRQ1,
 537                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
 538                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
 539                 .gpcs = { -1, 0 },
 540                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 541                 .gws_not_connected = 0,
 542                 .input_mux = 0,
 543                 .init = &dc10_init,
 544         }, {
 545                 .type = DC30plus,
 546                 .name = "DC30plus",
 547                 .vendor_id = PCI_VENDOR_ID_MIRO,
 548                 .device_id = PCI_DEVICE_ID_MIRO_DC30PLUS,
 549                 .i2c_decoder = I2C_DRIVERID_VPX3220,
 550                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 551                 .video_codec = CODEC_TYPE_ZR36050,
 552                 .video_vfe = CODEC_TYPE_ZR36016,
 553
 554                 .inputs = 3,
 555                 .input = {
 556                         { 1, "Composite" },
 557                         { 2, "S-Video" },
 558                         { 0, "Internal/comp" }
 559                 },
 560                 .norms = 3,
 561                 .tvn = {
 562                         &f50sqpixel_dc10,
 563                         &f60sqpixel_dc10,
 564                         &f50sqpixel_dc10
 565                 },
 566                 .jpeg_int = 0,
 567                 .vsync_int = ZR36057_ISR_GIRQ1,
 568                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
 569                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
 570                 .gpcs = { -1, 0 },
 571                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 572                 .gws_not_connected = 0,
 573                 .input_mux = 0,
 574                 .init = &dc10_init,
 575         }, {
 576                 .type = LML33,
 577                 .name = "LML33",
 578                 .i2c_decoder = I2C_DRIVERID_BT819,
 579                 .i2c_encoder = I2C_DRIVERID_BT856,
 580                 .video_codec = CODEC_TYPE_ZR36060,
 581
 582                 .inputs = 2,
 583                 .input = {
 584                         { 0, "Composite" },
 585                         { 7, "S-Video" }
 586                 },
 587                 .norms = 2,
 588                 .tvn = {
 589                         &f50ccir601_lml33,
 590                         &f60ccir601_lml33,
 591                         NULL
 592                 },
 593                 .jpeg_int = ZR36057_ISR_GIRQ1,
 594                 .vsync_int = ZR36057_ISR_GIRQ0,
 595                 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
 596                 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
 597                 .gpcs = { 3, 1 },
 598                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
 599                 .gws_not_connected = 1,
 600                 .input_mux = 0,
 601                 .init = &lml33_init,
 602         }, {
 603                 .type = LML33R10,
 604                 .name = "LML33R10",
 605                 .vendor_id = PCI_VENDOR_ID_ELECTRONICDESIGNGMBH,
 606                 .device_id = PCI_DEVICE_ID_LML_33R10,
 607                 .i2c_decoder = I2C_DRIVERID_SAA7114,
 608                 .i2c_encoder = I2C_DRIVERID_ADV7170,
 609                 .video_codec = CODEC_TYPE_ZR36060,
 610
 611                 .inputs = 2,
 612                 .input = {
 613                         { 0, "Composite" },
 614                         { 7, "S-Video" }
 615                 },
 616                 .norms = 2,
 617                 .tvn = {
 618                         &f50ccir601_lm33r10,
 619                         &f60ccir601_lm33r10,
 620                         NULL
 621                 },
 622                 .jpeg_int = ZR36057_ISR_GIRQ1,
 623                 .vsync_int = ZR36057_ISR_GIRQ0,
 624                 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
 625                 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
 626                 .gpcs = { 3, 1 },
 627                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
 628                 .gws_not_connected = 1,
 629                 .input_mux = 0,
 630                 .init = &lml33_init,
 631         }, {
 632                 .type = BUZ,
 633                 .name = "Buz",
 634                 .vendor_id = PCI_VENDOR_ID_IOMEGA,
 635                 .device_id = PCI_DEVICE_ID_IOMEGA_BUZ,
 636                 .i2c_decoder = I2C_DRIVERID_SAA7111A,
 637                 .i2c_encoder = I2C_DRIVERID_SAA7185B,
 638                 .video_codec = CODEC_TYPE_ZR36060,
 639
 640                 .inputs = 2,
 641                 .input = {
 642                         { 3, "Composite" },
 643                         { 7, "S-Video" }
 644                 },
 645                 .norms = 3,
 646                 .tvn = {
 647                         &f50ccir601,
 648                         &f60ccir601,
 649                         &f50ccir601
 650                 },
 651                 .jpeg_int = ZR36057_ISR_GIRQ1,
 652                 .vsync_int = ZR36057_ISR_GIRQ0,
 653                 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
 654                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 655                 .gpcs = { 3, 1 },
 656                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
 657                 .gws_not_connected = 1,
 658                 .input_mux = 0,
 659                 .init = &buz_init,
 660         }, {
 661                 .type = AVS6EYES,
 662                 .name = "6-Eyes",
 663                 /* AverMedia chose not to brand the 6-Eyes. Thus it
 664                    can't be autodetected, and requires card=x. */
 665                 .vendor_id = -1,
 666                 .device_id = -1,
 667                 .i2c_decoder = I2C_DRIVERID_KS0127,
 668                 .i2c_encoder = I2C_DRIVERID_BT866,
 669                 .video_codec = CODEC_TYPE_ZR36060,
 670
 671                 .inputs = 10,
 672                 .input = {
 673                         { 0, "Composite 1" },
 674                         { 1, "Composite 2" },
 675                         { 2, "Composite 3" },
 676                         { 4, "Composite 4" },
 677                         { 5, "Composite 5" },
 678                         { 6, "Composite 6" },
 679                         { 8, "S-Video 1" },
 680                         { 9, "S-Video 2" },
 681                         {10, "S-Video 3" },
 682                         {15, "YCbCr" }
 683                 },
 684                 .norms = 2,
 685                 .tvn = {
 686                         &f50ccir601_avs6eyes,
 687                         &f60ccir601_avs6eyes,
 688                         NULL
 689                 },
 690                 .jpeg_int = ZR36057_ISR_GIRQ1,
 691                 .vsync_int = ZR36057_ISR_GIRQ0,
 692                 .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
 693                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
 694                 .gpcs = { 3, 1 },                       // Validity unknown /Sam
 695                 .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 },  // Validity unknown /Sam
 696                 .gws_not_connected = 1,
 697                 .input_mux = 1,
 698                 .init = &avs6eyes_init,
 699         }
 700
 701 };
 702
 703 /*
 704  * I2C functions
 705  */
 706 /* software I2C functions */
 707 static int
 708 zoran_i2c_getsda (void *data)
 709 {
 710         struct zoran *zr = (struct zoran *) data;
 711
 712         return (btread(ZR36057_I2CBR) >> 1) & 1;
 713 }
 714
 715 static int
 716 zoran_i2c_getscl (void *data)
 717 {
 718         struct zoran *zr = (struct zoran *) data;
 719
 720         return btread(ZR36057_I2CBR) & 1;
 721 }
 722
 723 static void
 724 zoran_i2c_setsda (void *data,
 725                   int   state)
 726 {
 727         struct zoran *zr = (struct zoran *) data;
 728
 729         if (state)
 730                 zr->i2cbr |= 2;
 731         else
 732                 zr->i2cbr &= ~2;
 733         btwrite(zr->i2cbr, ZR36057_I2CBR);
 734 }
 735
 736 static void
 737 zoran_i2c_setscl (void *data,
 738                   int   state)
 739 {
 740         struct zoran *zr = (struct zoran *) data;
 741
 742         if (state)
 743                 zr->i2cbr |= 1;
 744         else
 745                 zr->i2cbr &= ~1;
 746         btwrite(zr->i2cbr, ZR36057_I2CBR);
 747 }
 748
 749 static int
 750 zoran_i2c_client_register (struct i2c_client *client)
 751 {
 752         struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
 753         int res = 0;
 754
 755         dprintk(2,
 756                 KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
 757                 ZR_DEVNAME(zr), client->driver->id);
 758
 759         mutex_lock(&zr->resource_lock);
 760
 761         if (zr->user > 0) {
 762                 /* we're already busy, so we keep a reference to
 763                  * them... Could do a lot of stuff here, but this
 764                  * is easiest. (Did I ever mention I'm a lazy ass?)
 765                  */
 766                 res = -EBUSY;
 767                 goto clientreg_unlock_and_return;
 768         }
 769
 770         if (client->driver->id == zr->card.i2c_decoder)
 771                 zr->decoder = client;
 772         else if (client->driver->id == zr->card.i2c_encoder)
 773                 zr->encoder = client;
 774         else {
 775                 res = -ENODEV;
 776                 goto clientreg_unlock_and_return;
 777         }
 778
 779 clientreg_unlock_and_return:
 780         mutex_unlock(&zr->resource_lock);
 781
 782         return res;
 783 }
 784
 785 static int
 786 zoran_i2c_client_unregister (struct i2c_client *client)
 787 {
 788         struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
 789         int res = 0;
 790
 791         dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
 792
 793         mutex_lock(&zr->resource_lock);
 794
 795         if (zr->user > 0) {
 796                 res = -EBUSY;
 797                 goto clientunreg_unlock_and_return;
 798         }
 799
 800         /* try to locate it */
 801         if (client == zr->encoder) {
 802                 zr->encoder = NULL;
 803         } else if (client == zr->decoder) {
 804                 zr->decoder = NULL;
 805                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
 806         }
 807 clientunreg_unlock_and_return:
 808         mutex_unlock(&zr->resource_lock);
 809         return res;
 810 }
 811
 812 static struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
 813         .setsda = zoran_i2c_setsda,
 814         .setscl = zoran_i2c_setscl,
 815         .getsda = zoran_i2c_getsda,
 816         .getscl = zoran_i2c_getscl,
 817         .udelay = 10,
 818         .timeout = 100,
 819 };
 820
 821 static struct i2c_adapter zoran_i2c_adapter_template = {
 822         .name = "zr36057",
 823         .id = I2C_HW_B_ZR36067,
 824         .algo = NULL,
 825         .client_register = zoran_i2c_client_register,
 826         .client_unregister = zoran_i2c_client_unregister,
 827 };
 828
 829 static int
 830 zoran_register_i2c (struct zoran *zr)
 831 {
 832         memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
 833                sizeof(struct i2c_algo_bit_data));
 834         zr->i2c_algo.data = zr;
 835         memcpy(&zr->i2c_adapter, &zoran_i2c_adapter_template,
 836                sizeof(struct i2c_adapter));
 837         strncpy(I2C_NAME(&zr->i2c_adapter), ZR_DEVNAME(zr),
 838                 sizeof(I2C_NAME(&zr->i2c_adapter)) - 1);
 839         i2c_set_adapdata(&zr->i2c_adapter, zr);
 840         zr->i2c_adapter.algo_data = &zr->i2c_algo;
 841         zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
 842         return i2c_bit_add_bus(&zr->i2c_adapter);
 843 }
 844
 845 static void
 846 zoran_unregister_i2c (struct zoran *zr)
 847 {
 848         i2c_del_adapter(&zr->i2c_adapter);
 849 }
 850
 851 /* Check a zoran_params struct for correctness, insert default params */
 852
 853 int
 854 zoran_check_jpg_settings (struct zoran              *zr,
 855                           struct zoran_jpg_settings *settings)
 856 {
 857         int err = 0, err0 = 0;
 858
 859         dprintk(4,
 860                 KERN_DEBUG
 861                 "%s: check_jpg_settings() - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
 862                 ZR_DEVNAME(zr), settings->decimation, settings->HorDcm,
 863                 settings->VerDcm, settings->TmpDcm);
 864         dprintk(4,
 865                 KERN_DEBUG
 866                 "%s: check_jpg_settings() - x: %d, y: %d, w: %d, y: %d\n",
 867                 ZR_DEVNAME(zr), settings->img_x, settings->img_y,
 868                 settings->img_width, settings->img_height);
 869         /* Check decimation, set default values for decimation = 1, 2, 4 */
 870         switch (settings->decimation) {
 871         case 1:
 872
 873                 settings->HorDcm = 1;
 874                 settings->VerDcm = 1;
 875                 settings->TmpDcm = 1;
 876                 settings->field_per_buff = 2;
 877                 settings->img_x = 0;
 878                 settings->img_y = 0;
 879                 settings->img_width = BUZ_MAX_WIDTH;
 880                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 881                 break;
 882         case 2:
 883
 884                 settings->HorDcm = 2;
 885                 settings->VerDcm = 1;
 886                 settings->TmpDcm = 2;
 887                 settings->field_per_buff = 1;
 888                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 889                 settings->img_y = 0;
 890                 settings->img_width =
 891                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 892                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 893                 break;
 894         case 4:
 895
 896                 if (zr->card.type == DC10_new) {
 897                         dprintk(1,
 898                                 KERN_DEBUG
 899                                 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
 900                                 ZR_DEVNAME(zr));
 901                         err0++;
 902                         break;
 903                 }
 904
 905                 settings->HorDcm = 4;
 906                 settings->VerDcm = 2;
 907                 settings->TmpDcm = 2;
 908                 settings->field_per_buff = 1;
 909                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 910                 settings->img_y = 0;
 911                 settings->img_width =
 912                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 913                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 914                 break;
 915         case 0:
 916
 917                 /* We have to check the data the user has set */
 918
 919                 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
 920                     (zr->card.type == DC10_new || settings->HorDcm != 4))
 921                         err0++;
 922                 if (settings->VerDcm != 1 && settings->VerDcm != 2)
 923                         err0++;
 924                 if (settings->TmpDcm != 1 && settings->TmpDcm != 2)
 925                         err0++;
 926                 if (settings->field_per_buff != 1 &&
 927                     settings->field_per_buff != 2)
 928                         err0++;
 929                 if (settings->img_x < 0)
 930                         err0++;
 931                 if (settings->img_y < 0)
 932                         err0++;
 933                 if (settings->img_width < 0)
 934                         err0++;
 935                 if (settings->img_height < 0)
 936                         err0++;
 937                 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH)
 938                         err0++;
 939                 if (settings->img_y + settings->img_height >
 940                     BUZ_MAX_HEIGHT / 2)
 941                         err0++;
 942                 if (settings->HorDcm && settings->VerDcm) {
 943                         if (settings->img_width %
 944                             (16 * settings->HorDcm) != 0)
 945                                 err0++;
 946                         if (settings->img_height %
 947                             (8 * settings->VerDcm) != 0)
 948                                 err0++;
 949                 }
 950
 951                 if (err0) {
 952                         dprintk(1,
 953                                 KERN_ERR
 954                                 "%s: check_jpg_settings() - error in params for decimation = 0\n",
 955                                 ZR_DEVNAME(zr));
 956                         err++;
 957                 }
 958                 break;
 959         default:
 960                 dprintk(1,
 961                         KERN_ERR
 962                         "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
 963                         ZR_DEVNAME(zr), settings->decimation);
 964                 err++;
 965                 break;
 966         }
 967
 968         if (settings->jpg_comp.quality > 100)
 969                 settings->jpg_comp.quality = 100;
 970         if (settings->jpg_comp.quality < 5)
 971                 settings->jpg_comp.quality = 5;
 972         if (settings->jpg_comp.APPn < 0)
 973                 settings->jpg_comp.APPn = 0;
 974         if (settings->jpg_comp.APPn > 15)
 975                 settings->jpg_comp.APPn = 15;
 976         if (settings->jpg_comp.APP_len < 0)
 977                 settings->jpg_comp.APP_len = 0;
 978         if (settings->jpg_comp.APP_len > 60)
 979                 settings->jpg_comp.APP_len = 60;
 980         if (settings->jpg_comp.COM_len < 0)
 981                 settings->jpg_comp.COM_len = 0;
 982         if (settings->jpg_comp.COM_len > 60)
 983                 settings->jpg_comp.COM_len = 60;
 984         if (err)
 985                 return -EINVAL;
 986         return 0;
 987 }
 988
 989 void
 990 zoran_open_init_params (struct zoran *zr)
 991 {
 992         int i;
 993
 994         /* User must explicitly set a window */
 995         zr->overlay_settings.is_set = 0;
 996         zr->overlay_mask = NULL;
 997         zr->overlay_active = ZORAN_FREE;
 998
 999         zr->v4l_memgrab_active = 0;
1000         zr->v4l_overlay_active = 0;
1001         zr->v4l_grab_frame = NO_GRAB_ACTIVE;
1002         zr->v4l_grab_seq = 0;
1003         zr->v4l_settings.width = 192;
1004         zr->v4l_settings.height = 144;
1005         zr->v4l_settings.format = &zoran_formats[4];    /* YUY2 - YUV-4:2:2 packed */
1006         zr->v4l_settings.bytesperline =
1007             zr->v4l_settings.width *
1008             ((zr->v4l_settings.format->depth + 7) / 8);
1009
1010         /* DMA ring stuff for V4L */
1011         zr->v4l_pend_tail = 0;
1012         zr->v4l_pend_head = 0;
1013         zr->v4l_sync_tail = 0;
1014         zr->v4l_buffers.active = ZORAN_FREE;
1015         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1016                 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
1017         }
1018         zr->v4l_buffers.allocated = 0;
1019
1020         for (i = 0; i < BUZ_MAX_FRAME; i++) {
1021                 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
1022         }
1023         zr->jpg_buffers.active = ZORAN_FREE;
1024         zr->jpg_buffers.allocated = 0;
1025         /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
1026         zr->jpg_settings.decimation = 1;
1027         zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
1028         if (zr->card.type != BUZ)
1029                 zr->jpg_settings.odd_even = 1;
1030         else
1031                 zr->jpg_settings.odd_even = 0;
1032         zr->jpg_settings.jpg_comp.APPn = 0;
1033         zr->jpg_settings.jpg_comp.APP_len = 0;  /* No APPn marker */
1034         memset(zr->jpg_settings.jpg_comp.APP_data, 0,
1035                sizeof(zr->jpg_settings.jpg_comp.APP_data));
1036         zr->jpg_settings.jpg_comp.COM_len = 0;  /* No COM marker */
1037         memset(zr->jpg_settings.jpg_comp.COM_data, 0,
1038                sizeof(zr->jpg_settings.jpg_comp.COM_data));
1039         zr->jpg_settings.jpg_comp.jpeg_markers =
1040             JPEG_MARKER_DHT | JPEG_MARKER_DQT;
1041         i = zoran_check_jpg_settings(zr, &zr->jpg_settings);
1042         if (i)
1043                 dprintk(1,
1044                         KERN_ERR
1045                         "%s: zoran_open_init_params() internal error\n",
1046                         ZR_DEVNAME(zr));
1047
1048         clear_interrupt_counters(zr);
1049         zr->testing = 0;
1050 }
1051
1052 static void __devinit
1053 test_interrupts (struct zoran *zr)
1054 {
1055         DEFINE_WAIT(wait);
1056         int timeout, icr;
1057
1058         clear_interrupt_counters(zr);
1059
1060         zr->testing = 1;
1061         icr = btread(ZR36057_ICR);
1062         btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
1063         prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
1064         timeout = schedule_timeout(HZ);
1065         finish_wait(&zr->test_q, &wait);
1066         btwrite(0, ZR36057_ICR);
1067         btwrite(0x78000000, ZR36057_ISR);
1068         zr->testing = 0;
1069         dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
1070         if (timeout) {
1071                 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
1072         }
1073         if (zr36067_debug > 1)
1074                 print_interrupts(zr);
1075         btwrite(icr, ZR36057_ICR);
1076 }
1077
1078 static int __devinit
1079 zr36057_init (struct zoran *zr)
1080 {
1081         int j, err;
1082         int two = 2;
1083         int zero = 0;
1084
1085         dprintk(1,
1086                 KERN_INFO
1087                 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1088                 ZR_DEVNAME(zr), zr->id, zr);
1089
1090         /* default setup of all parameters which will persist between opens */
1091         zr->user = 0;
1092
1093         init_waitqueue_head(&zr->v4l_capq);
1094         init_waitqueue_head(&zr->jpg_capq);
1095         init_waitqueue_head(&zr->test_q);
1096         zr->jpg_buffers.allocated = 0;
1097         zr->v4l_buffers.allocated = 0;
1098
1099         zr->buffer.base = (void *) vidmem;
1100         zr->buffer.width = 0;
1101         zr->buffer.height = 0;
1102         zr->buffer.depth = 0;
1103         zr->buffer.bytesperline = 0;
1104
1105         /* Avoid nonsense settings from user for default input/norm */
1106         if (default_norm < VIDEO_MODE_PAL &&
1107             default_norm > VIDEO_MODE_SECAM)
1108                 default_norm = VIDEO_MODE_PAL;
1109         zr->norm = default_norm;
1110         if (!(zr->timing = zr->card.tvn[zr->norm])) {
1111                 dprintk(1,
1112                         KERN_WARNING
1113                         "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1114                         ZR_DEVNAME(zr));
1115                 zr->norm = VIDEO_MODE_PAL;
1116                 zr->timing = zr->card.tvn[zr->norm];
1117         }
1118
1119         if (default_input > zr->card.inputs-1) {
1120                 dprintk(1,
1121                         KERN_WARNING
1122                         "%s: default_input value %d out of range (0-%d)\n",
1123                         ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1124                 default_input = 0;
1125         }
1126         zr->input = default_input;
1127
1128         /* Should the following be reset at every open ? */
1129         zr->hue = 32768;
1130         zr->contrast = 32768;
1131         zr->saturation = 32768;
1132         zr->brightness = 32768;
1133
1134         /* default setup (will be repeated at every open) */
1135         zoran_open_init_params(zr);
1136
1137         /* allocate memory *before* doing anything to the hardware
1138          * in case allocation fails */
1139         zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1140         zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1141         if (!zr->stat_com || !zr->video_dev) {
1142                 dprintk(1,
1143                         KERN_ERR
1144                         "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1145                         ZR_DEVNAME(zr));
1146                 err = -ENOMEM;
1147                 goto exit_free;
1148         }
1149         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1150                 zr->stat_com[j] = 1;    /* mark as unavailable to zr36057 */
1151         }
1152
1153         /*
1154          *   Now add the template and register the device unit.
1155          */
1156         memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1157         strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1158         err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
1159         if (err < 0)
1160                 goto exit_unregister;
1161
1162         zoran_init_hardware(zr);
1163         if (zr36067_debug > 2)
1164                 detect_guest_activity(zr);
1165         test_interrupts(zr);
1166         if (!pass_through) {
1167                 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1168                 encoder_command(zr, ENCODER_SET_INPUT, &two);
1169         }
1170
1171         zr->zoran_proc = NULL;
1172         zr->initialized = 1;
1173         return 0;
1174
1175 exit_unregister:
1176         zoran_unregister_i2c(zr);
1177 exit_free:
1178         kfree(zr->stat_com);
1179         kfree(zr->video_dev);
1180         return err;
1181 }
1182
1183 static void
1184 zoran_release (struct zoran *zr)
1185 {
1186         if (!zr->initialized)
1187                 return;
1188         /* unregister videocodec bus */
1189         if (zr->codec) {
1190                 struct videocodec_master *master = zr->codec->master_data;
1191
1192                 videocodec_detach(zr->codec);
1193                 kfree(master);
1194         }
1195         if (zr->vfe) {
1196                 struct videocodec_master *master = zr->vfe->master_data;
1197
1198                 videocodec_detach(zr->vfe);
1199                 kfree(master);
1200         }
1201
1202         /* unregister i2c bus */
1203         zoran_unregister_i2c(zr);
1204         /* disable PCI bus-mastering */
1205         zoran_set_pci_master(zr, 0);
1206         /* put chip into reset */
1207         btwrite(0, ZR36057_SPGPPCR);
1208         free_irq(zr->pci_dev->irq, zr);
1209         /* unmap and free memory */
1210         kfree(zr->stat_com);
1211         zoran_proc_cleanup(zr);
1212         iounmap(zr->zr36057_mem);
1213         pci_disable_device(zr->pci_dev);
1214         video_unregister_device(zr->video_dev);
1215 }
1216
1217 void
1218 zoran_vdev_release (struct video_device *vdev)
1219 {
1220         kfree(vdev);
1221 }
1222
1223 static struct videocodec_master * __devinit
1224 zoran_setup_videocodec (struct zoran *zr,
1225                         int           type)
1226 {
1227         struct videocodec_master *m = NULL;
1228
1229         m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1230         if (!m) {
1231                 dprintk(1,
1232                         KERN_ERR
1233                         "%s: zoran_setup_videocodec() - no memory\n",
1234                         ZR_DEVNAME(zr));
1235                 return m;
1236         }
1237
1238         m->magic = 0L; /* magic not used */
1239         m->type = VID_HARDWARE_ZR36067;
1240         m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1241         strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1242         m->data = zr;
1243
1244         switch (type)
1245         {
1246         case CODEC_TYPE_ZR36060:
1247                 m->readreg = zr36060_read;
1248                 m->writereg = zr36060_write;
1249                 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1250                 break;
1251         case CODEC_TYPE_ZR36050:
1252                 m->readreg = zr36050_read;
1253                 m->writereg = zr36050_write;
1254                 m->flags |= CODEC_FLAG_JPEG;
1255                 break;
1256         case CODEC_TYPE_ZR36016:
1257                 m->readreg = zr36016_read;
1258                 m->writereg = zr36016_write;
1259                 m->flags |= CODEC_FLAG_VFE;
1260                 break;
1261         }
1262
1263         return m;
1264 }
1265
1266 /*
1267  *   Scan for a Buz card (actually for the PCI contoler ZR36057),
1268  *   request the irq and map the io memory
1269  */
1270 static int __devinit
1271 find_zr36057 (void)
1272 {
1273         unsigned char latency, need_latency;
1274         struct zoran *zr;
1275         struct pci_dev *dev = NULL;
1276         int result;
1277         struct videocodec_master *master_vfe = NULL;
1278         struct videocodec_master *master_codec = NULL;
1279         int card_num;
1280         char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1281
1282         zoran_num = 0;
1283         while (zoran_num < BUZ_MAX &&
1284                (dev = pci_get_device(PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1285                 card_num = card[zoran_num];
1286                 zr = &zoran[zoran_num];
1287                 memset(zr, 0, sizeof(struct zoran));    // Just in case if previous cycle failed
1288                 zr->pci_dev = dev;
1289                 //zr->zr36057_mem = NULL;
1290                 zr->id = zoran_num;
1291                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1292                 spin_lock_init(&zr->spinlock);
1293                 mutex_init(&zr->resource_lock);
1294                 if (pci_enable_device(dev))
1295                         continue;
1296                 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
1297                 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,
1298                                      &zr->revision);
1299                 if (zr->revision < 2) {
1300                         dprintk(1,
1301                                 KERN_INFO
1302                                 "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
1303                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1304                                 zr->zr36057_adr);
1305
1306                         if (card_num == -1) {
1307                                 dprintk(1,
1308                                         KERN_ERR
1309                                         "%s: find_zr36057() - no card specified, please use the card=X insmod option\n",
1310                                         ZR_DEVNAME(zr));
1311                                 continue;
1312                         }
1313                 } else {
1314                         int i;
1315                         unsigned short ss_vendor, ss_device;
1316
1317                         ss_vendor = zr->pci_dev->subsystem_vendor;
1318                         ss_device = zr->pci_dev->subsystem_device;
1319                         dprintk(1,
1320                                 KERN_INFO
1321                                 "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
1322                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1323                                 zr->zr36057_adr);
1324                         dprintk(1,
1325                                 KERN_INFO
1326                                 "%s: subsystem vendor=0x%04x id=0x%04x\n",
1327                                 ZR_DEVNAME(zr), ss_vendor, ss_device);
1328                         if (card_num == -1) {
1329                                 dprintk(3,
1330                                         KERN_DEBUG
1331                                         "%s: find_zr36057() - trying to autodetect card type\n",
1332                                         ZR_DEVNAME(zr));
1333                                 for (i=0;i<NUM_CARDS;i++) {
1334                                         if (ss_vendor == zoran_cards[i].vendor_id &&
1335                                             ss_device == zoran_cards[i].device_id) {
1336                                                 dprintk(3,
1337                                                         KERN_DEBUG
1338                                                         "%s: find_zr36057() - card %s detected\n",
1339                                                         ZR_DEVNAME(zr),
1340                                                         zoran_cards[i].name);
1341                                                 card_num = i;
1342                                                 break;
1343                                         }
1344                                 }
1345                                 if (i == NUM_CARDS) {
1346                                         dprintk(1,
1347                                                 KERN_ERR
1348                                                 "%s: find_zr36057() - unknown card\n",
1349                                                 ZR_DEVNAME(zr));
1350                                         continue;
1351                                 }
1352                         }
1353                 }
1354
1355                 if (card_num < 0 || card_num >= NUM_CARDS) {
1356                         dprintk(2,
1357                                 KERN_ERR
1358                                 "%s: find_zr36057() - invalid cardnum %d\n",
1359                                 ZR_DEVNAME(zr), card_num);
1360                         continue;
1361                 }
1362
1363                 /* even though we make this a non pointer and thus
1364                  * theoretically allow for making changes to this struct
1365                  * on a per-individual card basis at runtime, this is
1366                  * strongly discouraged. This structure is intended to
1367                  * keep general card information, no settings or anything */
1368                 zr->card = zoran_cards[card_num];
1369                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1370                          "%s[%u]", zr->card.name, zr->id);
1371
1372                 zr->zr36057_mem = ioremap_nocache(zr->zr36057_adr, 0x1000);
1373                 if (!zr->zr36057_mem) {
1374                         dprintk(1,
1375                                 KERN_ERR
1376                                 "%s: find_zr36057() - ioremap failed\n",
1377                                 ZR_DEVNAME(zr));
1378                         continue;
1379                 }
1380
1381                 result = request_irq(zr->pci_dev->irq,
1382                                      zoran_irq,
1383                                      IRQF_SHARED | IRQF_DISABLED,
1384                                      ZR_DEVNAME(zr),
1385                                      (void *) zr);
1386                 if (result < 0) {
1387                         if (result == -EINVAL) {
1388                                 dprintk(1,
1389                                         KERN_ERR
1390                                         "%s: find_zr36057() - bad irq number or handler\n",
1391                                         ZR_DEVNAME(zr));
1392                         } else if (result == -EBUSY) {
1393                                 dprintk(1,
1394                                         KERN_ERR
1395                                         "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1396                                         ZR_DEVNAME(zr), zr->pci_dev->irq);
1397                         } else {
1398                                 dprintk(1,
1399                                         KERN_ERR
1400                                         "%s: find_zr36057() - can't assign irq, error code %d\n",
1401                                         ZR_DEVNAME(zr), result);
1402                         }
1403                         goto zr_unmap;
1404                 }
1405
1406                 /* set PCI latency timer */
1407                 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1408                                      &latency);
1409                 need_latency = zr->revision > 1 ? 32 : 48;
1410                 if (latency != need_latency) {
1411                         dprintk(2,
1412                                 KERN_INFO
1413                                 "%s: Changing PCI latency from %d to %d.\n",
1414                                 ZR_DEVNAME(zr), latency, need_latency);
1415                         pci_write_config_byte(zr->pci_dev,
1416                                               PCI_LATENCY_TIMER,
1417                                               need_latency);
1418                 }
1419
1420                 zr36057_restart(zr);
1421                 /* i2c */
1422                 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1423                         ZR_DEVNAME(zr));
1424
1425                 /* i2c decoder */
1426                 if (decoder[zr->id] != -1) {
1427                         i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1428                         zr->card.i2c_decoder = decoder[zr->id];
1429                 } else if (zr->card.i2c_decoder != 0) {
1430                         i2c_dec_name =
1431                                 i2cid_to_modulename(zr->card.i2c_decoder);
1432                 } else {
1433                         i2c_dec_name = NULL;
1434                 }
1435
1436                 if (i2c_dec_name) {
1437                         if ((result = request_module(i2c_dec_name)) < 0) {
1438                                 dprintk(1,
1439                                         KERN_ERR
1440                                         "%s: failed to load module %s: %d\n",
1441                                         ZR_DEVNAME(zr), i2c_dec_name, result);
1442                         }
1443                 }
1444
1445                 /* i2c encoder */
1446                 if (encoder[zr->id] != -1) {
1447                         i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1448                         zr->card.i2c_encoder = encoder[zr->id];
1449                 } else if (zr->card.i2c_encoder != 0) {
1450                         i2c_enc_name =
1451                                 i2cid_to_modulename(zr->card.i2c_encoder);
1452                 } else {
1453                         i2c_enc_name = NULL;
1454                 }
1455
1456                 if (i2c_enc_name) {
1457                         if ((result = request_module(i2c_enc_name)) < 0) {
1458                                 dprintk(1,
1459                                         KERN_ERR
1460                                         "%s: failed to load module %s: %d\n",
1461                                         ZR_DEVNAME(zr), i2c_enc_name, result);
1462                         }
1463                 }
1464
1465                 if (zoran_register_i2c(zr) < 0) {
1466                         dprintk(1,
1467                                 KERN_ERR
1468                                 "%s: find_zr36057() - can't initialize i2c bus\n",
1469                                 ZR_DEVNAME(zr));
1470                         goto zr_free_irq;
1471                 }
1472
1473                 dprintk(2,
1474                         KERN_INFO "%s: Initializing videocodec bus...\n",
1475                         ZR_DEVNAME(zr));
1476
1477                 if (zr->card.video_codec != 0 &&
1478                     (codec_name =
1479                      codecid_to_modulename(zr->card.video_codec)) != NULL) {
1480                         if ((result = request_module(codec_name)) < 0) {
1481                                 dprintk(1,
1482                                         KERN_ERR
1483                                         "%s: failed to load modules %s: %d\n",
1484                                         ZR_DEVNAME(zr), codec_name, result);
1485                         }
1486                 }
1487                 if (zr->card.video_vfe != 0 &&
1488                     (vfe_name =
1489                      codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1490                         if ((result = request_module(vfe_name)) < 0) {
1491                                 dprintk(1,
1492                                         KERN_ERR
1493                                         "%s: failed to load modules %s: %d\n",
1494                                         ZR_DEVNAME(zr), vfe_name, result);
1495                         }
1496                 }
1497
1498                 /* reset JPEG codec */
1499                 jpeg_codec_sleep(zr, 1);
1500                 jpeg_codec_reset(zr);
1501                 /* video bus enabled */
1502                 /* display codec revision */
1503                 if (zr->card.video_codec != 0) {
1504                         master_codec = zoran_setup_videocodec(zr,
1505                                                               zr->card.video_codec);
1506                         if (!master_codec)
1507                                 goto zr_unreg_i2c;
1508                         zr->codec = videocodec_attach(master_codec);
1509                         if (!zr->codec) {
1510                                 dprintk(1,
1511                                         KERN_ERR
1512                                         "%s: find_zr36057() - no codec found\n",
1513                                         ZR_DEVNAME(zr));
1514                                 goto zr_free_codec;
1515                         }
1516                         if (zr->codec->type != zr->card.video_codec) {
1517                                 dprintk(1,
1518                                         KERN_ERR
1519                                         "%s: find_zr36057() - wrong codec\n",
1520                                         ZR_DEVNAME(zr));
1521                                 goto zr_detach_codec;
1522                         }
1523                 }
1524                 if (zr->card.video_vfe != 0) {
1525                         master_vfe = zoran_setup_videocodec(zr,
1526                                                             zr->card.video_vfe);
1527                         if (!master_vfe)
1528                                 goto zr_detach_codec;
1529                         zr->vfe = videocodec_attach(master_vfe);
1530                         if (!zr->vfe) {
1531                                 dprintk(1,
1532                                         KERN_ERR
1533                                         "%s: find_zr36057() - no VFE found\n",
1534                                         ZR_DEVNAME(zr));
1535                                 goto zr_free_vfe;
1536                         }
1537                         if (zr->vfe->type != zr->card.video_vfe) {
1538                                 dprintk(1,
1539                                         KERN_ERR
1540                                         "%s: find_zr36057() = wrong VFE\n",
1541                                         ZR_DEVNAME(zr));
1542                                 goto zr_detach_vfe;
1543                         }
1544                 }
1545                 /* Success so keep the pci_dev referenced */
1546                 pci_dev_get(zr->pci_dev);
1547                 zoran_num++;
1548                 continue;
1549
1550                 // Init errors
1551               zr_detach_vfe:
1552                 videocodec_detach(zr->vfe);
1553               zr_free_vfe:
1554                 kfree(master_vfe);
1555               zr_detach_codec:
1556                 videocodec_detach(zr->codec);
1557               zr_free_codec:
1558                 kfree(master_codec);
1559               zr_unreg_i2c:
1560                 zoran_unregister_i2c(zr);
1561               zr_free_irq:
1562                 btwrite(0, ZR36057_SPGPPCR);
1563                 free_irq(zr->pci_dev->irq, zr);
1564               zr_unmap:
1565                 iounmap(zr->zr36057_mem);
1566                 continue;
1567         }
1568         if (dev)        /* Clean up ref count on early exit */
1569                 pci_dev_put(dev);
1570
1571         if (zoran_num == 0) {
1572                 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1573         }
1574         return zoran_num;
1575 }
1576
1577 static int __init
1578 init_dc10_cards (void)
1579 {
1580         int i;
1581
1582         memset(zoran, 0, sizeof(zoran));
1583         printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1584                MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1585
1586         /* Look for cards */
1587         if (find_zr36057() < 0) {
1588                 return -EIO;
1589         }
1590         if (zoran_num == 0)
1591                 return -ENODEV;
1592         dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1593                 zoran_num);
1594         /* check the parameters we have been given, adjust if necessary */
1595         if (v4l_nbufs < 2)
1596                 v4l_nbufs = 2;
1597         if (v4l_nbufs > VIDEO_MAX_FRAME)
1598                 v4l_nbufs = VIDEO_MAX_FRAME;
1599         /* The user specfies the in KB, we want them in byte
1600          * (and page aligned) */
1601         v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1602         if (v4l_bufsize < 32768)
1603                 v4l_bufsize = 32768;
1604         /* 2 MB is arbitrary but sufficient for the maximum possible images */
1605         if (v4l_bufsize > 2048 * 1024)
1606                 v4l_bufsize = 2048 * 1024;
1607         if (jpg_nbufs < 4)
1608                 jpg_nbufs = 4;
1609         if (jpg_nbufs > BUZ_MAX_FRAME)
1610                 jpg_nbufs = BUZ_MAX_FRAME;
1611         jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1612         if (jpg_bufsize < 8192)
1613                 jpg_bufsize = 8192;
1614         if (jpg_bufsize > (512 * 1024))
1615                 jpg_bufsize = 512 * 1024;
1616         /* Use parameter for vidmem or try to find a video card */
1617         if (vidmem) {
1618                 dprintk(1,
1619                         KERN_INFO
1620                         "%s: Using supplied video memory base address @ 0x%lx\n",
1621                         ZORAN_NAME, vidmem);
1622         }
1623
1624         /* random nonsense */
1625         dprintk(6, KERN_DEBUG "Jotti is een held!\n");
1626
1627         /* some mainboards might not do PCI-PCI data transfer well */
1628         if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1629                 dprintk(1,
1630                         KERN_WARNING
1631                         "%s: chipset does not support reliable PCI-PCI DMA\n",
1632                         ZORAN_NAME);
1633         }
1634
1635         /* take care of Natoma chipset and a revision 1 zr36057 */
1636         for (i = 0; i < zoran_num; i++) {
1637                 struct zoran *zr = &zoran[i];
1638
1639                 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1640                         zr->jpg_buffers.need_contiguous = 1;
1641                         dprintk(1,
1642                                 KERN_INFO
1643                                 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1644                                 ZR_DEVNAME(zr));
1645                 }
1646
1647                 if (zr36057_init(zr) < 0) {
1648                         for (i = 0; i < zoran_num; i++)
1649                                 zoran_release(&zoran[i]);
1650                         return -EIO;
1651                 }
1652                 zoran_proc_init(zr);
1653         }
1654
1655         return 0;
1656 }
1657
1658 static void __exit
1659 unload_dc10_cards (void)
1660 {
1661         int i;
1662
1663         for (i = 0; i < zoran_num; i++)
1664                 zoran_release(&zoran[i]);
1665 }
1666
1667 module_init(init_dc10_cards);
1668 module_exit(unload_dc10_cards);