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