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_bit_del_bus((&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 =
1282                 pci_find_device(PCI_VENDOR_ID_ZORAN,
1283                                 PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1284                 card_num = card[zoran_num];
1285                 zr = &zoran[zoran_num];
1286                 memset(zr, 0, sizeof(struct zoran));    // Just in case if previous cycle failed
1287                 zr->pci_dev = dev;
1288                 //zr->zr36057_mem = NULL;
1289                 zr->id = zoran_num;
1290                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1291                 spin_lock_init(&zr->spinlock);
1292                 mutex_init(&zr->resource_lock);
1293                 if (pci_enable_device(dev))
1294                         continue;
1295                 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
1296                 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,
1297                                      &zr->revision);
1298                 if (zr->revision < 2) {
1299                         dprintk(1,
1300                                 KERN_INFO
1301                                 "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
1302                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1303                                 zr->zr36057_adr);
1304
1305                         if (card_num == -1) {
1306                                 dprintk(1,
1307                                         KERN_ERR
1308                                         "%s: find_zr36057() - no card specified, please use the card=X insmod option\n",
1309                                         ZR_DEVNAME(zr));
1310                                 continue;
1311                         }
1312                 } else {
1313                         int i;
1314                         unsigned short ss_vendor, ss_device;
1315
1316                         ss_vendor = zr->pci_dev->subsystem_vendor;
1317                         ss_device = zr->pci_dev->subsystem_device;
1318                         dprintk(1,
1319                                 KERN_INFO
1320                                 "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
1321                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1322                                 zr->zr36057_adr);
1323                         dprintk(1,
1324                                 KERN_INFO
1325                                 "%s: subsystem vendor=0x%04x id=0x%04x\n",
1326                                 ZR_DEVNAME(zr), ss_vendor, ss_device);
1327                         if (card_num == -1) {
1328                                 dprintk(3,
1329                                         KERN_DEBUG
1330                                         "%s: find_zr36057() - trying to autodetect card type\n",
1331                                         ZR_DEVNAME(zr));
1332                                 for (i=0;i<NUM_CARDS;i++) {
1333                                         if (ss_vendor == zoran_cards[i].vendor_id &&
1334                                             ss_device == zoran_cards[i].device_id) {
1335                                                 dprintk(3,
1336                                                         KERN_DEBUG
1337                                                         "%s: find_zr36057() - card %s detected\n",
1338                                                         ZR_DEVNAME(zr),
1339                                                         zoran_cards[i].name);
1340                                                 card_num = i;
1341                                                 break;
1342                                         }
1343                                 }
1344                                 if (i == NUM_CARDS) {
1345                                         dprintk(1,
1346                                                 KERN_ERR
1347                                                 "%s: find_zr36057() - unknown card\n",
1348                                                 ZR_DEVNAME(zr));
1349                                         continue;
1350                                 }
1351                         }
1352                 }
1353
1354                 if (card_num < 0 || card_num >= NUM_CARDS) {
1355                         dprintk(2,
1356                                 KERN_ERR
1357                                 "%s: find_zr36057() - invalid cardnum %d\n",
1358                                 ZR_DEVNAME(zr), card_num);
1359                         continue;
1360                 }
1361
1362                 /* even though we make this a non pointer and thus
1363                  * theoretically allow for making changes to this struct
1364                  * on a per-individual card basis at runtime, this is
1365                  * strongly discouraged. This structure is intended to
1366                  * keep general card information, no settings or anything */
1367                 zr->card = zoran_cards[card_num];
1368                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1369                          "%s[%u]", zr->card.name, zr->id);
1370
1371                 zr->zr36057_mem = ioremap_nocache(zr->zr36057_adr, 0x1000);
1372                 if (!zr->zr36057_mem) {
1373                         dprintk(1,
1374                                 KERN_ERR
1375                                 "%s: find_zr36057() - ioremap failed\n",
1376                                 ZR_DEVNAME(zr));
1377                         continue;
1378                 }
1379
1380                 result = request_irq(zr->pci_dev->irq,
1381                                      zoran_irq,
1382                                      IRQF_SHARED | IRQF_DISABLED,
1383                                      ZR_DEVNAME(zr),
1384                                      (void *) zr);
1385                 if (result < 0) {
1386                         if (result == -EINVAL) {
1387                                 dprintk(1,
1388                                         KERN_ERR
1389                                         "%s: find_zr36057() - bad irq number or handler\n",
1390                                         ZR_DEVNAME(zr));
1391                         } else if (result == -EBUSY) {
1392                                 dprintk(1,
1393                                         KERN_ERR
1394                                         "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1395                                         ZR_DEVNAME(zr), zr->pci_dev->irq);
1396                         } else {
1397                                 dprintk(1,
1398                                         KERN_ERR
1399                                         "%s: find_zr36057() - can't assign irq, error code %d\n",
1400                                         ZR_DEVNAME(zr), result);
1401                         }
1402                         goto zr_unmap;
1403                 }
1404
1405                 /* set PCI latency timer */
1406                 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1407                                      &latency);
1408                 need_latency = zr->revision > 1 ? 32 : 48;
1409                 if (latency != need_latency) {
1410                         dprintk(2,
1411                                 KERN_INFO
1412                                 "%s: Changing PCI latency from %d to %d.\n",
1413                                 ZR_DEVNAME(zr), latency, need_latency);
1414                         pci_write_config_byte(zr->pci_dev,
1415                                               PCI_LATENCY_TIMER,
1416                                               need_latency);
1417                 }
1418
1419                 zr36057_restart(zr);
1420                 /* i2c */
1421                 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1422                         ZR_DEVNAME(zr));
1423
1424                 /* i2c decoder */
1425                 if (decoder[zr->id] != -1) {
1426                         i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1427                         zr->card.i2c_decoder = decoder[zr->id];
1428                 } else if (zr->card.i2c_decoder != 0) {
1429                         i2c_dec_name =
1430                                 i2cid_to_modulename(zr->card.i2c_decoder);
1431                 } else {
1432                         i2c_dec_name = NULL;
1433                 }
1434
1435                 if (i2c_dec_name) {
1436                         if ((result = request_module(i2c_dec_name)) < 0) {
1437                                 dprintk(1,
1438                                         KERN_ERR
1439                                         "%s: failed to load module %s: %d\n",
1440                                         ZR_DEVNAME(zr), i2c_dec_name, result);
1441                         }
1442                 }
1443
1444                 /* i2c encoder */
1445                 if (encoder[zr->id] != -1) {
1446                         i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1447                         zr->card.i2c_encoder = encoder[zr->id];
1448                 } else if (zr->card.i2c_encoder != 0) {
1449                         i2c_enc_name =
1450                                 i2cid_to_modulename(zr->card.i2c_encoder);
1451                 } else {
1452                         i2c_enc_name = NULL;
1453                 }
1454
1455                 if (i2c_enc_name) {
1456                         if ((result = request_module(i2c_enc_name)) < 0) {
1457                                 dprintk(1,
1458                                         KERN_ERR
1459                                         "%s: failed to load module %s: %d\n",
1460                                         ZR_DEVNAME(zr), i2c_enc_name, result);
1461                         }
1462                 }
1463
1464                 if (zoran_register_i2c(zr) < 0) {
1465                         dprintk(1,
1466                                 KERN_ERR
1467                                 "%s: find_zr36057() - can't initialize i2c bus\n",
1468                                 ZR_DEVNAME(zr));
1469                         goto zr_free_irq;
1470                 }
1471
1472                 dprintk(2,
1473                         KERN_INFO "%s: Initializing videocodec bus...\n",
1474                         ZR_DEVNAME(zr));
1475
1476                 if (zr->card.video_codec != 0 &&
1477                     (codec_name =
1478                      codecid_to_modulename(zr->card.video_codec)) != NULL) {
1479                         if ((result = request_module(codec_name)) < 0) {
1480                                 dprintk(1,
1481                                         KERN_ERR
1482                                         "%s: failed to load modules %s: %d\n",
1483                                         ZR_DEVNAME(zr), codec_name, result);
1484                         }
1485                 }
1486                 if (zr->card.video_vfe != 0 &&
1487                     (vfe_name =
1488                      codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1489                         if ((result = request_module(vfe_name)) < 0) {
1490                                 dprintk(1,
1491                                         KERN_ERR
1492                                         "%s: failed to load modules %s: %d\n",
1493                                         ZR_DEVNAME(zr), vfe_name, result);
1494                         }
1495                 }
1496
1497                 /* reset JPEG codec */
1498                 jpeg_codec_sleep(zr, 1);
1499                 jpeg_codec_reset(zr);
1500                 /* video bus enabled */
1501                 /* display codec revision */
1502                 if (zr->card.video_codec != 0) {
1503                         master_codec = zoran_setup_videocodec(zr,
1504                                                               zr->card.video_codec);
1505                         if (!master_codec)
1506                                 goto zr_unreg_i2c;
1507                         zr->codec = videocodec_attach(master_codec);
1508                         if (!zr->codec) {
1509                                 dprintk(1,
1510                                         KERN_ERR
1511                                         "%s: find_zr36057() - no codec found\n",
1512                                         ZR_DEVNAME(zr));
1513                                 goto zr_free_codec;
1514                         }
1515                         if (zr->codec->type != zr->card.video_codec) {
1516                                 dprintk(1,
1517                                         KERN_ERR
1518                                         "%s: find_zr36057() - wrong codec\n",
1519                                         ZR_DEVNAME(zr));
1520                                 goto zr_detach_codec;
1521                         }
1522                 }
1523                 if (zr->card.video_vfe != 0) {
1524                         master_vfe = zoran_setup_videocodec(zr,
1525                                                             zr->card.video_vfe);
1526                         if (!master_vfe)
1527                                 goto zr_detach_codec;
1528                         zr->vfe = videocodec_attach(master_vfe);
1529                         if (!zr->vfe) {
1530                                 dprintk(1,
1531                                         KERN_ERR
1532                                         "%s: find_zr36057() - no VFE found\n",
1533                                         ZR_DEVNAME(zr));
1534                                 goto zr_free_vfe;
1535                         }
1536                         if (zr->vfe->type != zr->card.video_vfe) {
1537                                 dprintk(1,
1538                                         KERN_ERR
1539                                         "%s: find_zr36057() = wrong VFE\n",
1540                                         ZR_DEVNAME(zr));
1541                                 goto zr_detach_vfe;
1542                         }
1543                 }
1544
1545                 zoran_num++;
1546                 continue;
1547
1548                 // Init errors
1549               zr_detach_vfe:
1550                 videocodec_detach(zr->vfe);
1551               zr_free_vfe:
1552                 kfree(master_vfe);
1553               zr_detach_codec:
1554                 videocodec_detach(zr->codec);
1555               zr_free_codec:
1556                 kfree(master_codec);
1557               zr_unreg_i2c:
1558                 zoran_unregister_i2c(zr);
1559               zr_free_irq:
1560                 btwrite(0, ZR36057_SPGPPCR);
1561                 free_irq(zr->pci_dev->irq, zr);
1562               zr_unmap:
1563                 iounmap(zr->zr36057_mem);
1564                 continue;
1565         }
1566         if (zoran_num == 0) {
1567                 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1568         }
1569         return zoran_num;
1570 }
1571
1572 static int __init
1573 init_dc10_cards (void)
1574 {
1575         int i;
1576
1577         memset(zoran, 0, sizeof(zoran));
1578         printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1579                MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1580
1581         /* Look for cards */
1582         if (find_zr36057() < 0) {
1583                 return -EIO;
1584         }
1585         if (zoran_num == 0)
1586                 return -ENODEV;
1587         dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1588                 zoran_num);
1589         /* check the parameters we have been given, adjust if necessary */
1590         if (v4l_nbufs < 2)
1591                 v4l_nbufs = 2;
1592         if (v4l_nbufs > VIDEO_MAX_FRAME)
1593                 v4l_nbufs = VIDEO_MAX_FRAME;
1594         /* The user specfies the in KB, we want them in byte
1595          * (and page aligned) */
1596         v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1597         if (v4l_bufsize < 32768)
1598                 v4l_bufsize = 32768;
1599         /* 2 MB is arbitrary but sufficient for the maximum possible images */
1600         if (v4l_bufsize > 2048 * 1024)
1601                 v4l_bufsize = 2048 * 1024;
1602         if (jpg_nbufs < 4)
1603                 jpg_nbufs = 4;
1604         if (jpg_nbufs > BUZ_MAX_FRAME)
1605                 jpg_nbufs = BUZ_MAX_FRAME;
1606         jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1607         if (jpg_bufsize < 8192)
1608                 jpg_bufsize = 8192;
1609         if (jpg_bufsize > (512 * 1024))
1610                 jpg_bufsize = 512 * 1024;
1611         /* Use parameter for vidmem or try to find a video card */
1612         if (vidmem) {
1613                 dprintk(1,
1614                         KERN_INFO
1615                         "%s: Using supplied video memory base address @ 0x%lx\n",
1616                         ZORAN_NAME, vidmem);
1617         }
1618
1619         /* random nonsense */
1620         dprintk(5, KERN_DEBUG "Jotti is een held!\n");
1621
1622         /* some mainboards might not do PCI-PCI data transfer well */
1623         if (pci_pci_problems & PCIPCI_FAIL) {
1624                 dprintk(1,
1625                         KERN_WARNING
1626                         "%s: chipset may not support reliable PCI-PCI DMA\n",
1627                         ZORAN_NAME);
1628         }
1629
1630         /* take care of Natoma chipset and a revision 1 zr36057 */
1631         for (i = 0; i < zoran_num; i++) {
1632                 struct zoran *zr = &zoran[i];
1633
1634                 if (pci_pci_problems & PCIPCI_NATOMA && zr->revision <= 1) {
1635                         zr->jpg_buffers.need_contiguous = 1;
1636                         dprintk(1,
1637                                 KERN_INFO
1638                                 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1639                                 ZR_DEVNAME(zr));
1640                 }
1641
1642                 if (zr36057_init(zr) < 0) {
1643                         for (i = 0; i < zoran_num; i++)
1644                                 zoran_release(&zoran[i]);
1645                         return -EIO;
1646                 }
1647                 zoran_proc_init(zr);
1648         }
1649
1650         return 0;
1651 }
1652
1653 static void __exit
1654 unload_dc10_cards (void)
1655 {
1656         int i;
1657
1658         for (i = 0; i < zoran_num; i++)
1659                 zoran_release(&zoran[i]);
1660 }
1661
1662 module_init(init_dc10_cards);
1663 module_exit(unload_dc10_cards);