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