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