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