drivers/media/video/ivtv/ivtv-driver.c

   1 /*
   2     ivtv driver initialization and card probing
   3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
   5     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* Main Driver file for the ivtv project:
  23  * Driver for the Conexant CX23415/CX23416 chip.
  24  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
  25  * License: GPL
  26  * http://www.ivtvdriver.org
  27  *
  28  * -----
  29  * MPG600/MPG160 support by  T.Adachi <tadachi@tadachi-net.com>
  30  *                      and Takeru KOMORIYA<komoriya@paken.org>
  31  *
  32  * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
  33  *                using information provided by Jiun-Kuei Jung @ AVerMedia.
  34  *
  35  * Kurouto Sikou CX23416GYC-STVLP tested by K.Ohta <alpha292@bremen.or.jp>
  36  *                using information from T.Adachi,Takeru KOMORIYA and others :-)
  37  *
  38  * Nagase TRANSGEAR 5000TV, Aopen VA2000MAX-STN6 and I/O data GV-MVP/RX
  39  *                version by T.Adachi. Special thanks  Mr.Suzuki
  40  */
  41
  42 #include "ivtv-driver.h"
  43 #include "ivtv-version.h"
  44 #include "ivtv-fileops.h"
  45 #include "ivtv-i2c.h"
  46 #include "ivtv-firmware.h"
  47 #include "ivtv-queue.h"
  48 #include "ivtv-udma.h"
  49 #include "ivtv-irq.h"
  50 #include "ivtv-mailbox.h"
  51 #include "ivtv-streams.h"
  52 #include "ivtv-ioctl.h"
  53 #include "ivtv-cards.h"
  54 #include "ivtv-vbi.h"
  55 #include "ivtv-routing.h"
  56 #include "ivtv-gpio.h"
  57
  58 #include <media/tveeprom.h>
  59 #include <media/saa7115.h>
  60 #include <media/v4l2-chip-ident.h>
  61 #include "tuner-xc2028.h"
  62
  63 /* var to keep track of the number of array elements in use */
  64 int ivtv_cards_active = 0;
  65
  66 /* If you have already X v4l cards, then set this to X. This way
  67    the device numbers stay matched. Example: you have a WinTV card
  68    without radio and a PVR-350 with. Normally this would give a
  69    video1 device together with a radio0 device for the PVR. By
  70    setting this to 1 you ensure that radio0 is now also radio1. */
  71 int ivtv_first_minor = 0;
  72
  73 /* Master variable for all ivtv info */
  74 struct ivtv *ivtv_cards[IVTV_MAX_CARDS];
  75
  76 /* Protects ivtv_cards_active */
  77 DEFINE_SPINLOCK(ivtv_cards_lock);
  78
  79 /* add your revision and whatnot here */
  80 static struct pci_device_id ivtv_pci_tbl[] __devinitdata = {
  81         {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV15,
  82          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  83         {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV16,
  84          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  85         {0,}
  86 };
  87
  88 MODULE_DEVICE_TABLE(pci,ivtv_pci_tbl);
  89
  90 /* Parameter declarations */
  91 static int cardtype[IVTV_MAX_CARDS];
  92 static int tuner[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  93                                      -1, -1, -1, -1, -1, -1, -1, -1,
  94                                      -1, -1, -1, -1, -1, -1, -1, -1,
  95                                      -1, -1, -1, -1, -1, -1, -1, -1 };
  96 static int radio[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  97                                      -1, -1, -1, -1, -1, -1, -1, -1,
  98                                      -1, -1, -1, -1, -1, -1, -1, -1,
  99                                      -1, -1, -1, -1, -1, -1, -1, -1 };
 100
 101 static unsigned int cardtype_c = 1;
 102 static unsigned int tuner_c = 1;
 103 static unsigned int radio_c = 1;
 104 static char pal[] = "---";
 105 static char secam[] = "--";
 106 static char ntsc[] = "-";
 107
 108 /* Buffers */
 109
 110 /* DMA Buffers, Default size in MB allocated */
 111 #define IVTV_DEFAULT_ENC_MPG_BUFFERS 4
 112 #define IVTV_DEFAULT_ENC_YUV_BUFFERS 2
 113 #define IVTV_DEFAULT_ENC_VBI_BUFFERS 1
 114 /* Exception: size in kB for this stream (MB is overkill) */
 115 #define IVTV_DEFAULT_ENC_PCM_BUFFERS 320
 116 #define IVTV_DEFAULT_DEC_MPG_BUFFERS 1
 117 #define IVTV_DEFAULT_DEC_YUV_BUFFERS 1
 118 /* Exception: size in kB for this stream (MB is way overkill) */
 119 #define IVTV_DEFAULT_DEC_VBI_BUFFERS 64
 120
 121 static int enc_mpg_buffers = IVTV_DEFAULT_ENC_MPG_BUFFERS;
 122 static int enc_yuv_buffers = IVTV_DEFAULT_ENC_YUV_BUFFERS;
 123 static int enc_vbi_buffers = IVTV_DEFAULT_ENC_VBI_BUFFERS;
 124 static int enc_pcm_buffers = IVTV_DEFAULT_ENC_PCM_BUFFERS;
 125 static int dec_mpg_buffers = IVTV_DEFAULT_DEC_MPG_BUFFERS;
 126 static int dec_yuv_buffers = IVTV_DEFAULT_DEC_YUV_BUFFERS;
 127 static int dec_vbi_buffers = IVTV_DEFAULT_DEC_VBI_BUFFERS;
 128
 129 static int ivtv_yuv_mode;
 130 static int ivtv_yuv_threshold = -1;
 131 static int ivtv_pci_latency = 1;
 132
 133 int ivtv_debug;
 134
 135 static int tunertype = -1;
 136 static int newi2c = -1;
 137
 138 module_param_array(tuner, int, &tuner_c, 0644);
 139 module_param_array(radio, bool, &radio_c, 0644);
 140 module_param_array(cardtype, int, &cardtype_c, 0644);
 141 module_param_string(pal, pal, sizeof(pal), 0644);
 142 module_param_string(secam, secam, sizeof(secam), 0644);
 143 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
 144 module_param_named(debug,ivtv_debug, int, 0644);
 145 module_param(ivtv_pci_latency, int, 0644);
 146 module_param(ivtv_yuv_mode, int, 0644);
 147 module_param(ivtv_yuv_threshold, int, 0644);
 148 module_param(ivtv_first_minor, int, 0644);
 149
 150 module_param(enc_mpg_buffers, int, 0644);
 151 module_param(enc_yuv_buffers, int, 0644);
 152 module_param(enc_vbi_buffers, int, 0644);
 153 module_param(enc_pcm_buffers, int, 0644);
 154 module_param(dec_mpg_buffers, int, 0644);
 155 module_param(dec_yuv_buffers, int, 0644);
 156 module_param(dec_vbi_buffers, int, 0644);
 157
 158 module_param(tunertype, int, 0644);
 159 module_param(newi2c, int, 0644);
 160
 161 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
 162                         "\t\t\tsee tuner.h for values");
 163 MODULE_PARM_DESC(radio,
 164                  "Enable or disable the radio. Use only if autodetection\n"
 165                  "\t\t\tfails. 0 = disable, 1 = enable");
 166 MODULE_PARM_DESC(cardtype,
 167                  "Only use this option if your card is not detected properly.\n"
 168                  "\t\tSpecify card type:\n"
 169                  "\t\t\t 1 = WinTV PVR 250\n"
 170                  "\t\t\t 2 = WinTV PVR 350\n"
 171                  "\t\t\t 3 = WinTV PVR-150 or PVR-500\n"
 172                  "\t\t\t 4 = AVerMedia M179\n"
 173                  "\t\t\t 5 = YUAN MPG600/Kuroutoshikou iTVC16-STVLP\n"
 174                  "\t\t\t 6 = YUAN MPG160/Kuroutoshikou iTVC15-STVLP\n"
 175                  "\t\t\t 7 = YUAN PG600/DIAMONDMM PVR-550 (CX Falcon 2)\n"
 176                  "\t\t\t 8 = Adaptec AVC-2410\n"
 177                  "\t\t\t 9 = Adaptec AVC-2010\n"
 178                  "\t\t\t10 = NAGASE TRANSGEAR 5000TV\n"
 179                  "\t\t\t11 = AOpen VA2000MAX-STN6\n"
 180                  "\t\t\t12 = YUAN MPG600GR/Kuroutoshikou CX23416GYC-STVLP\n"
 181                  "\t\t\t13 = I/O Data GV-MVP/RX\n"
 182                  "\t\t\t14 = I/O Data GV-MVP/RX2E\n"
 183                  "\t\t\t15 = GOTVIEW PCI DVD\n"
 184                  "\t\t\t16 = GOTVIEW PCI DVD2 Deluxe\n"
 185                  "\t\t\t17 = Yuan MPC622\n"
 186                  "\t\t\t18 = Digital Cowboy DCT-MTVP1\n"
 187                  "\t\t\t19 = Yuan PG600V2/GotView PCI DVD Lite\n"
 188                  "\t\t\t20 = Club3D ZAP-TV1x01\n"
 189                  "\t\t\t21 = AverTV MCE 116 Plus\n"
 190                  "\t\t\t22 = ASUS Falcon2\n"
 191                  "\t\t\t23 = AverMedia PVR-150 Plus\n"
 192                  "\t\t\t24 = AverMedia EZMaker PCI Deluxe\n"
 193                  "\t\t\t25 = AverMedia M104 (not yet working)\n"
 194                  "\t\t\t26 = Buffalo PC-MV5L/PCI\n"
 195                  "\t\t\t 0 = Autodetect (default)\n"
 196                  "\t\t\t-1 = Ignore this card\n\t\t");
 197 MODULE_PARM_DESC(pal, "Set PAL standard: BGH, DK, I, M, N, Nc, 60");
 198 MODULE_PARM_DESC(secam, "Set SECAM standard: BGH, DK, L, LC");
 199 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J (Japan), K (South Korea)");
 200 MODULE_PARM_DESC(tunertype,
 201                 "Specify tuner type:\n"
 202                 "\t\t\t 0 = tuner for PAL-B/G/H/D/K/I, SECAM-B/G/H/D/K/L/Lc\n"
 203                 "\t\t\t 1 = tuner for NTSC-M/J/K, PAL-M/N/Nc\n"
 204                 "\t\t\t-1 = Autodetect (default)\n");
 205 MODULE_PARM_DESC(debug,
 206                  "Debug level (bitmask). Default: 0\n"
 207                  "\t\t\t   1/0x0001: warning\n"
 208                  "\t\t\t   2/0x0002: info\n"
 209                  "\t\t\t   4/0x0004: mailbox\n"
 210                  "\t\t\t   8/0x0008: ioctl\n"
 211                  "\t\t\t  16/0x0010: file\n"
 212                  "\t\t\t  32/0x0020: dma\n"
 213                  "\t\t\t  64/0x0040: irq\n"
 214                  "\t\t\t 128/0x0080: decoder\n"
 215                  "\t\t\t 256/0x0100: yuv\n"
 216                  "\t\t\t 512/0x0200: i2c\n"
 217                  "\t\t\t1024/0x0400: high volume\n");
 218 MODULE_PARM_DESC(ivtv_pci_latency,
 219                  "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
 220                  "\t\t\tDefault: Yes");
 221 MODULE_PARM_DESC(ivtv_yuv_mode,
 222                  "Specify the yuv playback mode:\n"
 223                  "\t\t\t0 = interlaced\n\t\t\t1 = progressive\n\t\t\t2 = auto\n"
 224                  "\t\t\tDefault: 0 (interlaced)");
 225 MODULE_PARM_DESC(ivtv_yuv_threshold,
 226                  "If ivtv_yuv_mode is 2 (auto) then playback content as\n\t\tprogressive if src height <= ivtv_yuvthreshold\n"
 227                  "\t\t\tDefault: 480");;
 228 MODULE_PARM_DESC(enc_mpg_buffers,
 229                  "Encoder MPG Buffers (in MB)\n"
 230                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS));
 231 MODULE_PARM_DESC(enc_yuv_buffers,
 232                  "Encoder YUV Buffers (in MB)\n"
 233                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_YUV_BUFFERS));
 234 MODULE_PARM_DESC(enc_vbi_buffers,
 235                  "Encoder VBI Buffers (in MB)\n"
 236                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_VBI_BUFFERS));
 237 MODULE_PARM_DESC(enc_pcm_buffers,
 238                  "Encoder PCM buffers (in kB)\n"
 239                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_PCM_BUFFERS));
 240 MODULE_PARM_DESC(dec_mpg_buffers,
 241                  "Decoder MPG buffers (in MB)\n"
 242                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_MPG_BUFFERS));
 243 MODULE_PARM_DESC(dec_yuv_buffers,
 244                  "Decoder YUV buffers (in MB)\n"
 245                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_YUV_BUFFERS));
 246 MODULE_PARM_DESC(dec_vbi_buffers,
 247                  "Decoder VBI buffers (in kB)\n"
 248                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_VBI_BUFFERS));
 249 MODULE_PARM_DESC(newi2c,
 250                  "Use new I2C implementation\n"
 251                  "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
 252                  "\t\t\tDefault is autodetect");
 253
 254 MODULE_PARM_DESC(ivtv_first_minor, "Set minor assigned to first card");
 255
 256 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
 257 MODULE_DESCRIPTION("CX23415/CX23416 driver");
 258 MODULE_SUPPORTED_DEVICE
 259     ("CX23415/CX23416 MPEG2 encoder (WinTV PVR-150/250/350/500,\n"
 260                 "\t\t\tYuan MPG series and similar)");
 261 MODULE_LICENSE("GPL");
 262
 263 MODULE_VERSION(IVTV_VERSION);
 264
 265 void ivtv_clear_irq_mask(struct ivtv *itv, u32 mask)
 266 {
 267         itv->irqmask &= ~mask;
 268         write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
 269 }
 270
 271 void ivtv_set_irq_mask(struct ivtv *itv, u32 mask)
 272 {
 273         itv->irqmask |= mask;
 274         write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
 275 }
 276
 277 int ivtv_set_output_mode(struct ivtv *itv, int mode)
 278 {
 279     int old_mode;
 280
 281     spin_lock(&itv->lock);
 282     old_mode = itv->output_mode;
 283     if (old_mode == 0)
 284         itv->output_mode = old_mode = mode;
 285     spin_unlock(&itv->lock);
 286     return old_mode;
 287 }
 288
 289 struct ivtv_stream *ivtv_get_output_stream(struct ivtv *itv)
 290 {
 291         switch (itv->output_mode) {
 292         case OUT_MPG:
 293                 return &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 294         case OUT_YUV:
 295                 return &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 296         default:
 297                 return NULL;
 298         }
 299 }
 300
 301 int ivtv_waitq(wait_queue_head_t *waitq)
 302 {
 303         DEFINE_WAIT(wait);
 304
 305         prepare_to_wait(waitq, &wait, TASK_INTERRUPTIBLE);
 306         schedule();
 307         finish_wait(waitq, &wait);
 308         return signal_pending(current) ? -EINTR : 0;
 309 }
 310
 311 /* Generic utility functions */
 312 int ivtv_msleep_timeout(unsigned int msecs, int intr)
 313 {
 314         int ret;
 315         int timeout = msecs_to_jiffies(msecs);
 316
 317         do {
 318                 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
 319                 timeout = schedule_timeout(timeout);
 320                 if (intr && (ret = signal_pending(current)))
 321                         return ret;
 322         } while (timeout);
 323         return 0;
 324 }
 325
 326 /* Release ioremapped memory */
 327 static void ivtv_iounmap(struct ivtv *itv)
 328 {
 329         if (itv == NULL)
 330                 return;
 331
 332         /* Release registers memory */
 333         if (itv->reg_mem != NULL) {
 334                 IVTV_DEBUG_INFO("releasing reg_mem\n");
 335                 iounmap(itv->reg_mem);
 336                 itv->reg_mem = NULL;
 337         }
 338         /* Release io memory */
 339         if (itv->has_cx23415 && itv->dec_mem != NULL) {
 340                 IVTV_DEBUG_INFO("releasing dec_mem\n");
 341                 iounmap(itv->dec_mem);
 342         }
 343         itv->dec_mem = NULL;
 344
 345         /* Release io memory */
 346         if (itv->enc_mem != NULL) {
 347                 IVTV_DEBUG_INFO("releasing enc_mem\n");
 348                 iounmap(itv->enc_mem);
 349                 itv->enc_mem = NULL;
 350         }
 351 }
 352
 353 /* Hauppauge card? get values from tveeprom */
 354 void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv)
 355 {
 356         u8 eedata[256];
 357
 358         itv->i2c_client.addr = 0xA0 >> 1;
 359         tveeprom_read(&itv->i2c_client, eedata, sizeof(eedata));
 360         tveeprom_hauppauge_analog(&itv->i2c_client, tv, eedata);
 361 }
 362
 363 static void ivtv_process_eeprom(struct ivtv *itv)
 364 {
 365         struct tveeprom tv;
 366         int pci_slot = PCI_SLOT(itv->dev->devfn);
 367
 368         ivtv_read_eeprom(itv, &tv);
 369
 370         /* Many thanks to Steven Toth from Hauppauge for providing the
 371            model numbers */
 372         switch (tv.model) {
 373                 /* In a few cases the PCI subsystem IDs do not correctly
 374                    identify the card. A better method is to check the
 375                    model number from the eeprom instead. */
 376                 case 30012 ... 30039:  /* Low profile PVR250 */
 377                 case 32000 ... 32999:
 378                 case 48000 ... 48099:  /* 48??? range are PVR250s with a cx23415 */
 379                 case 48400 ... 48599:
 380                         itv->card = ivtv_get_card(IVTV_CARD_PVR_250);
 381                         break;
 382                 case 48100 ... 48399:
 383                 case 48600 ... 48999:
 384                         itv->card = ivtv_get_card(IVTV_CARD_PVR_350);
 385                         break;
 386                 case 23000 ... 23999:  /* PVR500 */
 387                 case 25000 ... 25999:  /* Low profile PVR150 */
 388                 case 26000 ... 26999:  /* Regular PVR150 */
 389                         itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 390                         break;
 391                 case 0:
 392                         IVTV_ERR("Invalid EEPROM\n");
 393                         return;
 394                 default:
 395                         IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv.model);
 396                         itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 397                         break;
 398         }
 399
 400         switch (tv.model) {
 401                 /* Old style PVR350 (with an saa7114) uses this input for
 402                    the tuner. */
 403                 case 48254:
 404                         itv->card = ivtv_get_card(IVTV_CARD_PVR_350_V1);
 405                         break;
 406                 default:
 407                         break;
 408         }
 409
 410         itv->v4l2_cap = itv->card->v4l2_capabilities;
 411         itv->card_name = itv->card->name;
 412         itv->card_i2c = itv->card->i2c;
 413
 414         /* If this is a PVR500 then it should be possible to detect whether it is the
 415            first or second unit by looking at the subsystem device ID: is bit 4 is
 416            set, then it is the second unit (according to info from Hauppauge).
 417
 418            However, while this works for most cards, I have seen a few PVR500 cards
 419            where both units have the same subsystem ID.
 420
 421            So instead I look at the reported 'PCI slot' (which is the slot on the PVR500
 422            PCI bridge) and if it is 8, then it is assumed to be the first unit, otherwise
 423            it is the second unit. It is possible that it is a different slot when ivtv is
 424            used in Xen, in that case I ignore this card here. The worst that can happen
 425            is that the card presents itself with a non-working radio device.
 426
 427            This detection is needed since the eeprom reports incorrectly that a radio is
 428            present on the second unit. */
 429         if (tv.model / 1000 == 23) {
 430                 static const struct ivtv_card_tuner_i2c ivtv_i2c_radio = {
 431                         .radio = { 0x60, I2C_CLIENT_END },
 432                         .demod = { 0x43, I2C_CLIENT_END },
 433                         .tv = { 0x61, I2C_CLIENT_END },
 434                 };
 435
 436                 itv->card_name = "WinTV PVR 500";
 437                 itv->card_i2c = &ivtv_i2c_radio;
 438                 if (pci_slot == 8 || pci_slot == 9) {
 439                         int is_first = (pci_slot & 1) == 0;
 440
 441                         itv->card_name = is_first ? "WinTV PVR 500 (unit #1)" :
 442                                                     "WinTV PVR 500 (unit #2)";
 443                         if (!is_first) {
 444                                 IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
 445                                 tv.has_radio = 0;
 446                         }
 447                 }
 448         }
 449         IVTV_INFO("Autodetected %s\n", itv->card_name);
 450
 451         switch (tv.tuner_hauppauge_model) {
 452                 case 85:
 453                 case 99:
 454                 case 112:
 455                         itv->pvr150_workaround = 1;
 456                         break;
 457                 default:
 458                         break;
 459         }
 460         if (tv.tuner_type == TUNER_ABSENT)
 461                 IVTV_ERR("tveeprom cannot autodetect tuner!");
 462
 463         if (itv->options.tuner == -1)
 464                 itv->options.tuner = tv.tuner_type;
 465         if (itv->options.radio == -1)
 466                 itv->options.radio = (tv.has_radio != 0);
 467         /* only enable newi2c if an IR blaster is present */
 468         /* FIXME: for 2.6.20 the test against 2 should be removed */
 469         if (itv->options.newi2c == -1 && tv.has_ir != -1 && tv.has_ir != 2) {
 470                 itv->options.newi2c = (tv.has_ir & 2) ? 1 : 0;
 471                 if (itv->options.newi2c) {
 472                     IVTV_INFO("Reopen i2c bus for IR-blaster support\n");
 473                     exit_ivtv_i2c(itv);
 474                     init_ivtv_i2c(itv);
 475                 }
 476         }
 477
 478         if (itv->std != 0)
 479                 /* user specified tuner standard */
 480                 return;
 481
 482         /* autodetect tuner standard */
 483         if (tv.tuner_formats & V4L2_STD_PAL) {
 484                 IVTV_DEBUG_INFO("PAL tuner detected\n");
 485                 itv->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 486         } else if (tv.tuner_formats & V4L2_STD_NTSC) {
 487                 IVTV_DEBUG_INFO("NTSC tuner detected\n");
 488                 itv->std |= V4L2_STD_NTSC_M;
 489         } else if (tv.tuner_formats & V4L2_STD_SECAM) {
 490                 IVTV_DEBUG_INFO("SECAM tuner detected\n");
 491                 itv->std |= V4L2_STD_SECAM_L;
 492         } else {
 493                 IVTV_INFO("No tuner detected, default to NTSC-M\n");
 494                 itv->std |= V4L2_STD_NTSC_M;
 495         }
 496 }
 497
 498 static v4l2_std_id ivtv_parse_std(struct ivtv *itv)
 499 {
 500         switch (pal[0]) {
 501                 case '6':
 502                         tunertype = 0;
 503                         return V4L2_STD_PAL_60;
 504                 case 'b':
 505                 case 'B':
 506                 case 'g':
 507                 case 'G':
 508                 case 'h':
 509                 case 'H':
 510                         tunertype = 0;
 511                         return V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 512                 case 'n':
 513                 case 'N':
 514                         tunertype = 1;
 515                         if (pal[1] == 'c' || pal[1] == 'C')
 516                                 return V4L2_STD_PAL_Nc;
 517                         return V4L2_STD_PAL_N;
 518                 case 'i':
 519                 case 'I':
 520                         tunertype = 0;
 521                         return V4L2_STD_PAL_I;
 522                 case 'd':
 523                 case 'D':
 524                 case 'k':
 525                 case 'K':
 526                         tunertype = 0;
 527                         return V4L2_STD_PAL_DK;
 528                 case 'M':
 529                 case 'm':
 530                         tunertype = 1;
 531                         return V4L2_STD_PAL_M;
 532                 case '-':
 533                         break;
 534                 default:
 535                         IVTV_WARN("pal= argument not recognised\n");
 536                         return 0;
 537         }
 538
 539         switch (secam[0]) {
 540                 case 'b':
 541                 case 'B':
 542                 case 'g':
 543                 case 'G':
 544                 case 'h':
 545                 case 'H':
 546                         tunertype = 0;
 547                         return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 548                 case 'd':
 549                 case 'D':
 550                 case 'k':
 551                 case 'K':
 552                         tunertype = 0;
 553                         return V4L2_STD_SECAM_DK;
 554                 case 'l':
 555                 case 'L':
 556                         tunertype = 0;
 557                         if (secam[1] == 'C' || secam[1] == 'c')
 558                                 return V4L2_STD_SECAM_LC;
 559                         return V4L2_STD_SECAM_L;
 560                 case '-':
 561                         break;
 562                 default:
 563                         IVTV_WARN("secam= argument not recognised\n");
 564                         return 0;
 565         }
 566
 567         switch (ntsc[0]) {
 568                 case 'm':
 569                 case 'M':
 570                         tunertype = 1;
 571                         return V4L2_STD_NTSC_M;
 572                 case 'j':
 573                 case 'J':
 574                         tunertype = 1;
 575                         return V4L2_STD_NTSC_M_JP;
 576                 case 'k':
 577                 case 'K':
 578                         tunertype = 1;
 579                         return V4L2_STD_NTSC_M_KR;
 580                 case '-':
 581                         break;
 582                 default:
 583                         IVTV_WARN("ntsc= argument not recognised\n");
 584                         return 0;
 585         }
 586
 587         /* no match found */
 588         return 0;
 589 }
 590
 591 static void ivtv_process_options(struct ivtv *itv)
 592 {
 593         const char *chipname;
 594         int i, j;
 595
 596         itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers * 1024;
 597         itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers * 1024;
 598         itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers * 1024;
 599         itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
 600         itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_MPG] = dec_mpg_buffers * 1024;
 601         itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_YUV] = dec_yuv_buffers * 1024;
 602         itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_VBI] = dec_vbi_buffers;
 603         itv->options.cardtype = cardtype[itv->num];
 604         itv->options.tuner = tuner[itv->num];
 605         itv->options.radio = radio[itv->num];
 606         itv->options.newi2c = newi2c;
 607         if (tunertype < -1 || tunertype > 1) {
 608                 IVTV_WARN("Invalid tunertype argument, will autodetect instead\n");
 609                 tunertype = -1;
 610         }
 611         itv->std = ivtv_parse_std(itv);
 612         if (itv->std == 0 && tunertype >= 0)
 613                 itv->std = tunertype ? V4L2_STD_MN : (V4L2_STD_ALL & ~V4L2_STD_MN);
 614         itv->has_cx23415 = (itv->dev->device == PCI_DEVICE_ID_IVTV15);
 615         chipname = itv->has_cx23415 ? "cx23415" : "cx23416";
 616         if (itv->options.cardtype == -1) {
 617                 IVTV_INFO("Ignore card (detected %s based chip)\n", chipname);
 618                 return;
 619         }
 620         if ((itv->card = ivtv_get_card(itv->options.cardtype - 1))) {
 621                 IVTV_INFO("User specified %s card (detected %s based chip)\n",
 622                                 itv->card->name, chipname);
 623         } else if (itv->options.cardtype != 0) {
 624                 IVTV_ERR("Unknown user specified type, trying to autodetect card\n");
 625         }
 626         if (itv->card == NULL) {
 627                 if (itv->dev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE ||
 628                     itv->dev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT1 ||
 629                     itv->dev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT2) {
 630                         itv->card = ivtv_get_card(itv->has_cx23415 ? IVTV_CARD_PVR_350 : IVTV_CARD_PVR_150);
 631                         IVTV_INFO("Autodetected Hauppauge card (%s based)\n",
 632                                         chipname);
 633                 }
 634         }
 635         if (itv->card == NULL) {
 636                 for (i = 0; (itv->card = ivtv_get_card(i)); i++) {
 637                         if (itv->card->pci_list == NULL)
 638                                 continue;
 639                         for (j = 0; itv->card->pci_list[j].device; j++) {
 640                                 if (itv->dev->device !=
 641                                     itv->card->pci_list[j].device)
 642                                         continue;
 643                                 if (itv->dev->subsystem_vendor !=
 644                                     itv->card->pci_list[j].subsystem_vendor)
 645                                         continue;
 646                                 if (itv->dev->subsystem_device !=
 647                                     itv->card->pci_list[j].subsystem_device)
 648                                         continue;
 649                                 IVTV_INFO("Autodetected %s card (%s based)\n",
 650                                                 itv->card->name, chipname);
 651                                 goto done;
 652                         }
 653                 }
 654         }
 655 done:
 656
 657         if (itv->card == NULL) {
 658                 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 659                 IVTV_ERR("Unknown card: vendor/device: %04x/%04x\n",
 660                      itv->dev->vendor, itv->dev->device);
 661                 IVTV_ERR("              subsystem vendor/device: %04x/%04x\n",
 662                      itv->dev->subsystem_vendor, itv->dev->subsystem_device);
 663                 IVTV_ERR("              %s based\n", chipname);
 664                 IVTV_ERR("Defaulting to %s card\n", itv->card->name);
 665                 IVTV_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
 666                 IVTV_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
 667                 IVTV_ERR("Prefix your subject line with [UNKNOWN IVTV CARD].\n");
 668         }
 669         itv->v4l2_cap = itv->card->v4l2_capabilities;
 670         itv->card_name = itv->card->name;
 671         itv->card_i2c = itv->card->i2c;
 672 }
 673
 674 /* Precondition: the ivtv structure has been memset to 0. Only
 675    the dev and num fields have been filled in.
 676    No assumptions on the card type may be made here (see ivtv_init_struct2
 677    for that).
 678  */
 679 static int __devinit ivtv_init_struct1(struct ivtv *itv)
 680 {
 681         itv->base_addr = pci_resource_start(itv->dev, 0);
 682         itv->enc_mbox.max_mbox = 2; /* the encoder has 3 mailboxes (0-2) */
 683         itv->dec_mbox.max_mbox = 1; /* the decoder has 2 mailboxes (0-1) */
 684
 685         mutex_init(&itv->serialize_lock);
 686         mutex_init(&itv->i2c_bus_lock);
 687         mutex_init(&itv->udma.lock);
 688
 689         spin_lock_init(&itv->lock);
 690         spin_lock_init(&itv->dma_reg_lock);
 691
 692         itv->irq_work_queues = create_workqueue(itv->name);
 693         if (itv->irq_work_queues == NULL) {
 694                 IVTV_ERR("Could not create ivtv workqueue\n");
 695                 return -1;
 696         }
 697
 698         INIT_WORK(&itv->irq_work_queue, ivtv_irq_work_handler);
 699
 700         /* start counting open_id at 1 */
 701         itv->open_id = 1;
 702
 703         /* Initial settings */
 704         cx2341x_fill_defaults(&itv->params);
 705         itv->params.port = CX2341X_PORT_MEMORY;
 706         itv->params.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
 707         init_waitqueue_head(&itv->eos_waitq);
 708         init_waitqueue_head(&itv->event_waitq);
 709         init_waitqueue_head(&itv->vsync_waitq);
 710         init_waitqueue_head(&itv->dma_waitq);
 711         init_timer(&itv->dma_timer);
 712         itv->dma_timer.function = ivtv_unfinished_dma;
 713         itv->dma_timer.data = (unsigned long)itv;
 714
 715         itv->cur_dma_stream = -1;
 716         itv->cur_pio_stream = -1;
 717         itv->audio_stereo_mode = AUDIO_STEREO;
 718         itv->audio_bilingual_mode = AUDIO_MONO_LEFT;
 719
 720         /* Ctrls */
 721         itv->speed = 1000;
 722
 723         /* VBI */
 724         itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
 725         itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
 726
 727         /* Init the sg table for osd/yuv output */
 728         sg_init_table(itv->udma.SGlist, IVTV_DMA_SG_OSD_ENT);
 729
 730         /* OSD */
 731         itv->osd_global_alpha_state = 1;
 732         itv->osd_global_alpha = 255;
 733
 734         /* YUV */
 735         atomic_set(&itv->yuv_info.next_dma_frame, -1);
 736         itv->yuv_info.lace_mode = ivtv_yuv_mode;
 737         itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
 738         itv->yuv_info.max_frames_buffered = 3;
 739         itv->yuv_info.track_osd = 1;
 740         return 0;
 741 }
 742
 743 /* Second initialization part. Here the card type has been
 744    autodetected. */
 745 static void __devinit ivtv_init_struct2(struct ivtv *itv)
 746 {
 747         int i;
 748
 749         for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
 750                 if (itv->card->video_inputs[i].video_type == 0)
 751                         break;
 752         itv->nof_inputs = i;
 753         for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
 754                 if (itv->card->audio_inputs[i].audio_type == 0)
 755                         break;
 756         itv->nof_audio_inputs = i;
 757
 758         if (itv->card->hw_all & IVTV_HW_CX25840) {
 759                 itv->vbi.sliced_size = 288;  /* multiple of 16, real size = 284 */
 760         } else {
 761                 itv->vbi.sliced_size = 64;   /* multiple of 16, real size = 52 */
 762         }
 763
 764         /* Find tuner input */
 765         for (i = 0; i < itv->nof_inputs; i++) {
 766                 if (itv->card->video_inputs[i].video_type ==
 767                                 IVTV_CARD_INPUT_VID_TUNER)
 768                         break;
 769         }
 770         if (i == itv->nof_inputs)
 771                 i = 0;
 772         itv->active_input = i;
 773         itv->audio_input = itv->card->video_inputs[i].audio_index;
 774         if (itv->card->hw_all & IVTV_HW_CX25840)
 775                 itv->video_dec_func = ivtv_cx25840;
 776         else if (itv->card->hw_all & IVTV_HW_SAA717X)
 777                 itv->video_dec_func = ivtv_saa717x;
 778         else
 779                 itv->video_dec_func = ivtv_saa7115;
 780 }
 781
 782 static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *dev,
 783                           const struct pci_device_id *pci_id)
 784 {
 785         u16 cmd;
 786         u8 card_rev;
 787         unsigned char pci_latency;
 788
 789         IVTV_DEBUG_INFO("Enabling pci device\n");
 790
 791         if (pci_enable_device(dev)) {
 792                 IVTV_ERR("Can't enable device %d!\n", itv->num);
 793                 return -EIO;
 794         }
 795         if (pci_set_dma_mask(dev, 0xffffffff)) {
 796                 IVTV_ERR("No suitable DMA available on card %d.\n", itv->num);
 797                 return -EIO;
 798         }
 799         if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
 800                 IVTV_ERR("Cannot request encoder memory region on card %d.\n", itv->num);
 801                 return -EIO;
 802         }
 803
 804         if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
 805                                 IVTV_REG_SIZE, "ivtv registers")) {
 806                 IVTV_ERR("Cannot request register memory region on card %d.\n", itv->num);
 807                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 808                 return -EIO;
 809         }
 810
 811         if (itv->has_cx23415 &&
 812             !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
 813                                 IVTV_DECODER_SIZE, "ivtv decoder")) {
 814                 IVTV_ERR("Cannot request decoder memory region on card %d.\n", itv->num);
 815                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 816                 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
 817                 return -EIO;
 818         }
 819
 820         /* Check for bus mastering */
 821         pci_read_config_word(dev, PCI_COMMAND, &cmd);
 822         if (!(cmd & PCI_COMMAND_MASTER)) {
 823                 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
 824                 pci_set_master(dev);
 825                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
 826                 if (!(cmd & PCI_COMMAND_MASTER)) {
 827                         IVTV_ERR("Bus Mastering is not enabled\n");
 828                         return -ENXIO;
 829                 }
 830         }
 831         IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
 832
 833         pci_read_config_byte(dev, PCI_CLASS_REVISION, &card_rev);
 834         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 835
 836         if (pci_latency < 64 && ivtv_pci_latency) {
 837                 IVTV_INFO("Unreasonably low latency timer, "
 838                                "setting to 64 (was %d)\n", pci_latency);
 839                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
 840                 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 841         }
 842         /* This config space value relates to DMA latencies. The
 843            default value 0x8080 is too low however and will lead
 844            to DMA errors. 0xffff is the max value which solves
 845            these problems. */
 846         pci_write_config_dword(dev, 0x40, 0xffff);
 847
 848         IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
 849                    "irq: %d, latency: %d, memory: 0x%lx\n",
 850                    itv->dev->device, card_rev, dev->bus->number,
 851                    PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
 852                    itv->dev->irq, pci_latency, (unsigned long)itv->base_addr);
 853
 854         return 0;
 855 }
 856
 857 #ifdef MODULE
 858 static u32 ivtv_request_module(struct ivtv *itv, u32 hw,
 859                 const char *name, u32 id)
 860 {
 861         if ((hw & id) == 0)
 862                 return hw;
 863         if (request_module(name) != 0) {
 864                 IVTV_ERR("Failed to load module %s\n", name);
 865                 return hw & ~id;
 866         }
 867         IVTV_DEBUG_INFO("Loaded module %s\n", name);
 868         return hw;
 869 }
 870 #endif
 871
 872 static void ivtv_load_and_init_modules(struct ivtv *itv)
 873 {
 874         u32 hw = itv->card->hw_all;
 875         unsigned i;
 876
 877 #ifdef MODULE
 878         /* load modules */
 879 #ifndef CONFIG_MEDIA_TUNER
 880         hw = ivtv_request_module(itv, hw, "tuner", IVTV_HW_TUNER);
 881 #endif
 882 #ifndef CONFIG_VIDEO_CX25840
 883         hw = ivtv_request_module(itv, hw, "cx25840", IVTV_HW_CX25840);
 884 #endif
 885 #ifndef CONFIG_VIDEO_SAA711X
 886         hw = ivtv_request_module(itv, hw, "saa7115", IVTV_HW_SAA711X);
 887 #endif
 888 #ifndef CONFIG_VIDEO_SAA7127
 889         hw = ivtv_request_module(itv, hw, "saa7127", IVTV_HW_SAA7127);
 890 #endif
 891 #ifndef CONFIG_VIDEO_SAA717X
 892         hw = ivtv_request_module(itv, hw, "saa717x", IVTV_HW_SAA717X);
 893 #endif
 894 #ifndef CONFIG_VIDEO_UPD64031A
 895         hw = ivtv_request_module(itv, hw, "upd64031a", IVTV_HW_UPD64031A);
 896 #endif
 897 #ifndef CONFIG_VIDEO_UPD64083
 898         hw = ivtv_request_module(itv, hw, "upd64083", IVTV_HW_UPD6408X);
 899 #endif
 900 #ifndef CONFIG_VIDEO_MSP3400
 901         hw = ivtv_request_module(itv, hw, "msp3400", IVTV_HW_MSP34XX);
 902 #endif
 903 #ifndef CONFIG_VIDEO_VP27SMPX
 904         hw = ivtv_request_module(itv, hw, "vp27smpx", IVTV_HW_VP27SMPX);
 905 #endif
 906 #ifndef CONFIG_VIDEO_WM8775
 907         hw = ivtv_request_module(itv, hw, "wm8775", IVTV_HW_WM8775);
 908 #endif
 909 #ifndef CONFIG_VIDEO_WM8739
 910         hw = ivtv_request_module(itv, hw, "wm8739", IVTV_HW_WM8739);
 911 #endif
 912 #ifndef CONFIG_VIDEO_CS53L32A
 913         hw = ivtv_request_module(itv, hw, "cs53l32a", IVTV_HW_CS53L32A);
 914 #endif
 915 #ifndef CONFIG_VIDEO_M52790
 916         hw = ivtv_request_module(itv, hw, "m52790", IVTV_HW_M52790);
 917 #endif
 918 #endif
 919
 920         /* check which i2c devices are actually found */
 921         for (i = 0; i < 32; i++) {
 922                 u32 device = 1 << i;
 923
 924                 if (!(device & hw))
 925                         continue;
 926                 if (device == IVTV_HW_GPIO || device == IVTV_HW_TVEEPROM) {
 927                         /* GPIO and TVEEPROM do not use i2c probing */
 928                         itv->hw_flags |= device;
 929                         continue;
 930                 }
 931                 ivtv_i2c_register(itv, i);
 932                 if (ivtv_i2c_hw_addr(itv, device) > 0)
 933                         itv->hw_flags |= device;
 934         }
 935
 936         hw = itv->hw_flags;
 937
 938         if (itv->card->type == IVTV_CARD_CX23416GYC) {
 939                 /* Several variations of this card exist, detect which card
 940                    type should be used. */
 941                 if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
 942                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
 943                 else if ((hw & IVTV_HW_UPD64031A) == 0)
 944                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
 945         }
 946         else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
 947                  itv->card->type == IVTV_CARD_GV_MVPRX2E) {
 948                 struct v4l2_crystal_freq crystal_freq;
 949
 950                 /* The crystal frequency of GVMVPRX is 24.576MHz */
 951                 crystal_freq.freq = SAA7115_FREQ_24_576_MHZ;
 952                 crystal_freq.flags = SAA7115_FREQ_FL_UCGC;
 953                 itv->video_dec_func(itv, VIDIOC_INT_S_CRYSTAL_FREQ, &crystal_freq);
 954         }
 955
 956         if (hw & IVTV_HW_CX25840) {
 957                 itv->vbi.raw_decoder_line_size = 1444;
 958                 itv->vbi.raw_decoder_sav_odd_field = 0x20;
 959                 itv->vbi.raw_decoder_sav_even_field = 0x60;
 960                 itv->vbi.sliced_decoder_line_size = 272;
 961                 itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
 962                 itv->vbi.sliced_decoder_sav_even_field = 0xF0;
 963         }
 964
 965         if (hw & IVTV_HW_SAA711X) {
 966                 struct v4l2_chip_ident v = { V4L2_CHIP_MATCH_I2C_DRIVER, I2C_DRIVERID_SAA711X };
 967
 968                 /* determine the exact saa711x model */
 969                 itv->hw_flags &= ~IVTV_HW_SAA711X;
 970
 971                 ivtv_saa7115(itv, VIDIOC_G_CHIP_IDENT, &v);
 972                 if (v.ident == V4L2_IDENT_SAA7114) {
 973                         itv->hw_flags |= IVTV_HW_SAA7114;
 974                         /* VBI is not yet supported by the saa7114 driver. */
 975                         itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
 976                 }
 977                 else {
 978                         itv->hw_flags |= IVTV_HW_SAA7115;
 979                 }
 980                 itv->vbi.raw_decoder_line_size = 1443;
 981                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 982                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 983                 itv->vbi.sliced_decoder_line_size = 51;
 984                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 985                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 986         }
 987
 988         if (hw & IVTV_HW_SAA717X) {
 989                 itv->vbi.raw_decoder_line_size = 1443;
 990                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 991                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 992                 itv->vbi.sliced_decoder_line_size = 51;
 993                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 994                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 995         }
 996 }
 997
 998 static int __devinit ivtv_probe(struct pci_dev *dev,
 999                                 const struct pci_device_id *pci_id)
