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