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 #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, 0);
  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, 0);
  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, 0);
  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, 0);
  88
  89 /*
  90    Default input and video norm at startup of the driver.
  91 */
  92
  93 static int default_input = 0;   /* 0=Composite, 1=S-Video */
  94 module_param(default_input, int, 0);
  95 MODULE_PARM_DESC(default_input,
  96                  "Default input (0=Composite, 1=S-Video, 2=Internal)");
  97
  98 static int default_mux = 1;     /* 6 Eyes input selection */
  99 module_param(default_mux, int, 0);
 100 MODULE_PARM_DESC(default_mux,
 101                  "Default 6 Eyes mux setting (Input selection)");
 102
 103 static int default_norm = 0;    /* 0=PAL, 1=NTSC 2=SECAM */
 104 module_param(default_norm, int, 0);
 105 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
 106
 107 static int video_nr = -1;       /* /dev/videoN, -1 for autodetect */
 108 module_param(video_nr, int, 0);
 109 MODULE_PARM_DESC(video_nr, "video device number");
 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, 0);
 131 MODULE_PARM_DESC(v4l_nbufs, "Maximum number of V4L buffers to use");
 132 module_param(v4l_bufsize, int, 0);
 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, 0);
 138 MODULE_PARM_DESC(jpg_nbufs, "Maximum number of JPG buffers to use");
 139 module_param(jpg_bufsize, int, 0);
 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, 0);
 145 MODULE_PARM_DESC(pass_through,
 146                  "Pass TV signal through to TV-out when idling");
 147
 148 static int debug = 1;
 149 int *zr_debug = &debug;
 150 module_param(debug, int, 0);
 151 MODULE_PARM_DESC(debug, "Debug level (0-4)");
 152
 153 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
 154 MODULE_AUTHOR("Serguei Miridonov");
 155 MODULE_LICENSE("GPL");
 156
 157 static struct pci_device_id zr36067_pci_tbl[] = {
 158         {PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057,
 159          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 160         {0}
 161 };
 162 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
 163
 164 #define dprintk(num, format, args...) \
 165         do { \
 166                 if (*zr_debug >= num) \
 167                         printk(format, ##args); \
 168         } while (0)
 169
 170 int zoran_num;                  /* number of Buzs in use */
 171 struct zoran zoran[BUZ_MAX];
 172
 173 /* videocodec bus functions ZR36060 */
 174 static u32
 175 zr36060_read (struct videocodec *codec,
 176               u16                reg)
 177 {
 178         struct zoran *zr = (struct zoran *) codec->master_data->data;
 179         __u32 data;
 180
 181         if (post_office_wait(zr)
 182             || post_office_write(zr, 0, 1, reg >> 8)
 183             || post_office_write(zr, 0, 2, reg & 0xff)) {
 184                 return -1;
 185         }
 186
 187         data = post_office_read(zr, 0, 3) & 0xff;
 188         return data;
 189 }
 190
 191 static void
 192 zr36060_write (struct videocodec *codec,
 193                u16                reg,
 194                u32                val)
 195 {
 196         struct zoran *zr = (struct zoran *) codec->master_data->data;
 197
 198         if (post_office_wait(zr)
 199             || post_office_write(zr, 0, 1, reg >> 8)
 200             || post_office_write(zr, 0, 2, reg & 0xff)) {
 201                 return;
 202         }
 203
 204         post_office_write(zr, 0, 3, val & 0xff);
 205 }
 206
 207 /* videocodec bus functions ZR36050 */
 208 static u32
 209 zr36050_read (struct videocodec *codec,
 210               u16                reg)
 211 {
 212         struct zoran *zr = (struct zoran *) codec->master_data->data;
 213         __u32 data;
 214
 215         if (post_office_wait(zr)
 216             || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
 217                 return -1;
 218         }
 219
 220         data = post_office_read(zr, 0, reg & 0x03) & 0xff;      // reg. LOWBYTES + read
 221         return data;
 222 }
 223
 224 static void
 225 zr36050_write (struct videocodec *codec,
 226                u16                reg,
 227                u32                val)
 228 {
 229         struct zoran *zr = (struct zoran *) codec->master_data->data;
 230
 231         if (post_office_wait(zr)
 232             || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
 233                 return;
 234         }
 235
 236         post_office_write(zr, 0, reg & 0x03, val & 0xff);       // reg. LOWBYTES + wr. data
 237 }
 238
 239 /* videocodec bus functions ZR36016 */
 240 static u32
 241 zr36016_read (struct videocodec *codec,
 242               u16                reg)
 243 {
 244         struct zoran *zr = (struct zoran *) codec->master_data->data;
 245         __u32 data;
 246
 247         if (post_office_wait(zr)) {
 248                 return -1;
 249         }
 250
 251         data = post_office_read(zr, 2, reg & 0x03) & 0xff;      // read
 252         return data;
 253 }
 254
 255 /* hack for in zoran_device.c */
 256 void
 257 zr36016_write (struct videocodec *codec,
 258                u16                reg,
 259                u32                val)
 260 {
 261         struct zoran *zr = (struct zoran *) codec->master_data->data;
 262
 263         if (post_office_wait(zr)) {
 264                 return;
 265         }
 266
 267         post_office_write(zr, 2, reg & 0x03, val & 0x0ff);      // wr. data
 268 }
 269
 270 /*
 271  * Board specific information
 272  */
 273
 274 static void
 275 dc10_init (struct zoran *zr)
 276 {
 277         dprintk(3, KERN_DEBUG "%s: dc10_init()\n", ZR_DEVNAME(zr));
 278
 279         /* Pixel clock selection */
 280         GPIO(zr, 4, 0);
 281         GPIO(zr, 5, 1);
 282         /* Enable the video bus sync signals */
 283         GPIO(zr, 7, 0);
 284 }
 285
 286 static void
 287 dc10plus_init (struct zoran *zr)
 288 {
 289         dprintk(3, KERN_DEBUG "%s: dc10plus_init()\n", ZR_DEVNAME(zr));
 290 }
 291
 292 static void
 293 buz_init (struct zoran *zr)
 294 {
 295         dprintk(3, KERN_DEBUG "%s: buz_init()\n", ZR_DEVNAME(zr));
 296
 297         /* some stuff from Iomega */
 298         pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
 299         pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
 300         pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
 301 }
 302
 303 static void
 304 lml33_init (struct zoran *zr)
 305 {
 306         dprintk(3, KERN_DEBUG "%s: lml33_init()\n", ZR_DEVNAME(zr));
 307
 308         GPIO(zr, 2, 1);         // Set Composite input/output
 309 }
 310
 311 static void
 312 avs6eyes_init (struct zoran *zr)
 313 {
 314         // AverMedia 6-Eyes original driver by Christer Weinigel
 315
 316         // Lifted straight from Christer's old driver and
 317         // modified slightly by Martin Samuelsson.
 318
 319         int mux = default_mux; /* 1 = BT866, 7 = VID1 */
 320
 321         GPIO(zr, 4, 1); /* Bt866 SLEEP on */
 322         udelay(2);
 323
 324         GPIO(zr, 0, 1); /* ZR36060 /RESET on */
 325         GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */
 326         GPIO(zr, 2, mux & 1);   /* MUX S0 */
 327         GPIO(zr, 3, 0); /* /FRAME on */
 328         GPIO(zr, 4, 0); /* Bt866 SLEEP off */
 329         GPIO(zr, 5, mux & 2);   /* MUX S1 */
 330         GPIO(zr, 6, 0); /* ? */
 331         GPIO(zr, 7, mux & 4);   /* MUX S2 */
 332
 333 }
 334
 335 static char *
 336 i2cid_to_modulename (u16 i2c_id)
 337 {
 338         char *name = NULL;
 339
 340         switch (i2c_id) {
 341         case I2C_DRIVERID_SAA7110:
 342                 name = "saa7110";
 343                 break;
 344         case I2C_DRIVERID_SAA7111A:
 345                 name = "saa7111";
 346                 break;
 347         case I2C_DRIVERID_SAA7114:
 348                 name = "saa7114";
 349                 break;
 350         case I2C_DRIVERID_SAA7185B:
 351                 name = "saa7185";
 352                 break;
 353         case I2C_DRIVERID_ADV7170:
 354                 name = "adv7170";
 355                 break;
 356         case I2C_DRIVERID_ADV7175:
 357                 name = "adv7175";
 358                 break;
 359         case I2C_DRIVERID_BT819:
 360                 name = "bt819";
 361                 break;
 362         case I2C_DRIVERID_BT856:
 363                 name = "bt856";
 364                 break;
 365         case I2C_DRIVERID_VPX3220:
 366                 name = "vpx3220";
 367                 break;
 368 /*      case I2C_DRIVERID_VPX3224:
 369                 name = "vpx3224";
 370                 break;
 371         case I2C_DRIVERID_MSE3000:
 372                 name = "mse3000";
 373                 break;*/
 374         default:
 375                 break;
 376         }
 377
 378         return name;
 379 }
 380
 381 static char *
 382 codecid_to_modulename (u16 codecid)
 383 {
 384         char *name = NULL;
 385
 386         switch (codecid) {
 387         case CODEC_TYPE_ZR36060:
 388                 name = "zr36060";
 389                 break;
 390         case CODEC_TYPE_ZR36050:
 391                 name = "zr36050";
 392                 break;
 393         case CODEC_TYPE_ZR36016:
 394                 name = "zr36016";
 395                 break;
 396         default:
 397                 break;
 398         }
 399
 400         return name;
 401 }
 402
 403 // struct tvnorm {
 404 //      u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
 405 // };
 406
 407 static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
 408 static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
 409 static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
 410 static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
 411
 412 static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 };
 413 static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 };
 414
 415 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
 416 static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
 417 static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
 418
 419 /* FIXME: I cannot swap U and V in saa7114, so i do one
 420  * pixel left shift in zoran (75 -> 74)
 421  * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */
 422 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
 423 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
 424
 425 /* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
 426  * copy Maxim's left shift hack for the 6 Eyes.
 427  *
 428  * Christer's driver used the unshifted norms, though...
 429  * /Sam  */
 430 static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
 431 static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
 432
 433 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
 434         {
 435                 .type = DC10_old,
 436                 .name = "DC10(old)",
 437                 .i2c_decoder = I2C_DRIVERID_VPX3220,
 438                 /*.i2c_encoder = I2C_DRIVERID_MSE3000,*/
 439                 .video_codec = CODEC_TYPE_ZR36050,
 440                 .video_vfe = CODEC_TYPE_ZR36016,
 441
 442                 .inputs = 3,
 443                 .input = {
 444                         { 1, "Composite" },
 445                         { 2, "S-Video" },
 446                         { 0, "Internal/comp" }
 447                 },
 448                 .norms = 3,
 449                 .tvn = {
 450                         &f50sqpixel_dc10,
 451                         &f60sqpixel_dc10,
 452                         &f50sqpixel_dc10
 453                 },
 454                 .jpeg_int = 0,
 455                 .vsync_int = ZR36057_ISR_GIRQ1,
 456                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
 457                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
 458                 .gpcs = { -1, 0 },
 459                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 460                 .gws_not_connected = 0,
 461                 .input_mux = 0,
 462                 .init = &dc10_init,
 463         }, {
 464                 .type = DC10_new,
 465                 .name = "DC10(new)",
 466                 .i2c_decoder = I2C_DRIVERID_SAA7110,
 467                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 468                 .video_codec = CODEC_TYPE_ZR36060,
 469
 470                 .inputs = 3,
 471                 .input = {
 472                                 { 0, "Composite" },
 473                                 { 7, "S-Video" },
 474                                 { 5, "Internal/comp" }
 475                         },
 476                 .norms = 3,
 477                 .tvn = {
 478                                 &f50sqpixel,
 479                                 &f60sqpixel,
 480                                 &f50sqpixel},
 481                 .jpeg_int = ZR36057_ISR_GIRQ0,
 482                 .vsync_int = ZR36057_ISR_GIRQ1,
 483                 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
 484                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 485                 .gpcs = { -1, 1},
 486                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
 487                 .gws_not_connected = 0,
 488                 .input_mux = 0,
 489                 .init = &dc10plus_init,
 490         }, {
 491                 .type = DC10plus,
 492                 .name = "DC10plus",
 493                 .vendor_id = PCI_VENDOR_ID_MIRO,
 494                 .device_id = PCI_DEVICE_ID_MIRO_DC10PLUS,
 495                 .i2c_decoder = I2C_DRIVERID_SAA7110,
 496                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 497                 .video_codec = CODEC_TYPE_ZR36060,
 498
 499                 .inputs = 3,
 500                 .input = {
 501                         { 0, "Composite" },
 502                         { 7, "S-Video" },
 503                         { 5, "Internal/comp" }
 504                 },
 505                 .norms = 3,
 506                 .tvn = {
 507                         &f50sqpixel,
 508                         &f60sqpixel,
 509                         &f50sqpixel
 510                 },
 511                 .jpeg_int = ZR36057_ISR_GIRQ0,
 512                 .vsync_int = ZR36057_ISR_GIRQ1,
 513                 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
 514                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 515                 .gpcs = { -1, 1 },
 516                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
 517                 .gws_not_connected = 0,
 518                 .input_mux = 0,
 519                 .init = &dc10plus_init,
 520         }, {
 521                 .type = DC30,
 522                 .name = "DC30",
 523                 .i2c_decoder = I2C_DRIVERID_VPX3220,
 524                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 525                 .video_codec = CODEC_TYPE_ZR36050,
 526                 .video_vfe = CODEC_TYPE_ZR36016,
 527
 528                 .inputs = 3,
 529                 .input = {
 530                         { 1, "Composite" },
 531                         { 2, "S-Video" },
 532                         { 0, "Internal/comp" }
 533                 },
 534                 .norms = 3,
 535                 .tvn = {
 536                         &f50sqpixel_dc10,
 537                         &f60sqpixel_dc10,
 538                         &f50sqpixel_dc10
 539                 },
 540                 .jpeg_int = 0,
 541                 .vsync_int = ZR36057_ISR_GIRQ1,
 542                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
 543                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
 544                 .gpcs = { -1, 0 },
 545                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 546                 .gws_not_connected = 0,
 547                 .input_mux = 0,
 548                 .init = &dc10_init,
 549         }, {
 550                 .type = DC30plus,
 551                 .name = "DC30plus",
 552                 .vendor_id = PCI_VENDOR_ID_MIRO,
 553                 .device_id = PCI_DEVICE_ID_MIRO_DC30PLUS,
 554                 .i2c_decoder = I2C_DRIVERID_VPX3220,
 555                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 556                 .video_codec = CODEC_TYPE_ZR36050,
 557                 .video_vfe = CODEC_TYPE_ZR36016,
 558
 559                 .inputs = 3,
 560                 .input = {
 561                         { 1, "Composite" },
 562                         { 2, "S-Video" },
 563                         { 0, "Internal/comp" }
 564                 },
 565                 .norms = 3,
 566                 .tvn = {
 567                         &f50sqpixel_dc10,
 568                         &f60sqpixel_dc10,
 569                         &f50sqpixel_dc10
 570                 },
 571                 .jpeg_int = 0,
 572                 .vsync_int = ZR36057_ISR_GIRQ1,
 573                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
 574                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
 575                 .gpcs = { -1, 0 },
 576                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 577                 .gws_not_connected = 0,
 578                 .input_mux = 0,
 579                 .init = &dc10_init,
 580         }, {
 581                 .type = LML33,
 582                 .name = "LML33",
 583                 .i2c_decoder = I2C_DRIVERID_BT819,
 584                 .i2c_encoder = I2C_DRIVERID_BT856,
 585                 .video_codec = CODEC_TYPE_ZR36060,
 586
 587                 .inputs = 2,
 588                 .input = {
 589                         { 0, "Composite" },
 590                         { 7, "S-Video" }
 591                 },
 592                 .norms = 2,
 593                 .tvn = {
 594                         &f50ccir601_lml33,
 595                         &f60ccir601_lml33,
 596                         NULL
 597                 },
 598                 .jpeg_int = ZR36057_ISR_GIRQ1,
 599                 .vsync_int = ZR36057_ISR_GIRQ0,
 600                 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
 601                 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
 602                 .gpcs = { 3, 1 },
 603                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
 604                 .gws_not_connected = 1,
 605                 .input_mux = 0,
 606                 .init = &lml33_init,
 607         }, {
 608                 .type = LML33R10,
 609                 .name = "LML33R10",
 610                 .vendor_id = PCI_VENDOR_ID_ELECTRONICDESIGNGMBH,
 611                 .device_id = PCI_DEVICE_ID_LML_33R10,
 612                 .i2c_decoder = I2C_DRIVERID_SAA7114,
 613                 .i2c_encoder = I2C_DRIVERID_ADV7170,
 614                 .video_codec = CODEC_TYPE_ZR36060,
 615
 616                 .inputs = 2,
 617                 .input = {
 618                         { 0, "Composite" },
 619                         { 7, "S-Video" }
 620                 },
 621                 .norms = 2,
 622                 .tvn = {
 623                         &f50ccir601_lm33r10,
 624                         &f60ccir601_lm33r10,
 625                         NULL
 626                 },
 627                 .jpeg_int = ZR36057_ISR_GIRQ1,
 628                 .vsync_int = ZR36057_ISR_GIRQ0,
 629                 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
 630                 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
 631                 .gpcs = { 3, 1 },
 632                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
 633                 .gws_not_connected = 1,
 634                 .input_mux = 0,
 635                 .init = &lml33_init,
 636         }, {
 637                 .type = BUZ,
 638                 .name = "Buz",
 639                 .vendor_id = PCI_VENDOR_ID_IOMEGA,
 640                 .device_id = PCI_DEVICE_ID_IOMEGA_BUZ,
 641                 .i2c_decoder = I2C_DRIVERID_SAA7111A,
 642                 .i2c_encoder = I2C_DRIVERID_SAA7185B,
 643                 .video_codec = CODEC_TYPE_ZR36060,
 644
 645                 .inputs = 2,
 646                 .input = {
 647                         { 3, "Composite" },
 648                         { 7, "S-Video" }
 649                 },
 650                 .norms = 3,
 651                 .tvn = {
 652                         &f50ccir601,
 653                         &f60ccir601,
 654                         &f50ccir601
 655                 },
 656                 .jpeg_int = ZR36057_ISR_GIRQ1,
 657                 .vsync_int = ZR36057_ISR_GIRQ0,
 658                 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
 659                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 660                 .gpcs = { 3, 1 },
 661                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
 662                 .gws_not_connected = 1,
 663                 .input_mux = 0,
 664                 .init = &buz_init,
 665         }, {
 666                 .type = AVS6EYES,
 667                 .name = "6-Eyes",
 668                 /* AverMedia chose not to brand the 6-Eyes. Thus it
 669                    can't be autodetected, and requires card=x. */
 670                 .vendor_id = -1,
 671                 .device_id = -1,
 672                 .i2c_decoder = I2C_DRIVERID_KS0127,
 673                 .i2c_encoder = I2C_DRIVERID_BT866,
 674                 .video_codec = CODEC_TYPE_ZR36060,
 675
 676                 .inputs = 10,
 677                 .input = {
 678                         { 0, "Composite 1" },
 679                         { 1, "Composite 2" },
 680                         { 2, "Composite 3" },
 681                         { 4, "Composite 4" },
 682                         { 5, "Composite 5" },
 683                         { 6, "Composite 6" },
 684                         { 8, "S-Video 1" },
 685                         { 9, "S-Video 2" },
 686                         {10, "S-Video 3" },
 687                         {15, "YCbCr" }
 688                 },
 689                 .norms = 2,
 690                 .tvn = {
 691                         &f50ccir601_avs6eyes,
 692                         &f60ccir601_avs6eyes,
 693                         NULL
 694                 },
 695                 .jpeg_int = ZR36057_ISR_GIRQ1,
 696                 .vsync_int = ZR36057_ISR_GIRQ0,
 697                 .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
 698                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
 699                 .gpcs = { 3, 1 },                       // Validity unknown /Sam
 700                 .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 },  // Validity unknown /Sam
 701                 .gws_not_connected = 1,
 702                 .input_mux = 1,
 703                 .init = &avs6eyes_init,
 704         }
 705
 706 };
 707
 708 /*
 709  * I2C functions
 710  */
 711 /* software I2C functions */
 712 static int
 713 zoran_i2c_getsda (void *data)
 714 {
 715         struct zoran *zr = (struct zoran *) data;
 716
 717         return (btread(ZR36057_I2CBR) >> 1) & 1;
 718 }
 719
 720 static int
 721 zoran_i2c_getscl (void *data)
 722 {
 723         struct zoran *zr = (struct zoran *) data;
 724
 725         return btread(ZR36057_I2CBR) & 1;
 726 }
 727
 728 static void
 729 zoran_i2c_setsda (void *data,
 730                   int   state)
 731 {
 732         struct zoran *zr = (struct zoran *) data;
 733
 734         if (state)
 735                 zr->i2cbr |= 2;
 736         else
 737                 zr->i2cbr &= ~2;
 738         btwrite(zr->i2cbr, ZR36057_I2CBR);
 739 }
 740
 741 static void
 742 zoran_i2c_setscl (void *data,
 743                   int   state)
 744 {
 745         struct zoran *zr = (struct zoran *) data;
 746
 747         if (state)
 748                 zr->i2cbr |= 1;
 749         else
 750                 zr->i2cbr &= ~1;
 751         btwrite(zr->i2cbr, ZR36057_I2CBR);
 752 }
 753
 754 static int
 755 zoran_i2c_client_register (struct i2c_client *client)
 756 {
 757         struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
 758         int res = 0;
 759
 760         dprintk(2,
 761                 KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
 762                 ZR_DEVNAME(zr), client->driver->id);
 763
 764         mutex_lock(&zr->resource_lock);
 765
 766         if (zr->user > 0) {
 767                 /* we're already busy, so we keep a reference to
 768                  * them... Could do a lot of stuff here, but this
 769                  * is easiest. (Did I ever mention I'm a lazy ass?)
 770                  */
 771                 res = -EBUSY;
 772                 goto clientreg_unlock_and_return;
 773         }
 774
 775         if (client->driver->id == zr->card.i2c_decoder)
 776                 zr->decoder = client;
 777         else if (client->driver->id == zr->card.i2c_encoder)
 778                 zr->encoder = client;
 779         else {
 780                 res = -ENODEV;
 781                 goto clientreg_unlock_and_return;
 782         }
 783
 784 clientreg_unlock_and_return:
 785         mutex_unlock(&zr->resource_lock);
 786
 787         return res;
 788 }
 789
 790 static int
 791 zoran_i2c_client_unregister (struct i2c_client *client)
 792 {
 793         struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
 794         int res = 0;
 795
 796         dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
 797
 798         mutex_lock(&zr->resource_lock);
 799
 800         if (zr->user > 0) {
 801                 res = -EBUSY;
 802                 goto clientunreg_unlock_and_return;
 803         }
 804
 805         /* try to locate it */
 806         if (client == zr->encoder) {
 807                 zr->encoder = NULL;
 808         } else if (client == zr->decoder) {
 809                 zr->decoder = NULL;
 810                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
 811         }
 812 clientunreg_unlock_and_return:
 813         mutex_unlock(&zr->resource_lock);
 814         return res;
 815 }
 816
 817 static struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
 818         .setsda = zoran_i2c_setsda,
 819         .setscl = zoran_i2c_setscl,
 820         .getsda = zoran_i2c_getsda,
 821         .getscl = zoran_i2c_getscl,
 822         .udelay = 10,
 823         .mdelay = 0,
 824         .timeout = 100,
 825 };
 826
 827 static struct i2c_adapter zoran_i2c_adapter_template = {
 828         .name = "zr36057",
 829         .id = I2C_HW_B_ZR36067,
 830         .algo = NULL,
 831         .client_register = zoran_i2c_client_register,
 832         .client_unregister = zoran_i2c_client_unregister,
 833 };
 834
 835 static int
 836 zoran_register_i2c (struct zoran *zr)
 837 {
 838         memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
 839                sizeof(struct i2c_algo_bit_data));
 840         zr->i2c_algo.data = zr;
 841         memcpy(&zr->i2c_adapter, &zoran_i2c_adapter_template,
 842                sizeof(struct i2c_adapter));
 843         strncpy(I2C_NAME(&zr->i2c_adapter), ZR_DEVNAME(zr),
 844                 sizeof(I2C_NAME(&zr->i2c_adapter)) - 1);
 845         i2c_set_adapdata(&zr->i2c_adapter, zr);
 846         zr->i2c_adapter.algo_data = &zr->i2c_algo;
 847         return i2c_bit_add_bus(&zr->i2c_adapter);
 848 }
 849
 850 static void
 851 zoran_unregister_i2c (struct zoran *zr)
 852 {
 853         i2c_bit_del_bus((&zr->i2c_adapter));
 854 }
 855
 856 /* Check a zoran_params struct for correctness, insert default params */
 857
 858 int
 859 zoran_check_jpg_settings (struct zoran              *zr,
 860                           struct zoran_jpg_settings *settings)
 861 {
 862         int err = 0, err0 = 0;
 863
 864         dprintk(4,
 865                 KERN_DEBUG
 866                 "%s: check_jpg_settings() - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
 867                 ZR_DEVNAME(zr), settings->decimation, settings->HorDcm,
 868                 settings->VerDcm, settings->TmpDcm);
 869         dprintk(4,
 870                 KERN_DEBUG
 871                 "%s: check_jpg_settings() - x: %d, y: %d, w: %d, y: %d\n",
 872                 ZR_DEVNAME(zr), settings->img_x, settings->img_y,
 873                 settings->img_width, settings->img_height);
 874         /* Check decimation, set default values for decimation = 1, 2, 4 */
 875         switch (settings->decimation) {
 876         case 1:
 877
 878                 settings->HorDcm = 1;
 879                 settings->VerDcm = 1;
 880                 settings->TmpDcm = 1;
 881                 settings->field_per_buff = 2;
 882                 settings->img_x = 0;
 883                 settings->img_y = 0;
 884                 settings->img_width = BUZ_MAX_WIDTH;
 885                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 886                 break;
 887         case 2:
 888
 889                 settings->HorDcm = 2;
 890                 settings->VerDcm = 1;
 891                 settings->TmpDcm = 2;
 892                 settings->field_per_buff = 1;
 893                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 894                 settings->img_y = 0;
 895                 settings->img_width =
 896                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 897                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 898                 break;
 899         case 4:
 900
 901                 if (zr->card.type == DC10_new) {
 902                         dprintk(1,
 903                                 KERN_DEBUG
 904                                 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
 905                                 ZR_DEVNAME(zr));
 906                         err0++;
 907                         break;
 908                 }
 909
 910                 settings->HorDcm = 4;
 911                 settings->VerDcm = 2;
 912                 settings->TmpDcm = 2;
 913                 settings->field_per_buff = 1;
 914                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 915                 settings->img_y = 0;
 916                 settings->img_width =
 917                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 918                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 919                 break;
 920         case 0:
 921
 922                 /* We have to check the data the user has set */
 923
 924                 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
 925                     (zr->card.type == DC10_new || settings->HorDcm != 4))
 926                         err0++;
 927                 if (settings->VerDcm != 1 && settings->VerDcm != 2)
 928                         err0++;
 929                 if (settings->TmpDcm != 1 && settings->TmpDcm != 2)
 930                         err0++;
 931                 if (settings->field_per_buff != 1 &&
 932                     settings->field_per_buff != 2)
 933                         err0++;
 934                 if (settings->img_x < 0)
 935                         err0++;
 936                 if (settings->img_y < 0)
 937                         err0++;
 938                 if (settings->img_width < 0)
 939                         err0++;
 940                 if (settings->img_height < 0)
 941                         err0++;
 942                 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH)
 943                         err0++;
 944                 if (settings->img_y + settings->img_height >
 945                     BUZ_MAX_HEIGHT / 2)
 946                         err0++;
 947                 if (settings->HorDcm && settings->VerDcm) {
 948                         if (settings->img_width %
 949                             (16 * settings->HorDcm) != 0)
 950                                 err0++;
 951                         if (settings->img_height %
 952                             (8 * settings->VerDcm) != 0)
 953                                 err0++;
 954                 }
 955
 956                 if (err0) {
 957                         dprintk(1,
 958                                 KERN_ERR
 959                                 "%s: check_jpg_settings() - error in params for decimation = 0\n",
 960                                 ZR_DEVNAME(zr));
 961                         err++;
 962                 }
 963                 break;
 964         default:
 965                 dprintk(1,
 966                         KERN_ERR
 967                         "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
 968                         ZR_DEVNAME(zr), settings->decimation);
 969                 err++;
 970                 break;
 971         }
 972
 973         if (settings->jpg_comp.quality > 100)
 974                 settings->jpg_comp.quality = 100;
 975         if (settings->jpg_comp.quality < 5)
 976                 settings->jpg_comp.quality = 5;
 977         if (settings->jpg_comp.APPn < 0)
 978                 settings->jpg_comp.APPn = 0;
 979         if (settings->jpg_comp.APPn > 15)
 980                 settings->jpg_comp.APPn = 15;
 981         if (settings->jpg_comp.APP_len < 0)
 982                 settings->jpg_comp.APP_len = 0;
 983         if (settings->jpg_comp.APP_len > 60)
 984                 settings->jpg_comp.APP_len = 60;
 985         if (settings->jpg_comp.COM_len < 0)
 986                 settings->jpg_comp.COM_len = 0;
 987         if (settings->jpg_comp.COM_len > 60)
 988                 settings->jpg_comp.COM_len = 60;
 989         if (err)
 990                 return -EINVAL;
 991         return 0;
 992 }
 993
 994 void
 995 zoran_open_init_params (struct zoran *zr)
 996 {
 997         int i;
 998
 999         /* User must explicitly set a window */
1000         zr->overlay_settings.is_set = 0;
1001         zr->overlay_mask = NULL;
1002         zr->overlay_active = ZORAN_FREE;
1003
1004         zr->v4l_memgrab_active = 0;
1005         zr->v4l_overlay_active = 0;
1006         zr->v4l_grab_frame = NO_GRAB_ACTIVE;
1007         zr->v4l_grab_seq = 0;
1008         zr->v4l_settings.width = 192;
1009         zr->v4l_settings.height = 144;
1010         zr->v4l_settings.format = &zoran_formats[4];    /* YUY2 - YUV-4:2:2 packed */
1011         zr->v4l_settings.bytesperline =
1012             zr->v4l_settings.width *
1013             ((zr->v4l_settings.format->depth + 7) / 8);
1014
1015         /* DMA ring stuff for V4L */
1016         zr->v4l_pend_tail = 0;
1017         zr->v4l_pend_head = 0;
1018         zr->v4l_sync_tail = 0;
1019         zr->v4l_buffers.active = ZORAN_FREE;
1020         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1021                 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
1022         }
1023         zr->v4l_buffers.allocated = 0;
1024
1025         for (i = 0; i < BUZ_MAX_FRAME; i++) {
1026                 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
1027         }
1028         zr->jpg_buffers.active = ZORAN_FREE;
1029         zr->jpg_buffers.allocated = 0;
1030         /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
1031         zr->jpg_settings.decimation = 1;
1032         zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
1033         if (zr->card.type != BUZ)
1034                 zr->jpg_settings.odd_even = 1;
1035         else
1036                 zr->jpg_settings.odd_even = 0;
1037         zr->jpg_settings.jpg_comp.APPn = 0;
1038         zr->jpg_settings.jpg_comp.APP_len = 0;  /* No APPn marker */
1039         memset(zr->jpg_settings.jpg_comp.APP_data, 0,
1040                sizeof(zr->jpg_settings.jpg_comp.APP_data));
1041         zr->jpg_settings.jpg_comp.COM_len = 0;  /* No COM marker */
1042         memset(zr->jpg_settings.jpg_comp.COM_data, 0,
1043                sizeof(zr->jpg_settings.jpg_comp.COM_data));
1044         zr->jpg_settings.jpg_comp.jpeg_markers =
1045             JPEG_MARKER_DHT | JPEG_MARKER_DQT;
1046         i = zoran_check_jpg_settings(zr, &zr->jpg_settings);
1047         if (i)
1048                 dprintk(1,
1049                         KERN_ERR
1050                         "%s: zoran_open_init_params() internal error\n",
1051                         ZR_DEVNAME(zr));
1052
1053         clear_interrupt_counters(zr);
1054         zr->testing = 0;
1055 }
1056
1057 static void __devinit
1058 test_interrupts (struct zoran *zr)
1059 {
1060         DEFINE_WAIT(wait);
1061         int timeout, icr;
1062
1063         clear_interrupt_counters(zr);
1064
1065         zr->testing = 1;
1066         icr = btread(ZR36057_ICR);
1067         btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
1068         prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
1069         timeout = schedule_timeout(HZ);
1070         finish_wait(&zr->test_q, &wait);
1071         btwrite(0, ZR36057_ICR);
1072         btwrite(0x78000000, ZR36057_ISR);
1073         zr->testing = 0;
1074         dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
1075         if (timeout) {
1076                 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
1077         }
1078         if (*zr_debug > 1)
1079                 print_interrupts(zr);
1080         btwrite(icr, ZR36057_ICR);
1081 }
1082
1083 static int __devinit
1084 zr36057_init (struct zoran *zr)
1085 {
1086         int j, err;
1087         int two = 2;
1088         int zero = 0;
1089
1090         dprintk(1,
1091                 KERN_INFO
1092                 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1093                 ZR_DEVNAME(zr), zr->id, zr);
1094
1095         /* default setup of all parameters which will persist between opens */
1096         zr->user = 0;
1097
1098         init_waitqueue_head(&zr->v4l_capq);
1099         init_waitqueue_head(&zr->jpg_capq);
1100         init_waitqueue_head(&zr->test_q);
1101         zr->jpg_buffers.allocated = 0;
1102         zr->v4l_buffers.allocated = 0;
1103
1104         zr->buffer.base = (void *) vidmem;
1105         zr->buffer.width = 0;
1106         zr->buffer.height = 0;
1107         zr->buffer.depth = 0;
1108         zr->buffer.bytesperline = 0;
1109
1110         /* Avoid nonsense settings from user for default input/norm */
1111         if (default_norm < VIDEO_MODE_PAL &&
1112             default_norm > VIDEO_MODE_SECAM)
1113                 default_norm = VIDEO_MODE_PAL;
1114         zr->norm = default_norm;
1115         if (!(zr->timing = zr->card.tvn[zr->norm])) {
1116                 dprintk(1,
1117                         KERN_WARNING
1118                         "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1119                         ZR_DEVNAME(zr));
1120                 zr->norm = VIDEO_MODE_PAL;
1121                 zr->timing = zr->card.tvn[zr->norm];
1122         }
1123
1124         zr->input = default_input = (default_input ? 1 : 0);
1125
1126         /* Should the following be reset at every open ? */
1127         zr->hue = 32768;
1128         zr->contrast = 32768;
1129         zr->saturation = 32768;
1130         zr->brightness = 32768;
1131
1132         /* default setup (will be repeated at every open) */
1133         zoran_open_init_params(zr);
1134
1135         /* allocate memory *before* doing anything to the hardware
1136          * in case allocation fails */
1137         zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1138         zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1139         if (!zr->stat_com || !zr->video_dev) {
1140                 dprintk(1,
1141                         KERN_ERR
1142                         "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1143                         ZR_DEVNAME(zr));
1144                 err = -ENOMEM;
1145                 goto exit_free;
1146         }
1147         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1148                 zr->stat_com[j] = 1;    /* mark as unavailable to zr36057 */
1149         }
1150
1151         /*
1152          *   Now add the template and register the device unit.
1153          */
1154         memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1155         strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1156         err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr);
1157         if (err < 0)
1158                 goto exit_unregister;
1159
1160         zoran_init_hardware(zr);
1161         if (*zr_debug > 2)
1162                 detect_guest_activity(zr);
1163         test_interrupts(zr);
1164         if (!pass_through) {
1165                 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1166                 encoder_command(zr, ENCODER_SET_INPUT, &two);
1167         }
1168
1169         zr->zoran_proc = NULL;
1170         zr->initialized = 1;
1171         return 0;
1172
1173 exit_unregister:
1174         zoran_unregister_i2c(zr);
1175 exit_free:
1176         kfree(zr->stat_com);
1177         kfree(zr->video_dev);
1178         return err;
1179 }
1180
1181 static void
1182 zoran_release (struct zoran *zr)
1183 {
1184         if (!zr->initialized)
1185                 return;
1186         /* unregister videocodec bus */
1187         if (zr->codec) {
1188                 struct videocodec_master *master = zr->codec->master_data;
1189
1190                 videocodec_detach(zr->codec);
1191                 kfree(master);
1192         }
1193         if (zr->vfe) {
1194                 struct videocodec_master *master = zr->vfe->master_data;
1195
1196                 videocodec_detach(zr->vfe);
1197                 kfree(master);
1198         }
1199
1200         /* unregister i2c bus */
1201         zoran_unregister_i2c(zr);
1202         /* disable PCI bus-mastering */
1203         zoran_set_pci_master(zr, 0);
1204         /* put chip into reset */
1205         btwrite(0, ZR36057_SPGPPCR);
1206         free_irq(zr->pci_dev->irq, zr);
1207         /* unmap and free memory */
1208         kfree(zr->stat_com);
1209         zoran_proc_cleanup(zr);
1210         iounmap(zr->zr36057_mem);
1211         pci_disable_device(zr->pci_dev);
1212         video_unregister_device(zr->video_dev);
1213 }
1214
1215 void
1216 zoran_vdev_release (struct video_device *vdev)
1217 {
1218         kfree(vdev);
1219 }
1220
1221 static struct videocodec_master * __devinit
1222 zoran_setup_videocodec (struct zoran *zr,
1223                         int           type)
1224 {
1225         struct videocodec_master *m = NULL;
1226
1227         m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1228         if (!m) {
1229                 dprintk(1,
1230                         KERN_ERR
1231                         "%s: zoran_setup_videocodec() - no memory\n",
1232                         ZR_DEVNAME(zr));
1233                 return m;
1234         }
1235
1236         m->magic = 0L; /* magic not used */
1237         m->type = VID_HARDWARE_ZR36067;
1238         m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1239         strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1240         m->data = zr;
1241
1242         switch (type)
1243         {
1244         case CODEC_TYPE_ZR36060:
1245                 m->readreg = zr36060_read;
1246                 m->writereg = zr36060_write;
1247                 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1248                 break;
1249         case CODEC_TYPE_ZR36050:
1250                 m->readreg = zr36050_read;
1251                 m->writereg = zr36050_write;
1252                 m->flags |= CODEC_FLAG_JPEG;
1253                 break;
1254         case CODEC_TYPE_ZR36016:
1255                 m->readreg = zr36016_read;
1256                 m->writereg = zr36016_write;
1257                 m->flags |= CODEC_FLAG_VFE;
1258                 break;
1259         }
1260
1261         return m;
1262 }
1263
1264 /*
1265  *   Scan for a Buz card (actually for the PCI contoler ZR36057),
1266  *   request the irq and map the io memory
1267  */
1268 static int __devinit
1269 find_zr36057 (void)
1270 {
1271         unsigned char latency, need_latency;
1272         struct zoran *zr;
1273         struct pci_dev *dev = NULL;
1274         int result;
1275         struct videocodec_master *master_vfe = NULL;
1276         struct videocodec_master *master_codec = NULL;
1277         int card_num;
1278         char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1279
1280         zoran_num = 0;
1281         while (zoran_num < BUZ_MAX &&
1282                (dev =
1283                 pci_find_device(PCI_VENDOR_ID_ZORAN,
1284                                 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                                      SA_SHIRQ | SA_INTERRUPT,
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
1546                 zoran_num++;
1547                 continue;
1548
1549                 // Init errors
1550               zr_detach_vfe:
1551                 videocodec_detach(zr->vfe);
1552               zr_free_vfe:
1553                 kfree(master_vfe);
1554               zr_detach_codec:
1555                 videocodec_detach(zr->codec);
1556               zr_free_codec:
1557                 kfree(master_codec);
1558               zr_unreg_i2c:
1559                 zoran_unregister_i2c(zr);
1560               zr_free_irq:
1561                 btwrite(0, ZR36057_SPGPPCR);
1562                 free_irq(zr->pci_dev->irq, zr);
1563               zr_unmap:
1564                 iounmap(zr->zr36057_mem);
1565                 continue;
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(5, 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) {
1625                 dprintk(1,
1626                         KERN_WARNING
1627                         "%s: chipset may 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);