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         .timeout = 100,
 824 };
 825
 826 static struct i2c_adapter zoran_i2c_adapter_template = {
 827         .name = "zr36057",
 828         .id = I2C_HW_B_ZR36067,
 829         .algo = NULL,
 830         .client_register = zoran_i2c_client_register,
 831         .client_unregister = zoran_i2c_client_unregister,
 832 };
 833
 834 static int
 835 zoran_register_i2c (struct zoran *zr)
 836 {
 837         memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
 838                sizeof(struct i2c_algo_bit_data));
 839         zr->i2c_algo.data = zr;
 840         memcpy(&zr->i2c_adapter, &zoran_i2c_adapter_template,
 841                sizeof(struct i2c_adapter));
 842         strncpy(I2C_NAME(&zr->i2c_adapter), ZR_DEVNAME(zr),
 843                 sizeof(I2C_NAME(&zr->i2c_adapter)) - 1);
 844         i2c_set_adapdata(&zr->i2c_adapter, zr);
 845         zr->i2c_adapter.algo_data = &zr->i2c_algo;
 846         return i2c_bit_add_bus(&zr->i2c_adapter);
 847 }
 848
 849 static void
 850 zoran_unregister_i2c (struct zoran *zr)
 851 {
 852         i2c_del_adapter(&zr->i2c_adapter);
 853 }
 854
 855 /* Check a zoran_params struct for correctness, insert default params */
 856
 857 int
 858 zoran_check_jpg_settings (struct zoran              *zr,
 859                           struct zoran_jpg_settings *settings)
 860 {
 861         int err = 0, err0 = 0;
 862
 863         dprintk(4,
 864                 KERN_DEBUG
 865                 "%s: check_jpg_settings() - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
 866                 ZR_DEVNAME(zr), settings->decimation, settings->HorDcm,
 867                 settings->VerDcm, settings->TmpDcm);
 868         dprintk(4,
 869                 KERN_DEBUG
 870                 "%s: check_jpg_settings() - x: %d, y: %d, w: %d, y: %d\n",
 871                 ZR_DEVNAME(zr), settings->img_x, settings->img_y,
 872                 settings->img_width, settings->img_height);
 873         /* Check decimation, set default values for decimation = 1, 2, 4 */
 874         switch (settings->decimation) {
 875         case 1:
 876
 877                 settings->HorDcm = 1;
 878                 settings->VerDcm = 1;
 879                 settings->TmpDcm = 1;
 880                 settings->field_per_buff = 2;
 881                 settings->img_x = 0;
 882                 settings->img_y = 0;
 883                 settings->img_width = BUZ_MAX_WIDTH;
 884                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 885                 break;
 886         case 2:
 887
 888                 settings->HorDcm = 2;
 889                 settings->VerDcm = 1;
 890                 settings->TmpDcm = 2;
 891                 settings->field_per_buff = 1;
 892                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 893                 settings->img_y = 0;
 894                 settings->img_width =
 895                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 896                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 897                 break;
 898         case 4:
 899
 900                 if (zr->card.type == DC10_new) {
 901                         dprintk(1,
 902                                 KERN_DEBUG
 903                                 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
 904                                 ZR_DEVNAME(zr));
 905                         err0++;
 906                         break;
 907                 }
 908
 909                 settings->HorDcm = 4;
 910                 settings->VerDcm = 2;
 911                 settings->TmpDcm = 2;
 912                 settings->field_per_buff = 1;
 913                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 914                 settings->img_y = 0;
 915                 settings->img_width =
 916                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 917                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 918                 break;
 919         case 0:
 920
 921                 /* We have to check the data the user has set */
 922
 923                 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
 924                     (zr->card.type == DC10_new || settings->HorDcm != 4))
 925                         err0++;
 926                 if (settings->VerDcm != 1 && settings->VerDcm != 2)
 927                         err0++;
 928                 if (settings->TmpDcm != 1 && settings->TmpDcm != 2)
 929                         err0++;
 930                 if (settings->field_per_buff != 1 &&
 931                     settings->field_per_buff != 2)
 932                         err0++;
 933                 if (settings->img_x < 0)
 934                         err0++;
 935                 if (settings->img_y < 0)
 936                         err0++;
 937                 if (settings->img_width < 0)
 938                         err0++;
 939                 if (settings->img_height < 0)
 940                         err0++;
 941                 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH)
 942                         err0++;
 943                 if (settings->img_y + settings->img_height >
 944                     BUZ_MAX_HEIGHT / 2)
 945                         err0++;
 946                 if (settings->HorDcm && settings->VerDcm) {
 947                         if (settings->img_width %
 948                             (16 * settings->HorDcm) != 0)
 949                                 err0++;
 950                         if (settings->img_height %
 951                             (8 * settings->VerDcm) != 0)
 952                                 err0++;
 953                 }
 954
 955                 if (err0) {
 956                         dprintk(1,
 957                                 KERN_ERR
 958                                 "%s: check_jpg_settings() - error in params for decimation = 0\n",
 959                                 ZR_DEVNAME(zr));
 960                         err++;
 961                 }
 962                 break;
 963         default:
 964                 dprintk(1,
 965                         KERN_ERR
 966                         "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
 967                         ZR_DEVNAME(zr), settings->decimation);
 968                 err++;
 969                 break;
 970         }
 971
 972         if (settings->jpg_comp.quality > 100)
 973                 settings->jpg_comp.quality = 100;
 974         if (settings->jpg_comp.quality < 5)
 975                 settings->jpg_comp.quality = 5;
 976         if (settings->jpg_comp.APPn < 0)
 977                 settings->jpg_comp.APPn = 0;
 978         if (settings->jpg_comp.APPn > 15)
 979                 settings->jpg_comp.APPn = 15;
 980         if (settings->jpg_comp.APP_len < 0)
 981                 settings->jpg_comp.APP_len = 0;
 982         if (settings->jpg_comp.APP_len > 60)
 983                 settings->jpg_comp.APP_len = 60;
 984         if (settings->jpg_comp.COM_len < 0)
 985                 settings->jpg_comp.COM_len = 0;
 986         if (settings->jpg_comp.COM_len > 60)
 987                 settings->jpg_comp.COM_len = 60;
 988         if (err)
 989                 return -EINVAL;
 990         return 0;
 991 }
 992
 993 void
 994 zoran_open_init_params (struct zoran *zr)
 995 {
 996         int i;
 997
 998         /* User must explicitly set a window */
 999         zr->overlay_settings.is_set = 0;
1000         zr->overlay_mask = NULL;
1001         zr->overlay_active = ZORAN_FREE;
1002
1003         zr->v4l_memgrab_active = 0;
1004         zr->v4l_overlay_active = 0;
1005         zr->v4l_grab_frame = NO_GRAB_ACTIVE;
1006         zr->v4l_grab_seq = 0;
1007         zr->v4l_settings.width = 192;
1008         zr->v4l_settings.height = 144;
1009         zr->v4l_settings.format = &zoran_formats[4];    /* YUY2 - YUV-4:2:2 packed */
1010         zr->v4l_settings.bytesperline =
1011             zr->v4l_settings.width *
1012             ((zr->v4l_settings.format->depth + 7) / 8);
1013
1014         /* DMA ring stuff for V4L */
1015         zr->v4l_pend_tail = 0;
1016         zr->v4l_pend_head = 0;
1017         zr->v4l_sync_tail = 0;
1018         zr->v4l_buffers.active = ZORAN_FREE;
1019         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1020                 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
1021         }
1022         zr->v4l_buffers.allocated = 0;
1023
1024         for (i = 0; i < BUZ_MAX_FRAME; i++) {
1025                 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
1026         }
1027         zr->jpg_buffers.active = ZORAN_FREE;
1028         zr->jpg_buffers.allocated = 0;
1029         /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
1030         zr->jpg_settings.decimation = 1;
1031         zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
1032         if (zr->card.type != BUZ)
1033                 zr->jpg_settings.odd_even = 1;
1034         else
1035                 zr->jpg_settings.odd_even = 0;
1036         zr->jpg_settings.jpg_comp.APPn = 0;
1037         zr->jpg_settings.jpg_comp.APP_len = 0;  /* No APPn marker */
1038         memset(zr->jpg_settings.jpg_comp.APP_data, 0,
1039                sizeof(zr->jpg_settings.jpg_comp.APP_data));
1040         zr->jpg_settings.jpg_comp.COM_len = 0;  /* No COM marker */
1041         memset(zr->jpg_settings.jpg_comp.COM_data, 0,
1042                sizeof(zr->jpg_settings.jpg_comp.COM_data));
1043         zr->jpg_settings.jpg_comp.jpeg_markers =
1044             JPEG_MARKER_DHT | JPEG_MARKER_DQT;
1045         i = zoran_check_jpg_settings(zr, &zr->jpg_settings);
1046         if (i)
1047                 dprintk(1,
1048                         KERN_ERR
1049                         "%s: zoran_open_init_params() internal error\n",
1050                         ZR_DEVNAME(zr));
1051
1052         clear_interrupt_counters(zr);
1053         zr->testing = 0;
1054 }
1055
1056 static void __devinit
1057 test_interrupts (struct zoran *zr)
1058 {
1059         DEFINE_WAIT(wait);
1060         int timeout, icr;
1061
1062         clear_interrupt_counters(zr);
1063
1064         zr->testing = 1;
1065         icr = btread(ZR36057_ICR);
1066         btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
1067         prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
1068         timeout = schedule_timeout(HZ);
1069         finish_wait(&zr->test_q, &wait);
1070         btwrite(0, ZR36057_ICR);
1071         btwrite(0x78000000, ZR36057_ISR);
1072         zr->testing = 0;
1073         dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
1074         if (timeout) {
1075                 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
1076         }
1077         if (*zr_debug > 1)
1078                 print_interrupts(zr);
1079         btwrite(icr, ZR36057_ICR);
1080 }
1081
1082 static int __devinit
1083 zr36057_init (struct zoran *zr)
1084 {
1085         int j, err;
1086         int two = 2;
1087         int zero = 0;
1088
1089         dprintk(1,
1090                 KERN_INFO
1091                 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1092                 ZR_DEVNAME(zr), zr->id, zr);
1093
1094         /* default setup of all parameters which will persist between opens */
1095         zr->user = 0;
1096
1097         init_waitqueue_head(&zr->v4l_capq);
1098         init_waitqueue_head(&zr->jpg_capq);
1099         init_waitqueue_head(&zr->test_q);
1100         zr->jpg_buffers.allocated = 0;
1101         zr->v4l_buffers.allocated = 0;
1102
1103         zr->buffer.base = (void *) vidmem;
1104         zr->buffer.width = 0;
1105         zr->buffer.height = 0;
1106         zr->buffer.depth = 0;
1107         zr->buffer.bytesperline = 0;
1108
1109         /* Avoid nonsense settings from user for default input/norm */
1110         if (default_norm < VIDEO_MODE_PAL &&
1111             default_norm > VIDEO_MODE_SECAM)
1112                 default_norm = VIDEO_MODE_PAL;
1113         zr->norm = default_norm;
1114         if (!(zr->timing = zr->card.tvn[zr->norm])) {
1115                 dprintk(1,
1116                         KERN_WARNING
1117                         "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1118                         ZR_DEVNAME(zr));
1119                 zr->norm = VIDEO_MODE_PAL;
1120                 zr->timing = zr->card.tvn[zr->norm];
1121         }
1122
1123         zr->input = default_input = (default_input ? 1 : 0);
1124
1125         /* Should the following be reset at every open ? */
1126         zr->hue = 32768;
1127         zr->contrast = 32768;
1128         zr->saturation = 32768;
1129         zr->brightness = 32768;
1130
1131         /* default setup (will be repeated at every open) */
1132         zoran_open_init_params(zr);
1133
1134         /* allocate memory *before* doing anything to the hardware
1135          * in case allocation fails */
1136         zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1137         zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1138         if (!zr->stat_com || !zr->video_dev) {
1139                 dprintk(1,
1140                         KERN_ERR
1141                         "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1142                         ZR_DEVNAME(zr));
1143                 err = -ENOMEM;
1144                 goto exit_free;
1145         }
1146         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1147                 zr->stat_com[j] = 1;    /* mark as unavailable to zr36057 */
1148         }
1149
1150         /*
1151          *   Now add the template and register the device unit.
1152          */
1153         memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1154         strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1155         err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr);
1156         if (err < 0)
1157                 goto exit_unregister;
1158
1159         zoran_init_hardware(zr);
1160         if (*zr_debug > 2)
1161                 detect_guest_activity(zr);
1162         test_interrupts(zr);
1163         if (!pass_through) {
1164                 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1165                 encoder_command(zr, ENCODER_SET_INPUT, &two);
1166         }
1167
1168         zr->zoran_proc = NULL;
1169         zr->initialized = 1;
1170         return 0;
1171
1172 exit_unregister:
1173         zoran_unregister_i2c(zr);
1174 exit_free:
1175         kfree(zr->stat_com);
1176         kfree(zr->video_dev);
1177         return err;
1178 }
1179
1180 static void
1181 zoran_release (struct zoran *zr)
1182 {
1183         if (!zr->initialized)
1184                 return;
1185         /* unregister videocodec bus */
1186         if (zr->codec) {
1187                 struct videocodec_master *master = zr->codec->master_data;
1188
1189                 videocodec_detach(zr->codec);
1190                 kfree(master);
1191         }
1192         if (zr->vfe) {
1193                 struct videocodec_master *master = zr->vfe->master_data;
1194
1195                 videocodec_detach(zr->vfe);
1196                 kfree(master);
1197         }
1198
1199         /* unregister i2c bus */
1200         zoran_unregister_i2c(zr);
1201         /* disable PCI bus-mastering */
1202         zoran_set_pci_master(zr, 0);
1203         /* put chip into reset */
1204         btwrite(0, ZR36057_SPGPPCR);
1205         free_irq(zr->pci_dev->irq, zr);
1206         /* unmap and free memory */
1207         kfree(zr->stat_com);
1208         zoran_proc_cleanup(zr);
1209         iounmap(zr->zr36057_mem);
1210         pci_disable_device(zr->pci_dev);
1211         video_unregister_device(zr->video_dev);
1212 }
1213
1214 void
1215 zoran_vdev_release (struct video_device *vdev)
1216 {
1217         kfree(vdev);
1218 }
1219
1220 static struct videocodec_master * __devinit
1221 zoran_setup_videocodec (struct zoran *zr,
1222                         int           type)
1223 {
1224         struct videocodec_master *m = NULL;
1225
1226         m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1227         if (!m) {
1228                 dprintk(1,
1229                         KERN_ERR
1230                         "%s: zoran_setup_videocodec() - no memory\n",
1231                         ZR_DEVNAME(zr));
1232                 return m;
1233         }
1234
1235         m->magic = 0L; /* magic not used */
1236         m->type = VID_HARDWARE_ZR36067;
1237         m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1238         strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1239         m->data = zr;
1240
1241         switch (type)
1242         {
1243         case CODEC_TYPE_ZR36060:
1244                 m->readreg = zr36060_read;
1245                 m->writereg = zr36060_write;
1246                 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1247                 break;
1248         case CODEC_TYPE_ZR36050:
1249                 m->readreg = zr36050_read;
1250                 m->writereg = zr36050_write;
1251                 m->flags |= CODEC_FLAG_JPEG;
1252                 break;
1253         case CODEC_TYPE_ZR36016:
1254                 m->readreg = zr36016_read;
1255                 m->writereg = zr36016_write;
1256                 m->flags |= CODEC_FLAG_VFE;
1257                 break;
1258         }
1259
1260         return m;
1261 }
1262
1263 /*
1264  *   Scan for a Buz card (actually for the PCI contoler ZR36057),
1265  *   request the irq and map the io memory
1266  */
1267 static int __devinit
1268 find_zr36057 (void)
1269 {
1270         unsigned char latency, need_latency;
1271         struct zoran *zr;
1272         struct pci_dev *dev = NULL;
1273         int result;
1274         struct videocodec_master *master_vfe = NULL;
1275         struct videocodec_master *master_codec = NULL;
1276         int card_num;
1277         char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1278
1279         zoran_num = 0;
1280         while (zoran_num < BUZ_MAX &&
1281                (dev = pci_get_device(PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1282                 card_num = card[zoran_num];
1283                 zr = &zoran[zoran_num];
1284                 memset(zr, 0, sizeof(struct zoran));    // Just in case if previous cycle failed
1285                 zr->pci_dev = dev;
1286                 //zr->zr36057_mem = NULL;
1287                 zr->id = zoran_num;
1288                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1289                 spin_lock_init(&zr->spinlock);
1290                 mutex_init(&zr->resource_lock);
1291                 if (pci_enable_device(dev))
1292                         continue;
1293                 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
1294                 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,
1295                                      &zr->revision);
1296                 if (zr->revision < 2) {
1297                         dprintk(1,
1298                                 KERN_INFO
1299                                 "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
1300                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1301                                 zr->zr36057_adr);
1302
1303                         if (card_num == -1) {
1304                                 dprintk(1,
1305                                         KERN_ERR
1306                                         "%s: find_zr36057() - no card specified, please use the card=X insmod option\n",
1307                                         ZR_DEVNAME(zr));
1308                                 continue;
1309                         }
1310                 } else {
1311                         int i;
1312                         unsigned short ss_vendor, ss_device;
1313
1314                         ss_vendor = zr->pci_dev->subsystem_vendor;
1315                         ss_device = zr->pci_dev->subsystem_device;
1316                         dprintk(1,
1317                                 KERN_INFO
1318                                 "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
1319                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1320                                 zr->zr36057_adr);
1321                         dprintk(1,
1322                                 KERN_INFO
1323                                 "%s: subsystem vendor=0x%04x id=0x%04x\n",
1324                                 ZR_DEVNAME(zr), ss_vendor, ss_device);
1325                         if (card_num == -1) {
1326                                 dprintk(3,
1327                                         KERN_DEBUG
1328                                         "%s: find_zr36057() - trying to autodetect card type\n",
1329                                         ZR_DEVNAME(zr));
1330                                 for (i=0;i<NUM_CARDS;i++) {
1331                                         if (ss_vendor == zoran_cards[i].vendor_id &&
1332                                             ss_device == zoran_cards[i].device_id) {
1333                                                 dprintk(3,
1334                                                         KERN_DEBUG
1335                                                         "%s: find_zr36057() - card %s detected\n",
1336                                                         ZR_DEVNAME(zr),
1337                                                         zoran_cards[i].name);
1338                                                 card_num = i;
1339                                                 break;
1340                                         }
1341                                 }
1342                                 if (i == NUM_CARDS) {
1343                                         dprintk(1,
1344                                                 KERN_ERR
1345                                                 "%s: find_zr36057() - unknown card\n",
1346                                                 ZR_DEVNAME(zr));
1347                                         continue;
1348                                 }
1349                         }
1350                 }
1351
1352                 if (card_num < 0 || card_num >= NUM_CARDS) {
1353                         dprintk(2,
1354                                 KERN_ERR
1355                                 "%s: find_zr36057() - invalid cardnum %d\n",
1356                                 ZR_DEVNAME(zr), card_num);
1357                         continue;
1358                 }
1359
1360                 /* even though we make this a non pointer and thus
1361                  * theoretically allow for making changes to this struct
1362                  * on a per-individual card basis at runtime, this is
1363                  * strongly discouraged. This structure is intended to
1364                  * keep general card information, no settings or anything */
1365                 zr->card = zoran_cards[card_num];
1366                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1367                          "%s[%u]", zr->card.name, zr->id);
1368
1369                 zr->zr36057_mem = ioremap_nocache(zr->zr36057_adr, 0x1000);
1370                 if (!zr->zr36057_mem) {
1371                         dprintk(1,
1372                                 KERN_ERR
1373                                 "%s: find_zr36057() - ioremap failed\n",
1374                                 ZR_DEVNAME(zr));
1375                         continue;
1376                 }
1377
1378                 result = request_irq(zr->pci_dev->irq,
1379                                      zoran_irq,
1380                                      IRQF_SHARED | IRQF_DISABLED,
1381                                      ZR_DEVNAME(zr),
1382                                      (void *) zr);
1383                 if (result < 0) {
1384                         if (result == -EINVAL) {
1385                                 dprintk(1,
1386                                         KERN_ERR
1387                                         "%s: find_zr36057() - bad irq number or handler\n",
1388                                         ZR_DEVNAME(zr));
1389                         } else if (result == -EBUSY) {
1390                                 dprintk(1,
1391                                         KERN_ERR
1392                                         "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1393                                         ZR_DEVNAME(zr), zr->pci_dev->irq);
1394                         } else {
1395                                 dprintk(1,
1396                                         KERN_ERR
1397                                         "%s: find_zr36057() - can't assign irq, error code %d\n",
1398                                         ZR_DEVNAME(zr), result);
1399                         }
1400                         goto zr_unmap;
1401                 }
1402
1403                 /* set PCI latency timer */
1404                 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1405                                      &latency);
1406                 need_latency = zr->revision > 1 ? 32 : 48;
1407                 if (latency != need_latency) {
1408                         dprintk(2,
1409                                 KERN_INFO
1410                                 "%s: Changing PCI latency from %d to %d.\n",
1411                                 ZR_DEVNAME(zr), latency, need_latency);
1412                         pci_write_config_byte(zr->pci_dev,
1413                                               PCI_LATENCY_TIMER,
1414                                               need_latency);
1415                 }
1416
1417                 zr36057_restart(zr);
1418                 /* i2c */
1419                 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1420                         ZR_DEVNAME(zr));
1421
1422                 /* i2c decoder */
1423                 if (decoder[zr->id] != -1) {
1424                         i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1425                         zr->card.i2c_decoder = decoder[zr->id];
1426                 } else if (zr->card.i2c_decoder != 0) {
1427                         i2c_dec_name =
1428                                 i2cid_to_modulename(zr->card.i2c_decoder);
1429                 } else {
1430                         i2c_dec_name = NULL;
1431                 }
1432
1433                 if (i2c_dec_name) {
1434                         if ((result = request_module(i2c_dec_name)) < 0) {
1435                                 dprintk(1,
1436                                         KERN_ERR
1437                                         "%s: failed to load module %s: %d\n",
1438                                         ZR_DEVNAME(zr), i2c_dec_name, result);
1439                         }
1440                 }
1441
1442                 /* i2c encoder */
1443                 if (encoder[zr->id] != -1) {
1444                         i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1445                         zr->card.i2c_encoder = encoder[zr->id];
1446                 } else if (zr->card.i2c_encoder != 0) {
1447                         i2c_enc_name =
1448                                 i2cid_to_modulename(zr->card.i2c_encoder);
1449                 } else {
1450                         i2c_enc_name = NULL;
1451                 }
1452
1453                 if (i2c_enc_name) {
1454                         if ((result = request_module(i2c_enc_name)) < 0) {
1455                                 dprintk(1,
1456                                         KERN_ERR
1457                                         "%s: failed to load module %s: %d\n",
1458                                         ZR_DEVNAME(zr), i2c_enc_name, result);
1459                         }
1460                 }
1461
1462                 if (zoran_register_i2c(zr) < 0) {
1463                         dprintk(1,
1464                                 KERN_ERR
1465                                 "%s: find_zr36057() - can't initialize i2c bus\n",
1466                                 ZR_DEVNAME(zr));
1467                         goto zr_free_irq;
1468                 }
1469
1470                 dprintk(2,
1471                         KERN_INFO "%s: Initializing videocodec bus...\n",
1472                         ZR_DEVNAME(zr));
1473
1474                 if (zr->card.video_codec != 0 &&
1475                     (codec_name =
1476                      codecid_to_modulename(zr->card.video_codec)) != NULL) {
1477                         if ((result = request_module(codec_name)) < 0) {
1478                                 dprintk(1,
1479                                         KERN_ERR
1480                                         "%s: failed to load modules %s: %d\n",
1481                                         ZR_DEVNAME(zr), codec_name, result);
1482                         }
1483                 }
1484                 if (zr->card.video_vfe != 0 &&
1485                     (vfe_name =
1486                      codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1487                         if ((result = request_module(vfe_name)) < 0) {
1488                                 dprintk(1,
1489                                         KERN_ERR
1490                                         "%s: failed to load modules %s: %d\n",
1491                                         ZR_DEVNAME(zr), vfe_name, result);
1492                         }
1493                 }
1494
1495                 /* reset JPEG codec */
1496                 jpeg_codec_sleep(zr, 1);
1497                 jpeg_codec_reset(zr);
1498                 /* video bus enabled */
1499                 /* display codec revision */
1500                 if (zr->card.video_codec != 0) {
1501                         master_codec = zoran_setup_videocodec(zr,
1502                                                               zr->card.video_codec);
1503                         if (!master_codec)
1504                                 goto zr_unreg_i2c;
1505                         zr->codec = videocodec_attach(master_codec);
1506                         if (!zr->codec) {
1507                                 dprintk(1,
1508                                         KERN_ERR
1509                                         "%s: find_zr36057() - no codec found\n",
1510                                         ZR_DEVNAME(zr));
1511                                 goto zr_free_codec;
1512                         }
1513                         if (zr->codec->type != zr->card.video_codec) {
1514                                 dprintk(1,
1515                                         KERN_ERR
1516                                         "%s: find_zr36057() - wrong codec\n",
1517                                         ZR_DEVNAME(zr));
1518                                 goto zr_detach_codec;
1519                         }
1520                 }
1521                 if (zr->card.video_vfe != 0) {
1522                         master_vfe = zoran_setup_videocodec(zr,
1523                                                             zr->card.video_vfe);
1524                         if (!master_vfe)
1525                                 goto zr_detach_codec;
1526                         zr->vfe = videocodec_attach(master_vfe);
1527                         if (!zr->vfe) {
1528                                 dprintk(1,
1529                                         KERN_ERR
1530                                         "%s: find_zr36057() - no VFE found\n",
1531                                         ZR_DEVNAME(zr));
1532                                 goto zr_free_vfe;
1533                         }
1534                         if (zr->vfe->type != zr->card.video_vfe) {
1535                                 dprintk(1,
1536                                         KERN_ERR
1537                                         "%s: find_zr36057() = wrong VFE\n",
1538                                         ZR_DEVNAME(zr));
1539                                 goto zr_detach_vfe;
1540                         }
1541                 }
1542                 /* Success so keep the pci_dev referenced */
1543                 pci_dev_get(zr->pci_dev);
1544                 zoran_num++;
1545                 continue;
1546
1547                 // Init errors
1548               zr_detach_vfe:
1549                 videocodec_detach(zr->vfe);
1550               zr_free_vfe:
1551                 kfree(master_vfe);
1552               zr_detach_codec:
1553                 videocodec_detach(zr->codec);
1554               zr_free_codec:
1555                 kfree(master_codec);
1556               zr_unreg_i2c:
1557                 zoran_unregister_i2c(zr);
1558               zr_free_irq:
1559                 btwrite(0, ZR36057_SPGPPCR);
1560                 free_irq(zr->pci_dev->irq, zr);
1561               zr_unmap:
1562                 iounmap(zr->zr36057_mem);
1563                 continue;
1564         }
1565         if (dev)        /* Clean up ref count on early exit */
1566                 pci_dev_put(dev);
1567
1568         if (zoran_num == 0) {
1569                 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1570         }
1571         return zoran_num;
1572 }
1573
1574 static int __init
1575 init_dc10_cards (void)
1576 {
1577         int i;
1578
1579         memset(zoran, 0, sizeof(zoran));
1580         printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1581                MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1582
1583         /* Look for cards */
1584         if (find_zr36057() < 0) {
1585                 return -EIO;
1586         }
1587         if (zoran_num == 0)
1588                 return -ENODEV;
1589         dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1590                 zoran_num);
1591         /* check the parameters we have been given, adjust if necessary */
1592         if (v4l_nbufs < 2)
1593                 v4l_nbufs = 2;
1594         if (v4l_nbufs > VIDEO_MAX_FRAME)
1595                 v4l_nbufs = VIDEO_MAX_FRAME;
1596         /* The user specfies the in KB, we want them in byte
1597          * (and page aligned) */
1598         v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1599         if (v4l_bufsize < 32768)
1600                 v4l_bufsize = 32768;
1601         /* 2 MB is arbitrary but sufficient for the maximum possible images */
1602         if (v4l_bufsize > 2048 * 1024)
1603                 v4l_bufsize = 2048 * 1024;
1604         if (jpg_nbufs < 4)
1605                 jpg_nbufs = 4;
1606         if (jpg_nbufs > BUZ_MAX_FRAME)
1607                 jpg_nbufs = BUZ_MAX_FRAME;
1608         jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1609         if (jpg_bufsize < 8192)
1610                 jpg_bufsize = 8192;
1611         if (jpg_bufsize > (512 * 1024))
1612                 jpg_bufsize = 512 * 1024;
1613         /* Use parameter for vidmem or try to find a video card */
1614         if (vidmem) {
1615                 dprintk(1,
1616                         KERN_INFO
1617                         "%s: Using supplied video memory base address @ 0x%lx\n",
1618                         ZORAN_NAME, vidmem);
1619         }
1620
1621         /* random nonsense */
1622         dprintk(5, KERN_DEBUG "Jotti is een held!\n");
1623
1624         /* some mainboards might not do PCI-PCI data transfer well */
1625         if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1626                 dprintk(1,
1627                         KERN_WARNING
1628                         "%s: chipset does not support reliable PCI-PCI DMA\n",
1629                         ZORAN_NAME);
1630         }
1631
1632         /* take care of Natoma chipset and a revision 1 zr36057 */
1633         for (i = 0; i < zoran_num; i++) {
1634                 struct zoran *zr = &zoran[i];
1635
1636                 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1637                         zr->jpg_buffers.need_contiguous = 1;
1638                         dprintk(1,
1639                                 KERN_INFO
1640                                 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1641                                 ZR_DEVNAME(zr));
1642                 }
1643
1644                 if (zr36057_init(zr) < 0) {
1645                         for (i = 0; i < zoran_num; i++)
1646                                 zoran_release(&zoran[i]);
1647                         return -EIO;
1648                 }
1649                 zoran_proc_init(zr);
1650         }
1651
1652         return 0;
1653 }
1654
1655 static void __exit
1656 unload_dc10_cards (void)
1657 {
1658         int i;
1659
1660         for (i = 0; i < zoran_num; i++)
1661                 zoran_release(&zoran[i]);
1662 }
1663
1664 module_init(init_dc10_cards);
1665 module_exit(unload_dc10_cards);