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] __devinitdata = {
 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         memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
 712                sizeof(struct i2c_algo_bit_data));
 713         zr->i2c_algo.data = zr;
 714         strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
 715                 sizeof(zr->i2c_adapter.name));
 716         i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
 717         zr->i2c_adapter.algo_data = &zr->i2c_algo;
 718         zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
 719         return i2c_bit_add_bus(&zr->i2c_adapter);
 720 }
 721
 722 static void
 723 zoran_unregister_i2c (struct zoran *zr)
 724 {
 725         i2c_del_adapter(&zr->i2c_adapter);
 726 }
 727
 728 /* Check a zoran_params struct for correctness, insert default params */
 729
 730 int
 731 zoran_check_jpg_settings (struct zoran              *zr,
 732                           struct zoran_jpg_settings *settings,
 733                           int try)
 734 {
 735         int err = 0, err0 = 0;
 736
 737         dprintk(4,
 738                 KERN_DEBUG
 739                 "%s: %s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
 740                 ZR_DEVNAME(zr), __func__, settings->decimation, settings->HorDcm,
 741                 settings->VerDcm, settings->TmpDcm);
 742         dprintk(4,
 743                 KERN_DEBUG
 744                 "%s: %s - x: %d, y: %d, w: %d, y: %d\n",
 745                 ZR_DEVNAME(zr), __func__, settings->img_x, settings->img_y,
 746                 settings->img_width, settings->img_height);
 747         /* Check decimation, set default values for decimation = 1, 2, 4 */
 748         switch (settings->decimation) {
 749         case 1:
 750
 751                 settings->HorDcm = 1;
 752                 settings->VerDcm = 1;
 753                 settings->TmpDcm = 1;
 754                 settings->field_per_buff = 2;
 755                 settings->img_x = 0;
 756                 settings->img_y = 0;
 757                 settings->img_width = BUZ_MAX_WIDTH;
 758                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 759                 break;
 760         case 2:
 761
 762                 settings->HorDcm = 2;
 763                 settings->VerDcm = 1;
 764                 settings->TmpDcm = 2;
 765                 settings->field_per_buff = 1;
 766                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 767                 settings->img_y = 0;
 768                 settings->img_width =
 769                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 770                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 771                 break;
 772         case 4:
 773
 774                 if (zr->card.type == DC10_new) {
 775                         dprintk(1,
 776                                 KERN_DEBUG
 777                                 "%s: %s - HDec by 4 is not supported on the DC10\n",
 778                                 ZR_DEVNAME(zr), __func__);
 779                         err0++;
 780                         break;
 781                 }
 782
 783                 settings->HorDcm = 4;
 784                 settings->VerDcm = 2;
 785                 settings->TmpDcm = 2;
 786                 settings->field_per_buff = 1;
 787                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
 788                 settings->img_y = 0;
 789                 settings->img_width =
 790                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
 791                 settings->img_height = BUZ_MAX_HEIGHT / 2;
 792                 break;
 793         case 0:
 794
 795                 /* We have to check the data the user has set */
 796
 797                 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
 798                     (zr->card.type == DC10_new || settings->HorDcm != 4)) {
 799                         settings->HorDcm = clamp(settings->HorDcm, 1, 2);
 800                         err0++;
 801                 }
 802                 if (settings->VerDcm != 1 && settings->VerDcm != 2) {
 803                         settings->VerDcm = clamp(settings->VerDcm, 1, 2);
 804                         err0++;
 805                 }
 806                 if (settings->TmpDcm != 1 && settings->TmpDcm != 2) {
 807                         settings->TmpDcm = clamp(settings->TmpDcm, 1, 2);
 808                         err0++;
 809                 }
 810                 if (settings->field_per_buff != 1 &&
 811                     settings->field_per_buff != 2) {
 812                         settings->field_per_buff = clamp(settings->field_per_buff, 1, 2);
 813                         err0++;
 814                 }
 815                 if (settings->img_x < 0) {
 816                         settings->img_x = 0;
 817                         err0++;
 818                 }
 819                 if (settings->img_y < 0) {
 820                         settings->img_y = 0;
 821                         err0++;
 822                 }
 823                 if (settings->img_width < 0 || settings->img_width > BUZ_MAX_WIDTH) {
 824                         settings->img_width = clamp(settings->img_width, 0, (int)BUZ_MAX_WIDTH);
 825                         err0++;
 826                 }
 827                 if (settings->img_height < 0 || settings->img_height > BUZ_MAX_HEIGHT / 2) {
 828                         settings->img_height = clamp(settings->img_height, 0, BUZ_MAX_HEIGHT / 2);
 829                         err0++;
 830                 }
 831                 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH) {
 832                         settings->img_x = BUZ_MAX_WIDTH - settings->img_width;
 833                         err0++;
 834                 }
 835                 if (settings->img_y + settings->img_height > BUZ_MAX_HEIGHT / 2) {
 836                         settings->img_y = BUZ_MAX_HEIGHT / 2 - settings->img_height;
 837                         err0++;
 838                 }
 839                 if (settings->img_width % (16 * settings->HorDcm) != 0) {
 840                         settings->img_width -= settings->img_width % (16 * settings->HorDcm);
 841                         if (settings->img_width == 0)
 842                                 settings->img_width = 16 * settings->HorDcm;
 843                         err0++;
 844                 }
 845                 if (settings->img_height % (8 * settings->VerDcm) != 0) {
 846                         settings->img_height -= settings->img_height % (8 * settings->VerDcm);
 847                         if (settings->img_height == 0)
 848                                 settings->img_height = 8 * settings->VerDcm;
 849                         err0++;
 850                 }
 851
 852                 if (!try && err0) {
 853                         dprintk(1,
 854                                 KERN_ERR
 855                                 "%s: %s - error in params for decimation = 0\n",
 856                                 ZR_DEVNAME(zr), __func__);
 857                         err++;
 858                 }
 859                 break;
 860         default:
 861                 dprintk(1,
 862                         KERN_ERR
 863                         "%s: %s - decimation = %d, must be 0, 1, 2 or 4\n",
 864                         ZR_DEVNAME(zr), __func__, settings->decimation);
 865                 err++;
 866                 break;
 867         }
 868
 869         if (settings->jpg_comp.quality > 100)
 870                 settings->jpg_comp.quality = 100;
 871         if (settings->jpg_comp.quality < 5)
 872                 settings->jpg_comp.quality = 5;
 873         if (settings->jpg_comp.APPn < 0)
 874                 settings->jpg_comp.APPn = 0;
 875         if (settings->jpg_comp.APPn > 15)
 876                 settings->jpg_comp.APPn = 15;
 877         if (settings->jpg_comp.APP_len < 0)
 878                 settings->jpg_comp.APP_len = 0;
 879         if (settings->jpg_comp.APP_len > 60)
 880                 settings->jpg_comp.APP_len = 60;
 881         if (settings->jpg_comp.COM_len < 0)
 882                 settings->jpg_comp.COM_len = 0;
 883         if (settings->jpg_comp.COM_len > 60)
 884                 settings->jpg_comp.COM_len = 60;
 885         if (err)
 886                 return -EINVAL;
 887         return 0;
 888 }
 889
 890 void
 891 zoran_open_init_params (struct zoran *zr)
 892 {
 893         int i;
 894
 895         /* User must explicitly set a window */
 896         zr->overlay_settings.is_set = 0;
 897         zr->overlay_mask = NULL;
 898         zr->overlay_active = ZORAN_FREE;
 899
 900         zr->v4l_memgrab_active = 0;
 901         zr->v4l_overlay_active = 0;
 902         zr->v4l_grab_frame = NO_GRAB_ACTIVE;
 903         zr->v4l_grab_seq = 0;
 904         zr->v4l_settings.width = 192;
 905         zr->v4l_settings.height = 144;
 906         zr->v4l_settings.format = &zoran_formats[7];    /* YUY2 - YUV-4:2:2 packed */
 907         zr->v4l_settings.bytesperline =
 908             zr->v4l_settings.width *
 909             ((zr->v4l_settings.format->depth + 7) / 8);
 910
 911         /* DMA ring stuff for V4L */
 912         zr->v4l_pend_tail = 0;
 913         zr->v4l_pend_head = 0;
 914         zr->v4l_sync_tail = 0;
 915         zr->v4l_buffers.active = ZORAN_FREE;
 916         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
 917                 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
 918         }
 919         zr->v4l_buffers.allocated = 0;
 920
 921         for (i = 0; i < BUZ_MAX_FRAME; i++) {
 922                 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
 923         }
 924         zr->jpg_buffers.active = ZORAN_FREE;
 925         zr->jpg_buffers.allocated = 0;
 926         /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
 927         zr->jpg_settings.decimation = 1;
 928         zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
 929         if (zr->card.type != BUZ)
 930                 zr->jpg_settings.odd_even = 1;
 931         else
 932                 zr->jpg_settings.odd_even = 0;
 933         zr->jpg_settings.jpg_comp.APPn = 0;
 934         zr->jpg_settings.jpg_comp.APP_len = 0;  /* No APPn marker */
 935         memset(zr->jpg_settings.jpg_comp.APP_data, 0,
 936                sizeof(zr->jpg_settings.jpg_comp.APP_data));
 937         zr->jpg_settings.jpg_comp.COM_len = 0;  /* No COM marker */
 938         memset(zr->jpg_settings.jpg_comp.COM_data, 0,
 939                sizeof(zr->jpg_settings.jpg_comp.COM_data));
 940         zr->jpg_settings.jpg_comp.jpeg_markers =
 941             V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT;
 942         i = zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
 943         if (i)
 944                 dprintk(1, KERN_ERR "%s: %s internal error\n",
 945                         ZR_DEVNAME(zr), __func__);
 946
 947         clear_interrupt_counters(zr);
 948         zr->testing = 0;
 949 }
 950
 951 static void __devinit
 952 test_interrupts (struct zoran *zr)
 953 {
 954         DEFINE_WAIT(wait);
 955         int timeout, icr;
 956
 957         clear_interrupt_counters(zr);
 958
 959         zr->testing = 1;
 960         icr = btread(ZR36057_ICR);
 961         btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
 962         prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
 963         timeout = schedule_timeout(HZ);
 964         finish_wait(&zr->test_q, &wait);
 965         btwrite(0, ZR36057_ICR);
 966         btwrite(0x78000000, ZR36057_ISR);
 967         zr->testing = 0;
 968         dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
 969         if (timeout) {
 970                 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
 971         }
 972         if (zr36067_debug > 1)
 973                 print_interrupts(zr);
 974         btwrite(icr, ZR36057_ICR);
 975 }
 976
 977 static int __devinit
 978 zr36057_init (struct zoran *zr)
 979 {
 980         int j, err;
 981
 982         dprintk(1,
 983                 KERN_INFO
 984                 "%s: %s - initializing card[%d], zr=%p\n",
 985                 ZR_DEVNAME(zr), __func__, zr->id, zr);
 986
 987         /* default setup of all parameters which will persist between opens */
 988         zr->user = 0;
 989
 990         init_waitqueue_head(&zr->v4l_capq);
 991         init_waitqueue_head(&zr->jpg_capq);
 992         init_waitqueue_head(&zr->test_q);
 993         zr->jpg_buffers.allocated = 0;
 994         zr->v4l_buffers.allocated = 0;
 995
 996         zr->vbuf_base = (void *) vidmem;
 997         zr->vbuf_width = 0;
 998         zr->vbuf_height = 0;
 999         zr->vbuf_depth = 0;
1000         zr->vbuf_bytesperline = 0;
1001
1002         /* Avoid nonsense settings from user for default input/norm */
1003         if (default_norm < 0 || default_norm > 2)
1004                 default_norm = 0;
1005         if (default_norm == 0) {
1006                 zr->norm = V4L2_STD_PAL;
1007                 zr->timing = zr->card.tvn[0];
1008         } else if (default_norm == 1) {
1009                 zr->norm = V4L2_STD_NTSC;
1010                 zr->timing = zr->card.tvn[1];
1011         } else {
1012                 zr->norm = V4L2_STD_SECAM;
1013                 zr->timing = zr->card.tvn[2];
1014         }
1015         if (zr->timing == NULL) {
1016                 dprintk(1,
1017                         KERN_WARNING
1018                         "%s: %s - default TV standard not supported by hardware. PAL will be used.\n",
1019                         ZR_DEVNAME(zr), __func__);
1020                 zr->norm = V4L2_STD_PAL;
1021                 zr->timing = zr->card.tvn[0];
1022         }
1023
1024         if (default_input > zr->card.inputs-1) {
1025                 dprintk(1,
1026                         KERN_WARNING
1027                         "%s: default_input value %d out of range (0-%d)\n",
1028                         ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1029                 default_input = 0;
1030         }
1031         zr->input = default_input;
1032
1033         /* default setup (will be repeated at every open) */
1034         zoran_open_init_params(zr);
1035
1036         /* allocate memory *before* doing anything to the hardware
1037          * in case allocation fails */
1038         zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1039         zr->video_dev = video_device_alloc();
1040         if (!zr->stat_com || !zr->video_dev) {
1041                 dprintk(1,
1042                         KERN_ERR
1043                         "%s: %s - kmalloc (STAT_COM) failed\n",
1044                         ZR_DEVNAME(zr), __func__);
1045                 err = -ENOMEM;
1046                 goto exit_free;
1047         }
1048         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1049                 zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1050         }
1051
1052         /*
1053          *   Now add the template and register the device unit.
1054          */
1055         memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1056         zr->video_dev->parent = &zr->pci_dev->dev;
1057         strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1058         /* It's not a mem2mem device, but you can both capture and output from
1059            one and the same device. This should really be split up into two
1060            device nodes, but that's a job for another day. */
1061         zr->video_dev->vfl_dir = VFL_DIR_M2M;
1062         err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
1063         if (err < 0)
1064                 goto exit_free;
1065         video_set_drvdata(zr->video_dev, zr);
1066
1067         zoran_init_hardware(zr);
1068         if (zr36067_debug > 2)
1069                 detect_guest_activity(zr);
1070         test_interrupts(zr);
1071         if (!pass_through) {
1072                 decoder_call(zr, video, s_stream, 0);
1073                 encoder_call(zr, video, s_routing, 2, 0, 0);
1074         }
1075
1076         zr->zoran_proc = NULL;
1077         zr->initialized = 1;
1078         return 0;
1079
1080 exit_free:
1081         kfree(zr->stat_com);
1082         kfree(zr->video_dev);
1083         return err;
1084 }
1085
1086 static void __devexit zoran_remove(struct pci_dev *pdev)
1087 {
1088         struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1089         struct zoran *zr = to_zoran(v4l2_dev);
1090
1091         if (!zr->initialized)
1092                 goto exit_free;
1093
1094         /* unregister videocodec bus */
1095         if (zr->codec) {
1096                 struct videocodec_master *master = zr->codec->master_data;
1097
1098                 videocodec_detach(zr->codec);
1099                 kfree(master);
1100         }
1101         if (zr->vfe) {
1102                 struct videocodec_master *master = zr->vfe->master_data;
1103
1104                 videocodec_detach(zr->vfe);
1105                 kfree(master);
1106         }
1107
1108         /* unregister i2c bus */
1109         zoran_unregister_i2c(zr);
1110         /* disable PCI bus-mastering */
1111         zoran_set_pci_master(zr, 0);
1112         /* put chip into reset */
1113         btwrite(0, ZR36057_SPGPPCR);
1114         free_irq(zr->pci_dev->irq, zr);
1115         /* unmap and free memory */
1116         kfree(zr->stat_com);
1117         zoran_proc_cleanup(zr);
1118         iounmap(zr->zr36057_mem);
1119         pci_disable_device(zr->pci_dev);
1120         video_unregister_device(zr->video_dev);
1121 exit_free:
1122         v4l2_device_unregister(&zr->v4l2_dev);
1123         kfree(zr);
1124 }
1125
1126 void
1127 zoran_vdev_release (struct video_device *vdev)
1128 {
1129         kfree(vdev);
1130 }
1131
1132 static struct videocodec_master * __devinit
1133 zoran_setup_videocodec (struct zoran *zr,
1134                         int           type)
1135 {
1136         struct videocodec_master *m = NULL;
1137
1138         m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1139         if (!m) {
1140                 dprintk(1, KERN_ERR "%s: %s - no memory\n",
1141                         ZR_DEVNAME(zr), __func__);
1142                 return m;
1143         }
1144
1145         /* magic and type are unused for master struct. Makes sense only at
1146            codec structs.
1147            In the past, .type were initialized to the old V4L1 .hardware
1148            value, as VID_HARDWARE_ZR36067
1149          */
1150         m->magic = 0L;
1151         m->type = 0;
1152
1153         m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1154         strlcpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1155         m->data = zr;
1156
1157         switch (type)
1158         {
1159         case CODEC_TYPE_ZR36060:
1160                 m->readreg = zr36060_read;
1161                 m->writereg = zr36060_write;
1162                 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1163                 break;
1164         case CODEC_TYPE_ZR36050:
1165                 m->readreg = zr36050_read;
1166                 m->writereg = zr36050_write;
1167                 m->flags |= CODEC_FLAG_JPEG;
1168                 break;
1169         case CODEC_TYPE_ZR36016:
1170                 m->readreg = zr36016_read;
1171                 m->writereg = zr36016_write;
1172                 m->flags |= CODEC_FLAG_VFE;
1173                 break;
1174         }
1175
1176         return m;
1177 }
1178
1179 static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1180 {
1181         struct zoran *zr = to_zoran(sd->v4l2_dev);
1182
1183         /* Bt819 needs to reset its FIFO buffer using #FRST pin and
1184            LML33 card uses GPIO(7) for that. */
1185         if (cmd == BT819_FIFO_RESET_LOW)
1186                 GPIO(zr, 7, 0);
1187         else if (cmd == BT819_FIFO_RESET_HIGH)
1188                 GPIO(zr, 7, 1);
1189 }
1190
1191 /*
1192  *   Scan for a Buz card (actually for the PCI controller ZR36057),
1193  *   request the irq and map the io memory
1194  */
1195 static int __devinit zoran_probe(struct pci_dev *pdev,
1196                                  const struct pci_device_id *ent)
1197 {
1198         unsigned char latency, need_latency;
1199         struct zoran *zr;
1200         int result;
1201         struct videocodec_master *master_vfe = NULL;
1202         struct videocodec_master *master_codec = NULL;
1203         int card_num;
1204         char *codec_name, *vfe_name;
1205         unsigned int nr;
1206
1207
1208         nr = zoran_num++;
1209         if (nr >= BUZ_MAX) {
1210                 dprintk(1, KERN_ERR "%s: driver limited to %d card(s) maximum\n",
1211                         ZORAN_NAME, BUZ_MAX);
1212                 return -ENOENT;
1213         }
1214
1215         zr = kzalloc(sizeof(struct zoran), GFP_KERNEL);
1216         if (!zr) {
1217                 dprintk(1, KERN_ERR "%s: %s - kzalloc failed\n",
1218                         ZORAN_NAME, __func__);
1219                 return -ENOMEM;
1220         }
1221         zr->v4l2_dev.notify = zoran_subdev_notify;
1222         if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
1223                 goto zr_free_mem;
1224         zr->pci_dev = pdev;
1225         zr->id = nr;
1226         snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1227         spin_lock_init(&zr->spinlock);
1228         mutex_init(&zr->resource_lock);
1229         mutex_init(&zr->other_lock);
1230         if (pci_enable_device(pdev))
1231                 goto zr_unreg;
1232         zr->revision = zr->pci_dev->revision;
1233
1234         dprintk(1,
1235                 KERN_INFO
1236                 "%s: Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
1237                 ZR_DEVNAME(zr), zr->revision < 2 ? '5' : '6', zr->revision,
1238                 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0));
1239         if (zr->revision >= 2) {
1240                 dprintk(1,
1241                         KERN_INFO
1242                         "%s: Subsystem vendor=0x%04x id=0x%04x\n",
1243                         ZR_DEVNAME(zr), zr->pci_dev->subsystem_vendor,
1244                         zr->pci_dev->subsystem_device);
1245         }
1246
1247         /* Use auto-detected card type? */
1248         if (card[nr] == -1) {
1249                 if (zr->revision < 2) {
1250                         dprintk(1,
1251                                 KERN_ERR
1252                                 "%s: No card type specified, please use the card=X module parameter\n",
1253                                 ZR_DEVNAME(zr));
1254                         dprintk(1,
1255                                 KERN_ERR
1256                                 "%s: It is not possible to auto-detect ZR36057 based cards\n",
1257                                 ZR_DEVNAME(zr));
1258                         goto zr_unreg;
1259                 }
1260
1261                 card_num = ent->driver_data;
1262                 if (card_num >= NUM_CARDS) {
1263                         dprintk(1,
1264                                 KERN_ERR
1265                                 "%s: Unknown card, try specifying card=X module parameter\n",
1266                                 ZR_DEVNAME(zr));
1267                         goto zr_unreg;
1268                 }
1269                 dprintk(3,
1270                         KERN_DEBUG
1271                         "%s: %s() - card %s detected\n",
1272                         ZR_DEVNAME(zr), __func__, zoran_cards[card_num].name);
1273         } else {
1274                 card_num = card[nr];
1275                 if (card_num >= NUM_CARDS || card_num < 0) {
1276                         dprintk(1,
1277                                 KERN_ERR
1278                                 "%s: User specified card type %d out of range (0 .. %d)\n",
1279                                 ZR_DEVNAME(zr), card_num, NUM_CARDS - 1);
1280                         goto zr_unreg;
1281                 }
1282         }
1283
1284         /* even though we make this a non pointer and thus
1285          * theoretically allow for making changes to this struct
1286          * on a per-individual card basis at runtime, this is
1287          * strongly discouraged. This structure is intended to
1288          * keep general card information, no settings or anything */
1289         zr->card = zoran_cards[card_num];
1290         snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1291                  "%s[%u]", zr->card.name, zr->id);
1292
1293         zr->zr36057_mem = pci_ioremap_bar(zr->pci_dev, 0);
1294         if (!zr->zr36057_mem) {
1295                 dprintk(1, KERN_ERR "%s: %s() - ioremap failed\n",
1296                         ZR_DEVNAME(zr), __func__);
1297                 goto zr_unreg;
1298         }
1299
1300         result = request_irq(zr->pci_dev->irq, zoran_irq,
1301                              IRQF_SHARED | IRQF_DISABLED, ZR_DEVNAME(zr), zr);
1302         if (result < 0) {
1303                 if (result == -EINVAL) {
1304                         dprintk(1,
1305                                 KERN_ERR
1306                                 "%s: %s - bad irq number or handler\n",
1307                                 ZR_DEVNAME(zr), __func__);
1308                 } else if (result == -EBUSY) {
1309                         dprintk(1,
1310                                 KERN_ERR
1311                                 "%s: %s - IRQ %d busy, change your PnP config in BIOS\n",
1312                                 ZR_DEVNAME(zr), __func__, zr->pci_dev->irq);
1313                 } else {
1314                         dprintk(1,
1315                                 KERN_ERR
1316                                 "%s: %s - can't assign irq, error code %d\n",
1317                                 ZR_DEVNAME(zr), __func__, result);
1318                 }
1319                 goto zr_unmap;
1320         }
1321
1322         /* set PCI latency timer */
1323         pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1324                              &latency);
1325         need_latency = zr->revision > 1 ? 32 : 48;
1326         if (latency != need_latency) {
1327                 dprintk(2, KERN_INFO "%s: Changing PCI latency from %d to %d\n",
1328                         ZR_DEVNAME(zr), latency, need_latency);
1329                 pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1330                                       need_latency);
1331         }
1332
1333         zr36057_restart(zr);
1334         /* i2c */
1335         dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1336                 ZR_DEVNAME(zr));
1337
1338         if (zoran_register_i2c(zr) < 0) {
1339                 dprintk(1, KERN_ERR "%s: %s - can't initialize i2c bus\n",
1340                         ZR_DEVNAME(zr), __func__);
1341                 goto zr_free_irq;
1342         }
1343
1344         zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
1345                 &zr->i2c_adapter, zr->card.i2c_decoder,
1346                 0, zr->card.addrs_decoder);
1347
1348         if (zr->card.i2c_encoder)
1349                 zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
1350                         &zr->i2c_adapter, zr->card.i2c_encoder,
1351                         0, zr->card.addrs_encoder);
1352
1353         dprintk(2,
1354                 KERN_INFO "%s: Initializing videocodec bus...\n",
1355                 ZR_DEVNAME(zr));
1356
1357         if (zr->card.video_codec) {
1358                 codec_name = codecid_to_modulename(zr->card.video_codec);
1359                 if (codec_name) {
1360                         result = request_module(codec_name);
1361                         if (result) {
1362                                 dprintk(1,
1363                                         KERN_ERR
1364                                         "%s: failed to load modules %s: %d\n",
1365                                         ZR_DEVNAME(zr), codec_name, result);
1366                         }
1367                 }
1368         }
1369         if (zr->card.video_vfe) {
1370                 vfe_name = codecid_to_modulename(zr->card.video_vfe);
1371                 if (vfe_name) {
1372                         result = request_module(vfe_name);
1373                         if (result < 0) {
1374                                 dprintk(1,
1375                                         KERN_ERR
1376                                         "%s: failed to load modules %s: %d\n",
1377                                         ZR_DEVNAME(zr), vfe_name, result);
1378                         }
1379                 }
1380         }
1381
1382         /* reset JPEG codec */
1383         jpeg_codec_sleep(zr, 1);
1384         jpeg_codec_reset(zr);
1385         /* video bus enabled */
1386         /* display codec revision */
1387         if (zr->card.video_codec != 0) {
1388                 master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);
1389                 if (!master_codec)
1390                         goto zr_unreg_i2c;
1391                 zr->codec = videocodec_attach(master_codec);
1392                 if (!zr->codec) {
1393                         dprintk(1, KERN_ERR "%s: %s - no codec found\n",
1394                                 ZR_DEVNAME(zr), __func__);
1395                         goto zr_free_codec;
1396                 }
1397                 if (zr->codec->type != zr->card.video_codec) {
1398                         dprintk(1, KERN_ERR "%s: %s - wrong codec\n",
1399                                 ZR_DEVNAME(zr), __func__);
1400                         goto zr_detach_codec;
1401                 }
1402         }
1403         if (zr->card.video_vfe != 0) {
1404                 master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);
1405                 if (!master_vfe)
1406                         goto zr_detach_codec;
1407                 zr->vfe = videocodec_attach(master_vfe);
1408                 if (!zr->vfe) {
1409                         dprintk(1, KERN_ERR "%s: %s - no VFE found\n",
1410                                 ZR_DEVNAME(zr), __func__);
1411                         goto zr_free_vfe;
1412                 }
1413                 if (zr->vfe->type != zr->card.video_vfe) {
1414                         dprintk(1, KERN_ERR "%s: %s = wrong VFE\n",
1415                                 ZR_DEVNAME(zr), __func__);
1416                         goto zr_detach_vfe;
1417                 }
1418         }
1419
1420         /* take care of Natoma chipset and a revision 1 zr36057 */
1421         if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1422                 zr->jpg_buffers.need_contiguous = 1;
1423                 dprintk(1, KERN_INFO
1424                         "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1425                         ZR_DEVNAME(zr));
1426         }
1427
1428         if (zr36057_init(zr) < 0)
1429                 goto zr_detach_vfe;
1430
1431         zoran_proc_init(zr);
1432
1433         return 0;
1434
1435 zr_detach_vfe:
1436         videocodec_detach(zr->vfe);
1437 zr_free_vfe:
1438         kfree(master_vfe);
1439 zr_detach_codec:
1440         videocodec_detach(zr->codec);
1441 zr_free_codec:
1442         kfree(master_codec);
1443 zr_unreg_i2c:
1444         zoran_unregister_i2c(zr);
1445 zr_free_irq:
1446         btwrite(0, ZR36057_SPGPPCR);
1447         free_irq(zr->pci_dev->irq, zr);
1448 zr_unmap:
1449         iounmap(zr->zr36057_mem);
1450 zr_unreg:
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 = __devexit_p(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);