drivers/media/video/zoran_card.c

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