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_BT866:
 359                 name = "bt866";
 360                 break;
 361         case I2C_DRIVERID_VPX3220:
 362                 name = "vpx3220";
 363                 break;
 364         case I2C_DRIVERID_KS0127:
 365                 name = "ks0127";
 366                 break;
 367         }
 368
 369         return name;
 370 }
 371
 372 static char *
 373 codecid_to_modulename (u16 codecid)
 374 {
 375         char *name = NULL;
 376
 377         switch (codecid) {
 378         case CODEC_TYPE_ZR36060:
 379                 name = "zr36060";
 380                 break;
 381         case CODEC_TYPE_ZR36050:
 382                 name = "zr36050";
 383                 break;
 384         case CODEC_TYPE_ZR36016:
 385                 name = "zr36016";
 386                 break;
 387         }
 388
 389         return name;
 390 }
 391
 392 // struct tvnorm {
 393 //      u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
 394 // };
 395
 396 static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
 397 static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
 398 static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
 399 static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
 400
 401 static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 };
 402 static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 };
 403
 404 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
 405 static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
 406 static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
 407
 408 /* FIXME: I cannot swap U and V in saa7114, so i do one
 409  * pixel left shift in zoran (75 -> 74)
 410  * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */
 411 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
 412 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
 413
 414 /* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
 415  * copy Maxim's left shift hack for the 6 Eyes.
 416  *
 417  * Christer's driver used the unshifted norms, though...
 418  * /Sam  */
 419 static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
 420 static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
 421
 422 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
 423         {
 424                 .type = DC10_old,
 425                 .name = "DC10(old)",
 426                 .i2c_decoder = I2C_DRIVERID_VPX3220,
 427                 .video_codec = CODEC_TYPE_ZR36050,
 428                 .video_vfe = CODEC_TYPE_ZR36016,
 429
 430                 .inputs = 3,
 431                 .input = {
 432                         { 1, "Composite" },
 433                         { 2, "S-Video" },
 434                         { 0, "Internal/comp" }
 435                 },
 436                 .norms = 3,
 437                 .tvn = {
 438                         &f50sqpixel_dc10,
 439                         &f60sqpixel_dc10,
 440                         &f50sqpixel_dc10
 441                 },
 442                 .jpeg_int = 0,
 443                 .vsync_int = ZR36057_ISR_GIRQ1,
 444                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
 445                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
 446                 .gpcs = { -1, 0 },
 447                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 448                 .gws_not_connected = 0,
 449                 .input_mux = 0,
 450                 .init = &dc10_init,
 451         }, {
 452                 .type = DC10_new,
 453                 .name = "DC10(new)",
 454                 .i2c_decoder = I2C_DRIVERID_SAA7110,
 455                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 456                 .video_codec = CODEC_TYPE_ZR36060,
 457
 458                 .inputs = 3,
 459                 .input = {
 460                                 { 0, "Composite" },
 461                                 { 7, "S-Video" },
 462                                 { 5, "Internal/comp" }
 463                         },
 464                 .norms = 3,
 465                 .tvn = {
 466                                 &f50sqpixel,
 467                                 &f60sqpixel,
 468                                 &f50sqpixel},
 469                 .jpeg_int = ZR36057_ISR_GIRQ0,
 470                 .vsync_int = ZR36057_ISR_GIRQ1,
 471                 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
 472                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 473                 .gpcs = { -1, 1},
 474                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
 475                 .gws_not_connected = 0,
 476                 .input_mux = 0,
 477                 .init = &dc10plus_init,
 478         }, {
 479                 .type = DC10plus,
 480                 .name = "DC10plus",
 481                 .vendor_id = PCI_VENDOR_ID_MIRO,
 482                 .device_id = PCI_DEVICE_ID_MIRO_DC10PLUS,
 483                 .i2c_decoder = I2C_DRIVERID_SAA7110,
 484                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 485                 .video_codec = CODEC_TYPE_ZR36060,
 486
 487                 .inputs = 3,
 488                 .input = {
 489                         { 0, "Composite" },
 490                         { 7, "S-Video" },
 491                         { 5, "Internal/comp" }
 492                 },
 493                 .norms = 3,
 494                 .tvn = {
 495                         &f50sqpixel,
 496                         &f60sqpixel,
 497                         &f50sqpixel
 498                 },
 499                 .jpeg_int = ZR36057_ISR_GIRQ0,
 500                 .vsync_int = ZR36057_ISR_GIRQ1,
 501                 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
 502                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 503                 .gpcs = { -1, 1 },
 504                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
 505                 .gws_not_connected = 0,
 506                 .input_mux = 0,
 507                 .init = &dc10plus_init,
 508         }, {
 509                 .type = DC30,
 510                 .name = "DC30",
 511                 .i2c_decoder = I2C_DRIVERID_VPX3220,
 512                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 513                 .video_codec = CODEC_TYPE_ZR36050,
 514                 .video_vfe = CODEC_TYPE_ZR36016,
 515
 516                 .inputs = 3,
 517                 .input = {
 518                         { 1, "Composite" },
 519                         { 2, "S-Video" },
 520                         { 0, "Internal/comp" }
 521                 },
 522                 .norms = 3,
 523                 .tvn = {
 524                         &f50sqpixel_dc10,
 525                         &f60sqpixel_dc10,
 526                         &f50sqpixel_dc10
 527                 },
 528                 .jpeg_int = 0,
 529                 .vsync_int = ZR36057_ISR_GIRQ1,
 530                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
 531                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
 532                 .gpcs = { -1, 0 },
 533                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 534                 .gws_not_connected = 0,
 535                 .input_mux = 0,
 536                 .init = &dc10_init,
 537         }, {
 538                 .type = DC30plus,
 539                 .name = "DC30plus",
 540                 .vendor_id = PCI_VENDOR_ID_MIRO,
 541                 .device_id = PCI_DEVICE_ID_MIRO_DC30PLUS,
 542                 .i2c_decoder = I2C_DRIVERID_VPX3220,
 543                 .i2c_encoder = I2C_DRIVERID_ADV7175,
 544                 .video_codec = CODEC_TYPE_ZR36050,
 545                 .video_vfe = CODEC_TYPE_ZR36016,
 546
 547                 .inputs = 3,
 548                 .input = {
 549                         { 1, "Composite" },
 550                         { 2, "S-Video" },
 551                         { 0, "Internal/comp" }
 552                 },
 553                 .norms = 3,
 554                 .tvn = {
 555                         &f50sqpixel_dc10,
 556                         &f60sqpixel_dc10,
 557                         &f50sqpixel_dc10
 558                 },
 559                 .jpeg_int = 0,
 560                 .vsync_int = ZR36057_ISR_GIRQ1,
 561                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
 562                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
 563                 .gpcs = { -1, 0 },
 564                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 565                 .gws_not_connected = 0,
 566                 .input_mux = 0,
 567                 .init = &dc10_init,
 568         }, {
 569                 .type = LML33,
 570                 .name = "LML33",
 571                 .i2c_decoder = I2C_DRIVERID_BT819,
 572                 .i2c_encoder = I2C_DRIVERID_BT856,
 573                 .video_codec = CODEC_TYPE_ZR36060,
 574
 575                 .inputs = 2,
 576                 .input = {
 577                         { 0, "Composite" },
 578                         { 7, "S-Video" }
 579                 },
 580                 .norms = 2,
 581                 .tvn = {
 582                         &f50ccir601_lml33,
 583                         &f60ccir601_lml33,
 584                         NULL
 585                 },
 586                 .jpeg_int = ZR36057_ISR_GIRQ1,
 587                 .vsync_int = ZR36057_ISR_GIRQ0,
 588                 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
 589                 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
 590                 .gpcs = { 3, 1 },
 591                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
 592                 .gws_not_connected = 1,
 593                 .input_mux = 0,
 594                 .init = &lml33_init,
 595         }, {
 596                 .type = LML33R10,
 597                 .name = "LML33R10",
 598                 .vendor_id = PCI_VENDOR_ID_ELECTRONICDESIGNGMBH,
 599                 .device_id = PCI_DEVICE_ID_LML_33R10,
 600                 .i2c_decoder = I2C_DRIVERID_SAA7114,
 601                 .i2c_encoder = I2C_DRIVERID_ADV7170,
 602                 .video_codec = CODEC_TYPE_ZR36060,
 603
 604                 .inputs = 2,
 605                 .input = {
 606                         { 0, "Composite" },
 607                         { 7, "S-Video" }
 608                 },
 609                 .norms = 2,
 610                 .tvn = {
 611                         &f50ccir601_lm33r10,
 612                         &f60ccir601_lm33r10,
 613                         NULL
 614                 },
 615                 .jpeg_int = ZR36057_ISR_GIRQ1,
 616                 .vsync_int = ZR36057_ISR_GIRQ0,
 617                 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
 618                 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
 619                 .gpcs = { 3, 1 },
 620                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
 621                 .gws_not_connected = 1,
 622                 .input_mux = 0,
 623                 .init = &lml33_init,
 624         }, {
 625                 .type = BUZ,
 626                 .name = "Buz",
 627                 .vendor_id = PCI_VENDOR_ID_IOMEGA,
 628                 .device_id = PCI_DEVICE_ID_IOMEGA_BUZ,
 629                 .i2c_decoder = I2C_DRIVERID_SAA7111A,
 630                 .i2c_encoder = I2C_DRIVERID_SAA7185B,
 631                 .video_codec = CODEC_TYPE_ZR36060,
 632
 633                 .inputs = 2,
 634                 .input = {
 635                         { 3, "Composite" },
 636                         { 7, "S-Video" }
 637                 },
 638                 .norms = 3,
 639                 .tvn = {
 640                         &f50ccir601,
 641                         &f60ccir601,
 642                         &f50ccir601
 643                 },
 644                 .jpeg_int = ZR36057_ISR_GIRQ1,
 645                 .vsync_int = ZR36057_ISR_GIRQ0,
 646                 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
 647                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
 648                 .gpcs = { 3, 1 },
 649                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
 650                 .gws_not_connected = 1,
 651                 .input_mux = 0,
 652                 .init = &buz_init,
 653         }, {
 654                 .type = AVS6EYES,
 655                 .name = "6-Eyes",
 656                 /* AverMedia chose not to brand the 6-Eyes. Thus it
 657                    can't be autodetected, and requires card=x. */
 658                 .vendor_id = -1,
 659                 .device_id = -1,
 660                 .i2c_decoder = I2C_DRIVERID_KS0127,
 661                 .i2c_encoder = I2C_DRIVERID_BT866,
 662                 .video_codec = CODEC_TYPE_ZR36060,
 663
 664                 .inputs = 10,
 665                 .input = {
 666                         { 0, "Composite 1" },
 667                         { 1, "Composite 2" },
 668                         { 2, "Composite 3" },
 669                         { 4, "Composite 4" },
 670                         { 5, "Composite 5" },
 671                         { 6, "Composite 6" },
 672                         { 8, "S-Video 1" },
 673                         { 9, "S-Video 2" },
 674                         {10, "S-Video 3" },
 675                         {15, "YCbCr" }
 676                 },
 677                 .norms = 2,
 678                 .tvn = {
 679                         &f50ccir601_avs6eyes,
 680                         &f60ccir601_avs6eyes,
 681                         NULL
 682                 },
 683                 .jpeg_int = ZR36057_ISR_GIRQ1,
 684                 .vsync_int = ZR36057_ISR_GIRQ0,
 685                 .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
 686                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
 687                 .gpcs = { 3, 1 },                       // Validity unknown /Sam
 688                 .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 },  // Validity unknown /Sam
 689                 .gws_not_connected = 1,
 690                 .input_mux = 1,
 691                 .init = &avs6eyes_init,
 692         }
 693
 694 };
 695
 696 /*
 697  * I2C functions
 698  */
 699 /* software I2C functions */
 700 static int
 701 zoran_i2c_getsda (void *data)
 702 {
 703         struct zoran *zr = (struct zoran *) data;
 704
 705         return (btread(ZR36057_I2CBR) >> 1) & 1;
 706 }
 707
 708 static int
 709 zoran_i2c_getscl (void *data)
 710 {
 711         struct zoran *zr = (struct zoran *) data;
 712
 713         return btread(ZR36057_I2CBR) & 1;
 714 }
 715
 716 static void
 717 zoran_i2c_setsda (void *data,
 718                   int   state)
 719 {
 720         struct zoran *zr = (struct zoran *) data;
 721
 722         if (state)
 723                 zr->i2cbr |= 2;
 724         else
 725                 zr->i2cbr &= ~2;
 726         btwrite(zr->i2cbr, ZR36057_I2CBR);
 727 }
 728
 729 static void
 730 zoran_i2c_setscl (void *data,
 731                   int   state)
 732 {
 733         struct zoran *zr = (struct zoran *) data;
 734
 735         if (state)
 736                 zr->i2cbr |= 1;
 737         else
 738                 zr->i2cbr &= ~1;
 739         btwrite(zr->i2cbr, ZR36057_I2CBR);
 740 }
 741
 742 static int
 743 zoran_i2c_client_register (struct i2c_client *client)
 744 {
 745         struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
 746         int res = 0;
 747
 748         dprintk(2,
 749                 KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
 750                 ZR_DEVNAME(zr), client->driver->id);
 751
 752         mutex_lock(&zr->resource_lock);
 753
 754         if (zr->user > 0) {
 755                 /* we're already busy, so we keep a reference to
 756                  * them... Could do a lot of stuff here, but this
 757                  * is easiest. (Did I ever mention I'm a lazy ass?)
 758                  */
 759                 res = -EBUSY;
 760                 goto clientreg_unlock_and_return;
 761         }
 762
 763         if (client->driver->id == zr->card.i2c_decoder)
 764                 zr->decoder = client;
 765         else if (client->driver->id == zr->card.i2c_encoder)
 766                 zr->encoder = client;
 767         else {
 768                 res = -ENODEV;
 769                 goto clientreg_unlock_and_return;
 770         }
 771
 772 clientreg_unlock_and_return:
 773         mutex_unlock(&zr->resource_lock);
 774
 775         return res;
 776 }
 777
 778 static int
 779 zoran_i2c_client_unregister (struct i2c_client *client)
 780 {
 781         struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
 782         int res = 0;
 783
 784         dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
 785
 786         mutex_lock(&zr->resource_lock);
 787
 788         if (zr->user > 0) {
 789                 res = -EBUSY;
 790                 goto clientunreg_unlock_and_return;
 791         }
 792
 793         /* try to locate it */
 794         if (client == zr->encoder) {
 795                 zr->encoder = NULL;
 796         } else if (client == zr->decoder) {
 797                 zr->decoder = NULL;
 798                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
 799         }
 800 clientunreg_unlock_and_return:
 801         mutex_unlock(&zr->resource_lock);
 802         return res;
 803 }
 804
 805 static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
 806         .setsda = zoran_i2c_setsda,
 807         .setscl = zoran_i2c_setscl,
 808         .getsda = zoran_i2c_getsda,
 809         .getscl = zoran_i2c_getscl,
 810         .udelay = 10,
 811         .timeout = 100,
 812 };
 813
 814 static int
 815 zoran_register_i2c (struct zoran *zr)
 816 {
 817         memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
 818                sizeof(struct i2c_algo_bit_data));
 819         zr->i2c_algo.data = zr;
 820         zr->i2c_adapter.id = I2C_HW_B_ZR36067;
 821         zr->i2c_adapter.client_register = zoran_i2c_client_register;
 822         zr->i2c_adapter.client_unregister = zoran_i2c_client_unregister;
 823         strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
 824                 sizeof(zr->i2c_adapter.name));
 825         i2c_set_adapdata(&zr->i2c_adapter, zr);
 826         zr->i2c_adapter.algo_data = &zr->i2c_algo;
 827         zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
 828         return i2c_bit_add_bus(&zr->i2c_adapter);
 829 }
 830
 831 static void
 832 zoran_unregister_i2c (struct zoran *zr)
 833 {
 834         i2c_del_adapter(&zr->i2c_adapter);
 835 }
 836
 837 /* Check a zoran_params struct for correctness, insert default params */
 838
 839 int
 840 zoran_check_jpg_settings (struct zoran              *zr,
 841                           struct zoran_jpg_settings *settings)
 842 {
 843         int err = 0, err0 = 0;
 844
 845         dprintk(4,
 846                 KERN_DEBUG
 847                 "%s: check_jpg_settings() - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
 848                 ZR_DEVNAME(zr), settings->decimation, settings->HorDcm,
 849                 settings->VerDcm, settings->TmpDcm);
 850         dprintk(4,
 851                 KERN_DEBUG
 852                 "%s: check_jpg_settings() - x: %d, y: %d, w: %d, y: %d\n",
 853                 ZR_DEVNAME(zr), settings->img_x, settings->img_y,
 854                 settings->img_width, settings->img_height);
 855         /* Check decimation, set default values for decimation = 1, 2, 4 */
 856         switch (settings->decimation) {
 857         case 1:
 858
 859                 settings->HorDcm = 1;
 860                 settings->VerDcm = 1;
 861                 settings->TmpDcm = 1;
 862                 settings->field_per_buff = 2;
 863                 settings->img_x = 0;
 864                 settings->img_y = 0;
 865                 settings->img_width = BUZ_MAX_WIDTH;
 866                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 867                 break;
 868         case 2:
 869
 870                 settings->HorDcm = 2;
 871                 settings->VerDcm = 1;
 872                 settings->TmpDcm = 2;
 873                 settings->field_per_buff = 1;
 874                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 875                 settings->img_y = 0;
 876                 settings->img_width =
 877                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 878                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 879                 break;
 880         case 4:
 881
 882                 if (zr->card.type == DC10_new) {
 883                         dprintk(1,
 884                                 KERN_DEBUG
 885                                 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
 886                                 ZR_DEVNAME(zr));
 887                         err0++;
 888                         break;
 889                 }
 890
 891                 settings->HorDcm = 4;
 892                 settings->VerDcm = 2;
 893                 settings->TmpDcm = 2;
 894                 settings->field_per_buff = 1;
 895                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 896                 settings->img_y = 0;
 897                 settings->img_width =
 898                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 899                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 900                 break;
 901         case 0:
 902
 903                 /* We have to check the data the user has set */
 904
 905                 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
 906                     (zr->card.type == DC10_new || settings->HorDcm != 4))
 907                         err0++;
 908                 if (settings->VerDcm != 1 && settings->VerDcm != 2)
 909                         err0++;
 910                 if (settings->TmpDcm != 1 && settings->TmpDcm != 2)
 911                         err0++;
 912                 if (settings->field_per_buff != 1 &&
 913                     settings->field_per_buff != 2)
 914                         err0++;
 915                 if (settings->img_x < 0)
 916                         err0++;
 917                 if (settings->img_y < 0)
 918                         err0++;
 919                 if (settings->img_width < 0)
 920                         err0++;
 921                 if (settings->img_height < 0)
 922                         err0++;
 923                 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH)
 924                         err0++;
 925                 if (settings->img_y + settings->img_height >
 926                     BUZ_MAX_HEIGHT / 2)
 927                         err0++;
 928                 if (settings->HorDcm && settings->VerDcm) {
 929                         if (settings->img_width %
 930                             (16 * settings->HorDcm) != 0)
 931                                 err0++;
 932                         if (settings->img_height %
 933                             (8 * settings->VerDcm) != 0)
 934                                 err0++;
 935                 }
 936
 937                 if (err0) {
 938                         dprintk(1,
 939                                 KERN_ERR
 940                                 "%s: check_jpg_settings() - error in params for decimation = 0\n",
 941                                 ZR_DEVNAME(zr));
 942                         err++;
 943                 }
 944                 break;
 945         default:
 946                 dprintk(1,
 947                         KERN_ERR
 948                         "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
 949                         ZR_DEVNAME(zr), settings->decimation);
 950                 err++;
 951                 break;
 952         }
 953
 954         if (settings->jpg_comp.quality > 100)
 955                 settings->jpg_comp.quality = 100;
 956         if (settings->jpg_comp.quality < 5)
 957                 settings->jpg_comp.quality = 5;
 958         if (settings->jpg_comp.APPn < 0)
 959                 settings->jpg_comp.APPn = 0;
 960         if (settings->jpg_comp.APPn > 15)
 961                 settings->jpg_comp.APPn = 15;
 962         if (settings->jpg_comp.APP_len < 0)
 963                 settings->jpg_comp.APP_len = 0;
 964         if (settings->jpg_comp.APP_len > 60)
 965                 settings->jpg_comp.APP_len = 60;
 966         if (settings->jpg_comp.COM_len < 0)
 967                 settings->jpg_comp.COM_len = 0;
 968         if (settings->jpg_comp.COM_len > 60)
 969                 settings->jpg_comp.COM_len = 60;
 970         if (err)
 971                 return -EINVAL;
 972         return 0;
 973 }
 974
 975 void
 976 zoran_open_init_params (struct zoran *zr)
 977 {
 978         int i;
 979
 980         /* User must explicitly set a window */
 981         zr->overlay_settings.is_set = 0;
 982         zr->overlay_mask = NULL;
 983         zr->overlay_active = ZORAN_FREE;
 984
 985         zr->v4l_memgrab_active = 0;
 986         zr->v4l_overlay_active = 0;
 987         zr->v4l_grab_frame = NO_GRAB_ACTIVE;
 988         zr->v4l_grab_seq = 0;
 989         zr->v4l_settings.width = 192;
 990         zr->v4l_settings.height = 144;
 991         zr->v4l_settings.format = &zoran_formats[7];    /* YUY2 - YUV-4:2:2 packed */
 992         zr->v4l_settings.bytesperline =
 993             zr->v4l_settings.width *
 994             ((zr->v4l_settings.format->depth + 7) / 8);
 995
 996         /* DMA ring stuff for V4L */
 997         zr->v4l_pend_tail = 0;
 998         zr->v4l_pend_head = 0;
 999         zr->v4l_sync_tail = 0;
1000         zr->v4l_buffers.active = ZORAN_FREE;
1001         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1002                 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
1003         }
1004         zr->v4l_buffers.allocated = 0;
1005
1006         for (i = 0; i < BUZ_MAX_FRAME; i++) {
1007                 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
1008         }
1009         zr->jpg_buffers.active = ZORAN_FREE;
1010         zr->jpg_buffers.allocated = 0;
1011         /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
1012         zr->jpg_settings.decimation = 1;
1013         zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
1014         if (zr->card.type != BUZ)
1015                 zr->jpg_settings.odd_even = 1;
1016         else
1017                 zr->jpg_settings.odd_even = 0;
1018         zr->jpg_settings.jpg_comp.APPn = 0;
1019         zr->jpg_settings.jpg_comp.APP_len = 0;  /* No APPn marker */
1020         memset(zr->jpg_settings.jpg_comp.APP_data, 0,
1021                sizeof(zr->jpg_settings.jpg_comp.APP_data));
1022         zr->jpg_settings.jpg_comp.COM_len = 0;  /* No COM marker */
1023         memset(zr->jpg_settings.jpg_comp.COM_data, 0,
1024                sizeof(zr->jpg_settings.jpg_comp.COM_data));
1025         zr->jpg_settings.jpg_comp.jpeg_markers =
1026             JPEG_MARKER_DHT | JPEG_MARKER_DQT;
1027         i = zoran_check_jpg_settings(zr, &zr->jpg_settings);
1028         if (i)
1029                 dprintk(1,
1030                         KERN_ERR
1031                         "%s: zoran_open_init_params() internal error\n",
1032                         ZR_DEVNAME(zr));
1033
1034         clear_interrupt_counters(zr);
1035         zr->testing = 0;
1036 }
1037
1038 static void __devinit
1039 test_interrupts (struct zoran *zr)
1040 {
1041         DEFINE_WAIT(wait);
1042         int timeout, icr;
1043
1044         clear_interrupt_counters(zr);
1045
1046         zr->testing = 1;
1047         icr = btread(ZR36057_ICR);
1048         btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
1049         prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
1050         timeout = schedule_timeout(HZ);
1051         finish_wait(&zr->test_q, &wait);
1052         btwrite(0, ZR36057_ICR);
1053         btwrite(0x78000000, ZR36057_ISR);
1054         zr->testing = 0;
1055         dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
1056         if (timeout) {
1057                 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
1058         }
1059         if (zr36067_debug > 1)
1060                 print_interrupts(zr);
1061         btwrite(icr, ZR36057_ICR);
1062 }
1063
1064 static int __devinit
1065 zr36057_init (struct zoran *zr)
1066 {
1067         int j, err;
1068         int two = 2;
1069         int zero = 0;
1070
1071         dprintk(1,
1072                 KERN_INFO
1073                 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1074                 ZR_DEVNAME(zr), zr->id, zr);
1075
1076         /* default setup of all parameters which will persist between opens */
1077         zr->user = 0;
1078
1079         init_waitqueue_head(&zr->v4l_capq);
1080         init_waitqueue_head(&zr->jpg_capq);
1081         init_waitqueue_head(&zr->test_q);
1082         zr->jpg_buffers.allocated = 0;
1083         zr->v4l_buffers.allocated = 0;
1084
1085         zr->buffer.base = (void *) vidmem;
1086         zr->buffer.width = 0;
1087         zr->buffer.height = 0;
1088         zr->buffer.depth = 0;
1089         zr->buffer.bytesperline = 0;
1090
1091         /* Avoid nonsense settings from user for default input/norm */
1092         if (default_norm < VIDEO_MODE_PAL &&
1093             default_norm > VIDEO_MODE_SECAM)
1094                 default_norm = VIDEO_MODE_PAL;
1095         zr->norm = default_norm;
1096         if (!(zr->timing = zr->card.tvn[zr->norm])) {
1097                 dprintk(1,
1098                         KERN_WARNING
1099                         "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1100                         ZR_DEVNAME(zr));
1101                 zr->norm = VIDEO_MODE_PAL;
1102                 zr->timing = zr->card.tvn[zr->norm];
1103         }
1104
1105         if (default_input > zr->card.inputs-1) {
1106                 dprintk(1,
1107                         KERN_WARNING
1108                         "%s: default_input value %d out of range (0-%d)\n",
1109                         ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1110                 default_input = 0;
1111         }
1112         zr->input = default_input;
1113
1114         /* Should the following be reset at every open ? */
1115         zr->hue = 32768;
1116         zr->contrast = 32768;
1117         zr->saturation = 32768;
1118         zr->brightness = 32768;
1119
1120         /* default setup (will be repeated at every open) */
1121         zoran_open_init_params(zr);
1122
1123         /* allocate memory *before* doing anything to the hardware
1124          * in case allocation fails */
1125         zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1126         zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1127         if (!zr->stat_com || !zr->video_dev) {
1128                 dprintk(1,
1129                         KERN_ERR
1130                         "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1131                         ZR_DEVNAME(zr));
1132                 err = -ENOMEM;
1133                 goto exit_free;
1134         }
1135         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1136                 zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1137         }
1138
1139         /*
1140          *   Now add the template and register the device unit.
1141          */
1142         memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1143         strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1144         err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
1145         if (err < 0)
1146                 goto exit_unregister;
1147
1148         zoran_init_hardware(zr);
1149         if (zr36067_debug > 2)
1150                 detect_guest_activity(zr);
1151         test_interrupts(zr);
1152         if (!pass_through) {
1153                 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1154                 encoder_command(zr, ENCODER_SET_INPUT, &two);
1155         }
1156
1157         zr->zoran_proc = NULL;
1158         zr->initialized = 1;
1159         return 0;
1160
1161 exit_unregister:
1162         zoran_unregister_i2c(zr);
1163 exit_free:
1164         kfree(zr->stat_com);
1165         kfree(zr->video_dev);
1166         return err;
1167 }
1168
1169 static void
1170 zoran_release (struct zoran *zr)
1171 {
1172         if (!zr->initialized)
1173                 goto exit_free;
1174         /* unregister videocodec bus */
1175         if (zr->codec) {
1176                 struct videocodec_master *master = zr->codec->master_data;
1177
1178                 videocodec_detach(zr->codec);
1179                 kfree(master);
1180         }
1181         if (zr->vfe) {
1182                 struct videocodec_master *master = zr->vfe->master_data;
1183
1184                 videocodec_detach(zr->vfe);
1185                 kfree(master);
1186         }
1187
1188         /* unregister i2c bus */
1189         zoran_unregister_i2c(zr);
1190         /* disable PCI bus-mastering */
1191         zoran_set_pci_master(zr, 0);
1192         /* put chip into reset */
1193         btwrite(0, ZR36057_SPGPPCR);
1194         free_irq(zr->pci_dev->irq, zr);
1195         /* unmap and free memory */
1196         kfree(zr->stat_com);
1197         zoran_proc_cleanup(zr);
1198         iounmap(zr->zr36057_mem);
1199         pci_disable_device(zr->pci_dev);
1200         video_unregister_device(zr->video_dev);
1201 exit_free:
1202         kfree(zr);
1203 }
1204
1205 void
1206 zoran_vdev_release (struct video_device *vdev)
1207 {
1208         kfree(vdev);
1209 }
1210
1211 static struct videocodec_master * __devinit
1212 zoran_setup_videocodec (struct zoran *zr,
1213                         int           type)
1214 {
1215         struct videocodec_master *m = NULL;
1216
1217         m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1218         if (!m) {
1219                 dprintk(1,
1220                         KERN_ERR
1221                         "%s: zoran_setup_videocodec() - no memory\n",
1222                         ZR_DEVNAME(zr));
1223                 return m;
1224         }
1225
1226         /* magic and type are unused for master struct. Makes sense only at
1227            codec structs.
1228            In the past, .type were initialized to the old V4L1 .hardware
1229            value, as VID_HARDWARE_ZR36067
1230          */
1231         m->magic = 0L;
1232         m->type = 0;
1233
1234         m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1235         strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1236         m->data = zr;
1237
1238         switch (type)
1239         {
1240         case CODEC_TYPE_ZR36060:
1241                 m->readreg = zr36060_read;
1242                 m->writereg = zr36060_write;
1243                 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1244                 break;
1245         case CODEC_TYPE_ZR36050:
1246                 m->readreg = zr36050_read;
1247                 m->writereg = zr36050_write;
1248                 m->flags |= CODEC_FLAG_JPEG;
1249                 break;
1250         case CODEC_TYPE_ZR36016:
1251                 m->readreg = zr36016_read;
1252                 m->writereg = zr36016_write;
1253                 m->flags |= CODEC_FLAG_VFE;
1254                 break;
1255         }
1256
1257         return m;
1258 }
1259
1260 /*
1261  *   Scan for a Buz card (actually for the PCI controller ZR36057),
1262  *   request the irq and map the io memory
1263  */
1264 static int __devinit
1265 find_zr36057 (void)
1266 {
1267         unsigned char latency, need_latency;
1268         struct zoran *zr;
1269         struct pci_dev *dev = NULL;
1270         int result;
1271         struct videocodec_master *master_vfe = NULL;
1272         struct videocodec_master *master_codec = NULL;
1273         int card_num;
1274         char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1275
1276         zoran_num = 0;
1277         while (zoran_num < BUZ_MAX &&
1278                (dev = pci_get_device(PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1279                 card_num = card[zoran_num];
1280                 zr = kzalloc(sizeof(struct zoran), GFP_KERNEL);
1281                 if (!zr) {
1282                         dprintk(1,
1283                                 KERN_ERR
1284                                 "%s: find_zr36057() - kzalloc failed\n",
1285                                 ZORAN_NAME);
1286                         continue;
1287                 }
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                         goto zr_free_mem;
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                                 goto zr_free_mem;
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                                         goto zr_free_mem;
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                         goto zr_free_mem;
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                         goto zr_free_mem;
1379                 }
1380
1381                 result = request_irq(zr->pci_dev->irq,
1382                                      zoran_irq,
1383                                      IRQF_SHARED | IRQF_DISABLED,
1384                                      ZR_DEVNAME(zr),
1385                                      (void *) zr);
1386                 if (result < 0) {
1387                         if (result == -EINVAL) {
1388                                 dprintk(1,
1389                                         KERN_ERR
1390                                         "%s: find_zr36057() - bad irq number or handler\n",
1391                                         ZR_DEVNAME(zr));
1392                         } else if (result == -EBUSY) {
1393                                 dprintk(1,
1394                                         KERN_ERR
1395                                         "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1396                                         ZR_DEVNAME(zr), zr->pci_dev->irq);
1397                         } else {
1398                                 dprintk(1,
1399                                         KERN_ERR
1400                                         "%s: find_zr36057() - can't assign irq, error code %d\n",
1401                                         ZR_DEVNAME(zr), result);
1402                         }
1403                         goto zr_unmap;
1404                 }
1405
1406                 /* set PCI latency timer */
1407                 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1408                                      &latency);
1409                 need_latency = zr->revision > 1 ? 32 : 48;
1410                 if (latency != need_latency) {
1411                         dprintk(2,
1412                                 KERN_INFO
1413                                 "%s: Changing PCI latency from %d to %d.\n",
1414                                 ZR_DEVNAME(zr), latency, need_latency);
1415                         pci_write_config_byte(zr->pci_dev,
1416                                               PCI_LATENCY_TIMER,
1417                                               need_latency);
1418                 }
1419
1420                 zr36057_restart(zr);
1421                 /* i2c */
1422                 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1423                         ZR_DEVNAME(zr));
1424
1425                 /* i2c decoder */
1426                 if (decoder[zr->id] != -1) {
1427                         i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1428                         zr->card.i2c_decoder = decoder[zr->id];
1429                 } else if (zr->card.i2c_decoder != 0) {
1430                         i2c_dec_name =
1431                                 i2cid_to_modulename(zr->card.i2c_decoder);
1432                 } else {
1433                         i2c_dec_name = NULL;
1434                 }
1435
1436                 if (i2c_dec_name) {
1437                         if ((result = request_module(i2c_dec_name)) < 0) {
1438                                 dprintk(1,
1439                                         KERN_ERR
1440                                         "%s: failed to load module %s: %d\n",
1441                                         ZR_DEVNAME(zr), i2c_dec_name, result);
1442                         }
1443                 }
1444
1445                 /* i2c encoder */
1446                 if (encoder[zr->id] != -1) {
1447                         i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1448                         zr->card.i2c_encoder = encoder[zr->id];
1449                 } else if (zr->card.i2c_encoder != 0) {
1450                         i2c_enc_name =
1451                                 i2cid_to_modulename(zr->card.i2c_encoder);
1452                 } else {
1453                         i2c_enc_name = NULL;
1454                 }
1455
1456                 if (i2c_enc_name) {
1457                         if ((result = request_module(i2c_enc_name)) < 0) {
1458                                 dprintk(1,
1459                                         KERN_ERR
1460                                         "%s: failed to load module %s: %d\n",
1461                                         ZR_DEVNAME(zr), i2c_enc_name, result);
1462                         }
1463                 }
1464
1465                 if (zoran_register_i2c(zr) < 0) {
1466                         dprintk(1,
1467                                 KERN_ERR
1468                                 "%s: find_zr36057() - can't initialize i2c bus\n",
1469                                 ZR_DEVNAME(zr));
1470                         goto zr_free_irq;
1471                 }
1472
1473                 dprintk(2,
1474                         KERN_INFO "%s: Initializing videocodec bus...\n",
1475                         ZR_DEVNAME(zr));
1476
1477                 if (zr->card.video_codec != 0 &&
1478                     (codec_name =
1479                      codecid_to_modulename(zr->card.video_codec)) != NULL) {
1480                         if ((result = request_module(codec_name)) < 0) {
1481                                 dprintk(1,
1482                                         KERN_ERR
1483                                         "%s: failed to load modules %s: %d\n",
1484                                         ZR_DEVNAME(zr), codec_name, result);
1485                         }
1486                 }
1487                 if (zr->card.video_vfe != 0 &&
1488                     (vfe_name =
1489                      codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1490                         if ((result = request_module(vfe_name)) < 0) {
1491                                 dprintk(1,
1492                                         KERN_ERR
1493                                         "%s: failed to load modules %s: %d\n",
1494                                         ZR_DEVNAME(zr), vfe_name, result);
1495                         }
1496                 }
1497
1498                 /* reset JPEG codec */
1499                 jpeg_codec_sleep(zr, 1);
1500                 jpeg_codec_reset(zr);
1501                 /* video bus enabled */
1502                 /* display codec revision */
1503                 if (zr->card.video_codec != 0) {
1504                         master_codec = zoran_setup_videocodec(zr,
1505                                                               zr->card.video_codec);
1506                         if (!master_codec)
1507                                 goto zr_unreg_i2c;
1508                         zr->codec = videocodec_attach(master_codec);
1509                         if (!zr->codec) {
1510                                 dprintk(1,
1511                                         KERN_ERR
1512                                         "%s: find_zr36057() - no codec found\n",
1513                                         ZR_DEVNAME(zr));
1514                                 goto zr_free_codec;
1515                         }
1516                         if (zr->codec->type != zr->card.video_codec) {
1517                                 dprintk(1,
1518                                         KERN_ERR
1519                                         "%s: find_zr36057() - wrong codec\n",
1520                                         ZR_DEVNAME(zr));
1521                                 goto zr_detach_codec;
1522                         }
1523                 }
1524                 if (zr->card.video_vfe != 0) {
1525                         master_vfe = zoran_setup_videocodec(zr,
1526                                                             zr->card.video_vfe);
1527                         if (!master_vfe)
1528                                 goto zr_detach_codec;
1529                         zr->vfe = videocodec_attach(master_vfe);
1530                         if (!zr->vfe) {
1531                                 dprintk(1,
1532                                         KERN_ERR
1533                                         "%s: find_zr36057() - no VFE found\n",
1534                                         ZR_DEVNAME(zr));
1535                                 goto zr_free_vfe;
1536                         }
1537                         if (zr->vfe->type != zr->card.video_vfe) {
1538                                 dprintk(1,
1539                                         KERN_ERR
1540                                         "%s: find_zr36057() = wrong VFE\n",
1541                                         ZR_DEVNAME(zr));
1542                                 goto zr_detach_vfe;
1543                         }
1544                 }
1545                 /* Success so keep the pci_dev referenced */
1546                 pci_dev_get(zr->pci_dev);
1547                 zoran[zoran_num++] = zr;
1548                 continue;
1549
1550                 // Init errors
1551               zr_detach_vfe:
1552                 videocodec_detach(zr->vfe);
1553               zr_free_vfe:
1554                 kfree(master_vfe);
1555               zr_detach_codec:
1556                 videocodec_detach(zr->codec);
1557               zr_free_codec:
1558                 kfree(master_codec);
1559               zr_unreg_i2c:
1560                 zoran_unregister_i2c(zr);
1561               zr_free_irq:
1562                 btwrite(0, ZR36057_SPGPPCR);
1563                 free_irq(zr->pci_dev->irq, zr);
1564               zr_unmap:
1565                 iounmap(zr->zr36057_mem);
1566               zr_free_mem:
1567                 kfree(zr);
1568                 continue;
1569         }
1570         if (dev)        /* Clean up ref count on early exit */
1571                 pci_dev_put(dev);
1572
1573         if (zoran_num == 0) {
1574                 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1575         }
1576         return zoran_num;
1577 }
1578
1579 static int __init
1580 init_dc10_cards (void)
1581 {
1582         int i;
1583
1584         memset(zoran, 0, sizeof(zoran));
1585         printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1586                MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1587
1588         /* Look for cards */
1589         if (find_zr36057() < 0) {
1590                 return -EIO;
1591         }
1592         if (zoran_num == 0)
1593                 return -ENODEV;
1594         dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1595                 zoran_num);
1596         /* check the parameters we have been given, adjust if necessary */
1597         if (v4l_nbufs < 2)
1598                 v4l_nbufs = 2;
1599         if (v4l_nbufs > VIDEO_MAX_FRAME)
1600                 v4l_nbufs = VIDEO_MAX_FRAME;
1601         /* The user specfies the in KB, we want them in byte
1602          * (and page aligned) */
1603         v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1604         if (v4l_bufsize < 32768)
1605                 v4l_bufsize = 32768;
1606         /* 2 MB is arbitrary but sufficient for the maximum possible images */
1607         if (v4l_bufsize > 2048 * 1024)
1608                 v4l_bufsize = 2048 * 1024;
1609         if (jpg_nbufs < 4)
1610                 jpg_nbufs = 4;
1611         if (jpg_nbufs > BUZ_MAX_FRAME)
1612                 jpg_nbufs = BUZ_MAX_FRAME;
1613         jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1614         if (jpg_bufsize < 8192)
1615                 jpg_bufsize = 8192;
1616         if (jpg_bufsize > (512 * 1024))
1617                 jpg_bufsize = 512 * 1024;
1618         /* Use parameter for vidmem or try to find a video card */
1619         if (vidmem) {
1620                 dprintk(1,
1621                         KERN_INFO
1622                         "%s: Using supplied video memory base address @ 0x%lx\n",
1623                         ZORAN_NAME, vidmem);
1624         }
1625
1626         /* random nonsense */
1627         dprintk(6, KERN_DEBUG "Jotti is een held!\n");
1628
1629         /* some mainboards might not do PCI-PCI data transfer well */
1630         if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1631                 dprintk(1,
1632                         KERN_WARNING
1633                         "%s: chipset does not support reliable PCI-PCI DMA\n",
1634                         ZORAN_NAME);
1635         }
1636
1637         /* take care of Natoma chipset and a revision 1 zr36057 */
1638         for (i = 0; i < zoran_num; i++) {
1639                 struct zoran *zr = zoran[i];
1640
1641                 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1642                         zr->jpg_buffers.need_contiguous = 1;
1643                         dprintk(1,
1644                                 KERN_INFO
1645                                 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1646                                 ZR_DEVNAME(zr));
1647                 }
1648
1649                 if (zr36057_init(zr) < 0) {
1650                         for (i = 0; i < zoran_num; i++)
1651                                 zoran_release(zoran[i]);
1652                         return -EIO;
1653                 }
1654                 zoran_proc_init(zr);
1655         }
1656
1657         return 0;
1658 }
1659
1660 static void __exit
1661 unload_dc10_cards (void)
1662 {
1663         int i;
1664
1665         for (i = 0; i < zoran_num; i++)
1666                 zoran_release(zoran[i]);
1667 }
1668
1669 module_init(init_dc10_cards);
1670 module_exit(unload_dc10_cards);