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