drivers/media/video/zoran/zoran_card.c

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