1000 {
1001         int retval = 0;
1002         int vbi_buf_size;
1003         struct ivtv *itv;
1004
1005         spin_lock(&ivtv_cards_lock);
1006
1007         /* Make sure we've got a place for this card */
1008         if (ivtv_cards_active == IVTV_MAX_CARDS) {
1009                 printk(KERN_ERR "ivtv:  Maximum number of cards detected (%d)\n",
1010                               ivtv_cards_active);
1011                 spin_unlock(&ivtv_cards_lock);
1012                 return -ENOMEM;
1013         }
1014
1015         itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
1016         if (itv == NULL) {
1017                 spin_unlock(&ivtv_cards_lock);
1018                 return -ENOMEM;
1019         }
1020         ivtv_cards[ivtv_cards_active] = itv;
1021         itv->dev = dev;
1022         itv->num = ivtv_cards_active++;
1023         snprintf(itv->name, sizeof(itv->name), "ivtv%d", itv->num);
1024         IVTV_INFO("Initializing card #%d\n", itv->num);
1025
1026         spin_unlock(&ivtv_cards_lock);
1027
1028         ivtv_process_options(itv);
1029         if (itv->options.cardtype == -1) {
1030                 retval = -ENODEV;
1031                 goto err;
1032         }
1033         if (ivtv_init_struct1(itv)) {
1034                 retval = -ENOMEM;
1035                 goto err;
1036         }
1037
1038         IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv->base_addr);
1039
1040         /* PCI Device Setup */
1041         if ((retval = ivtv_setup_pci(itv, dev, pci_id)) != 0) {
1042                 if (retval == -EIO)
1043                         goto free_workqueue;
1044                 else if (retval == -ENXIO)
1045                         goto free_mem;
1046         }
1047         /* save itv in the pci struct for later use */
1048         pci_set_drvdata(dev, itv);
1049
1050         /* map io memory */
1051         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1052                    itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1053         itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
1054                                        IVTV_ENCODER_SIZE);
1055         if (!itv->enc_mem) {
1056                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1057                 IVTV_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
1058                 retval = -ENOMEM;
1059                 goto free_mem;
1060         }
1061
1062         if (itv->has_cx23415) {
1063                 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1064                                 itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1065                 itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
1066                                 IVTV_DECODER_SIZE);
1067                 if (!itv->dec_mem) {
1068                         IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1069                         IVTV_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
1070                         retval = -ENOMEM;
1071                         goto free_mem;
1072                 }
1073         }
1074         else {
1075                 itv->dec_mem = itv->enc_mem;
1076         }
1077
1078         /* map registers memory */
1079         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1080                    itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1081         itv->reg_mem =
1082             ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1083         if (!itv->reg_mem) {
1084                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1085                 IVTV_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
1086                 retval = -ENOMEM;
1087                 goto free_io;
1088         }
1089
1090         ivtv_gpio_init(itv);
1091
1092         /* active i2c  */
1093         IVTV_DEBUG_INFO("activating i2c...\n");
1094         if (init_ivtv_i2c(itv)) {
1095                 IVTV_ERR("Could not initialize i2c\n");
1096                 goto free_io;
1097         }
1098
1099         IVTV_DEBUG_INFO("Active card count: %d.\n", ivtv_cards_active);
1100
1101         if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1102                 /* Based on the model number the cardtype may be changed.
1103                    The PCI IDs are not always reliable. */
1104                 ivtv_process_eeprom(itv);
1105         }
1106         if (itv->card->comment)
1107                 IVTV_INFO("%s", itv->card->comment);
1108         if (itv->card->v4l2_capabilities == 0) {
1109                 /* card was detected but is not supported */
1110                 retval = -ENODEV;
1111                 goto free_i2c;
1112         }
1113
1114         if (itv->std == 0) {
1115                 itv->std = V4L2_STD_NTSC_M;
1116         }
1117
1118         if (itv->options.tuner == -1) {
1119                 int i;
1120
1121                 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1122                         if ((itv->std & itv->card->tuners[i].std) == 0)
1123                                 continue;
1124                         itv->options.tuner = itv->card->tuners[i].tuner;
1125                         break;
1126                 }
1127         }
1128         /* if no tuner was found, then pick the first tuner in the card list */
1129         if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1130                 itv->std = itv->card->tuners[0].std;
1131                 if (itv->std & V4L2_STD_PAL)
1132                         itv->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1133                 else if (itv->std & V4L2_STD_NTSC)
1134                         itv->std = V4L2_STD_NTSC_M;
1135                 else if (itv->std & V4L2_STD_SECAM)
1136                         itv->std = V4L2_STD_SECAM_L;
1137                 itv->options.tuner = itv->card->tuners[0].tuner;
1138         }
1139         if (itv->options.radio == -1)
1140                 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1141
1142         /* The card is now fully identified, continue with card-specific
1143            initialization. */
1144         ivtv_init_struct2(itv);
1145
1146         ivtv_load_and_init_modules(itv);
1147
1148         if (itv->std & V4L2_STD_525_60) {
1149                 itv->is_60hz = 1;
1150                 itv->is_out_60hz = 1;
1151         } else {
1152                 itv->is_50hz = 1;
1153                 itv->is_out_50hz = 1;
1154         }
1155
1156         itv->yuv_info.osd_full_w = 720;
1157         itv->yuv_info.osd_full_h = itv->is_out_50hz ? 576 : 480;
1158         itv->yuv_info.v4l2_src_w = itv->yuv_info.osd_full_w;
1159         itv->yuv_info.v4l2_src_h = itv->yuv_info.osd_full_h;
1160
1161         itv->params.video_gop_size = itv->is_60hz ? 15 : 12;
1162
1163         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1164         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1165         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1166         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = 0x10000;
1167         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = 0x08000;
1168
1169         /* Setup VBI Raw Size. Should be big enough to hold PAL.
1170            It is possible to switch between PAL and NTSC, so we need to
1171            take the largest size here. */
1172         /* 1456 is multiple of 16, real size = 1444 */
1173         itv->vbi.raw_size = 1456;
1174         /* We use a buffer size of 1/2 of the total size needed for a
1175            frame. This is actually very useful, since we now receive
1176            a field at a time and that makes 'compressing' the raw data
1177            down to size by stripping off the SAV codes a lot easier.
1178            Note: having two different buffer sizes prevents standard
1179            switching on the fly. We need to find a better solution... */
1180         vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1181         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1182         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1183
1184         if (itv->options.radio > 0)
1185                 itv->v4l2_cap |= V4L2_CAP_RADIO;
1186
1187         if (itv->options.tuner > -1) {
1188                 struct tuner_setup setup;
1189
1190                 setup.addr = ADDR_UNSET;
1191                 setup.type = itv->options.tuner;
1192                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1193                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1194                         ivtv_reset_tuner_gpio : NULL;
1195                 ivtv_call_i2c_clients(itv, TUNER_SET_TYPE_ADDR, &setup);
1196                 if (setup.type == TUNER_XC2028) {
1197                         static struct xc2028_ctrl ctrl = {
1198                                 .fname = XC2028_DEFAULT_FIRMWARE,
1199                                 .max_len = 64,
1200                         };
1201                         struct v4l2_priv_tun_config cfg = {
1202                                 .tuner = itv->options.tuner,
1203                                 .priv = &ctrl,
1204                         };
1205                         ivtv_call_i2c_clients(itv, TUNER_SET_CONFIG, &cfg);
1206                 }
1207         }
1208
1209         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1210            are not. */
1211         itv->tuner_std = itv->std;
1212
1213         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1214                 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std);
1215         }
1216
1217         /* clear interrupt mask, effectively disabling interrupts */
1218         ivtv_set_irq_mask(itv, 0xffffffff);
1219
1220         /* Register IRQ */
1221         retval = request_irq(itv->dev->irq, ivtv_irq_handler,
1222                              IRQF_SHARED | IRQF_DISABLED, itv->name, (void *)itv);
1223         if (retval) {
1224                 IVTV_ERR("Failed to register irq %d\n", retval);
1225                 goto free_i2c;
1226         }
1227
1228         retval = ivtv_streams_setup(itv);
1229         if (retval) {
1230                 IVTV_ERR("Error %d setting up streams\n", retval);
1231                 goto free_irq;
1232         }
1233         retval = ivtv_streams_register(itv);
1234         if (retval) {
1235                 IVTV_ERR("Error %d registering devices\n", retval);
1236                 goto free_streams;
1237         }
1238         IVTV_INFO("Initialized card #%d: %s\n", itv->num, itv->card_name);
1239         return 0;
1240
1241 free_streams:
1242         ivtv_streams_cleanup(itv, 1);
1243 free_irq:
1244         free_irq(itv->dev->irq, (void *)itv);
1245 free_i2c:
1246         exit_ivtv_i2c(itv);
1247 free_io:
1248         ivtv_iounmap(itv);
1249 free_mem:
1250         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1251         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1252         if (itv->has_cx23415)
1253                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1254 free_workqueue:
1255         destroy_workqueue(itv->irq_work_queues);
1256 err:
1257         if (retval == 0)
1258                 retval = -ENODEV;
1259         IVTV_ERR("Error %d on initialization\n", retval);
1260
1261         spin_lock(&ivtv_cards_lock);
1262         kfree(ivtv_cards[ivtv_cards_active]);
1263         ivtv_cards[ivtv_cards_active] = NULL;
1264         spin_unlock(&ivtv_cards_lock);
1265         return retval;
1266 }
1267
1268 int ivtv_init_on_first_open(struct ivtv *itv)
1269 {
1270         struct v4l2_frequency vf;
1271         /* Needed to call ioctls later */
1272         struct ivtv_open_id fh;
1273         int fw_retry_count = 3;
1274         int video_input;
1275
1276         fh.itv = itv;
1277
1278         if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1279                 return -ENXIO;
1280
1281         if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1282                 return 0;
1283
1284         while (--fw_retry_count > 0) {
1285                 /* load firmware */
1286                 if (ivtv_firmware_init(itv) == 0)
1287                         break;
1288                 if (fw_retry_count > 1)
1289                         IVTV_WARN("Retry loading firmware\n");
1290         }
1291
1292         if (fw_retry_count == 0) {
1293                 set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1294                 return -ENXIO;
1295         }
1296
1297         /* Try and get firmware versions */
1298         IVTV_DEBUG_INFO("Getting firmware version..\n");
1299         ivtv_firmware_versions(itv);
1300
1301         if (itv->card->hw_all & IVTV_HW_CX25840) {
1302                 struct v4l2_control ctrl;
1303
1304                 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
1305                 ctrl.id = V4L2_CID_PRIVATE_BASE;
1306                 ctrl.value = itv->pvr150_workaround;
1307                 itv->video_dec_func(itv, VIDIOC_S_CTRL, &ctrl);
1308         }
1309
1310         vf.tuner = 0;
1311         vf.type = V4L2_TUNER_ANALOG_TV;
1312         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1313
1314         /* Set initial frequency. For PAL/SECAM broadcasts no
1315            'default' channel exists AFAIK. */
1316         if (itv->std == V4L2_STD_NTSC_M_JP) {
1317                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1318         }
1319         else if (itv->std & V4L2_STD_NTSC_M) {
1320                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1321         }
1322
1323         video_input = itv->active_input;
1324         itv->active_input++;    /* Force update of input */
1325         ivtv_s_input(NULL, &fh, video_input);
1326
1327         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1328            in one place. */
1329         itv->std++;             /* Force full standard initialization */
1330         itv->std_out = itv->std;
1331         ivtv_s_frequency(NULL, &fh, &vf);
1332
1333         if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1334                 ivtv_init_mpeg_decoder(itv);
1335         }
1336         ivtv_s_std(NULL, &fh, &itv->tuner_std);
1337
1338         /* On a cx23416 this seems to be able to enable DMA to the chip? */
1339         if (!itv->has_cx23415)
1340                 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1341
1342         /* Default interrupts enabled. For the PVR350 this includes the
1343            decoder VSYNC interrupt, which is always on. It is not only used
1344            during decoding but also by the OSD.
1345            Some old PVR250 cards had a cx23415, so testing for that is too
1346            general. Instead test if the card has video output capability. */
1347         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1348                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1349                 ivtv_set_osd_alpha(itv);
1350         }
1351         else
1352                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1353         return 0;
1354 }
1355
1356 static void ivtv_remove(struct pci_dev *pci_dev)
1357 {
1358         struct ivtv *itv = pci_get_drvdata(pci_dev);
1359
1360         IVTV_DEBUG_INFO("Removing Card #%d\n", itv->num);
1361
1362         if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1363                 /* Stop all captures */
1364                 IVTV_DEBUG_INFO("Stopping all streams\n");
1365                 if (atomic_read(&itv->capturing) > 0)
1366                         ivtv_stop_all_captures(itv);
1367
1368                 /* Stop all decoding */
1369                 IVTV_DEBUG_INFO("Stopping decoding\n");
1370                 if (atomic_read(&itv->decoding) > 0) {
1371                         int type;
1372
1373                         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1374                                 type = IVTV_DEC_STREAM_TYPE_YUV;
1375                         else
1376                                 type = IVTV_DEC_STREAM_TYPE_MPG;
1377                         ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1378                                 VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1379                 }
1380                 ivtv_halt_firmware(itv);
1381         }
1382
1383         /* Interrupts */
1384         ivtv_set_irq_mask(itv, 0xffffffff);
1385         del_timer_sync(&itv->dma_timer);
1386
1387         /* Stop all Work Queues */
1388         flush_workqueue(itv->irq_work_queues);
1389         destroy_workqueue(itv->irq_work_queues);
1390
1391         ivtv_streams_cleanup(itv, 1);
1392         ivtv_udma_free(itv);
1393
1394         exit_ivtv_i2c(itv);
1395
1396         free_irq(itv->dev->irq, (void *)itv);
1397         ivtv_iounmap(itv);
1398
1399         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1400         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1401         if (itv->has_cx23415)
1402                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1403
1404         pci_disable_device(itv->dev);
1405
1406         IVTV_INFO("Removed %s, card #%d\n", itv->card_name, itv->num);
1407 }
1408
1409 /* define a pci_driver for card detection */
1410 static struct pci_driver ivtv_pci_driver = {
1411       .name =     "ivtv",
1412       .id_table = ivtv_pci_tbl,
1413       .probe =    ivtv_probe,
1414       .remove =   ivtv_remove,
1415 };
1416
1417 static int module_start(void)
1418 {
1419         printk(KERN_INFO "ivtv:  Start initialization, version %s\n", IVTV_VERSION);
1420
1421         memset(ivtv_cards, 0, sizeof(ivtv_cards));
1422
1423         /* Validate parameters */
1424         if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1425                 printk(KERN_ERR "ivtv:  Exiting, ivtv_first_minor must be between 0 and %d\n",
1426                      IVTV_MAX_CARDS - 1);
1427                 return -1;
1428         }
1429
1430         if (ivtv_debug < 0 || ivtv_debug > 2047) {
1431                 ivtv_debug = 0;
1432                 printk(KERN_INFO "ivtv:  Debug value must be >= 0 and <= 2047\n");
1433         }
1434
1435         if (pci_register_driver(&ivtv_pci_driver)) {
1436                 printk(KERN_ERR "ivtv:  Error detecting PCI card\n");
1437                 return -ENODEV;
1438         }
1439         printk(KERN_INFO "ivtv:  End initialization\n");
1440         return 0;
1441 }
1442
1443 static void module_cleanup(void)
1444 {
1445         int i, j;
1446
1447         pci_unregister_driver(&ivtv_pci_driver);
1448
1449         spin_lock(&ivtv_cards_lock);
1450         for (i = 0; i < ivtv_cards_active; i++) {
1451                 if (ivtv_cards[i] == NULL)
1452                         continue;
1453                 for (j = 0; j < IVTV_VBI_FRAMES; j++) {
1454                         kfree(ivtv_cards[i]->vbi.sliced_mpeg_data[j]);
1455                 }
1456                 kfree(ivtv_cards[i]);
1457         }
1458         spin_unlock(&ivtv_cards_lock);
1459 }
1460
1461 /* Note: These symbols are exported because they are used by the ivtvfb
1462    framebuffer module and an infrared module for the IR-blaster. */
1463 EXPORT_SYMBOL(ivtv_set_irq_mask);
1464 EXPORT_SYMBOL(ivtv_cards_active);
1465 EXPORT_SYMBOL(ivtv_cards);
1466 EXPORT_SYMBOL(ivtv_cards_lock);
1467 EXPORT_SYMBOL(ivtv_api);
1468 EXPORT_SYMBOL(ivtv_vapi);
1469 EXPORT_SYMBOL(ivtv_vapi_result);
1470 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1471 EXPORT_SYMBOL(ivtv_debug);
1472 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1473 EXPORT_SYMBOL(ivtv_udma_setup);
1474 EXPORT_SYMBOL(ivtv_udma_unmap);
1475 EXPORT_SYMBOL(ivtv_udma_alloc);
1476 EXPORT_SYMBOL(ivtv_udma_prepare);
1477 EXPORT_SYMBOL(ivtv_init_on_first_open);
1478
1479 module_init(module_start);
1480 module_exit(module_cleanup);