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