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