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 bool 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         /* Initial settings */
 735         itv->cxhdl.port = CX2341X_PORT_MEMORY;
 736         itv->cxhdl.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
 737         init_waitqueue_head(&itv->eos_waitq);
 738         init_waitqueue_head(&itv->event_waitq);
 739         init_waitqueue_head(&itv->vsync_waitq);
 740         init_waitqueue_head(&itv->dma_waitq);
 741         init_timer(&itv->dma_timer);
 742         itv->dma_timer.function = ivtv_unfinished_dma;
 743         itv->dma_timer.data = (unsigned long)itv;
 744
 745         itv->cur_dma_stream = -1;
 746         itv->cur_pio_stream = -1;
 747         itv->audio_stereo_mode = AUDIO_STEREO;
 748         itv->audio_bilingual_mode = AUDIO_MONO_LEFT;
 749
 750         /* Ctrls */
 751         itv->speed = 1000;
 752
 753         /* VBI */
 754         itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
 755         itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
 756
 757         /* Init the sg table for osd/yuv output */
 758         sg_init_table(itv->udma.SGlist, IVTV_DMA_SG_OSD_ENT);
 759
 760         /* OSD */
 761         itv->osd_global_alpha_state = 1;
 762         itv->osd_global_alpha = 255;
 763
 764         /* YUV */
 765         atomic_set(&itv->yuv_info.next_dma_frame, -1);
 766         itv->yuv_info.lace_mode = ivtv_yuv_mode;
 767         itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
 768         itv->yuv_info.max_frames_buffered = 3;
 769         itv->yuv_info.track_osd = 1;
 770         return 0;
 771 }
 772
 773 /* Second initialization part. Here the card type has been
 774    autodetected. */
 775 static void __devinit ivtv_init_struct2(struct ivtv *itv)
 776 {
 777         int i;
 778
 779         for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
 780                 if (itv->card->video_inputs[i].video_type == 0)
 781                         break;
 782         itv->nof_inputs = i;
 783         for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
 784                 if (itv->card->audio_inputs[i].audio_type == 0)
 785                         break;
 786         itv->nof_audio_inputs = i;
 787
 788         if (itv->card->hw_all & IVTV_HW_CX25840) {
 789                 itv->vbi.sliced_size = 288;  /* multiple of 16, real size = 284 */
 790         } else {
 791                 itv->vbi.sliced_size = 64;   /* multiple of 16, real size = 52 */
 792         }
 793
 794         /* Find tuner input */
 795         for (i = 0; i < itv->nof_inputs; i++) {
 796                 if (itv->card->video_inputs[i].video_type ==
 797                                 IVTV_CARD_INPUT_VID_TUNER)
 798                         break;
 799         }
 800         if (i == itv->nof_inputs)
 801                 i = 0;
 802         itv->active_input = i;
 803         itv->audio_input = itv->card->video_inputs[i].audio_index;
 804 }
 805
 806 static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *pdev,
 807                           const struct pci_device_id *pci_id)
 808 {
 809         u16 cmd;
 810         unsigned char pci_latency;
 811
 812         IVTV_DEBUG_INFO("Enabling pci device\n");
 813
 814         if (pci_enable_device(pdev)) {
 815                 IVTV_ERR("Can't enable device!\n");
 816                 return -EIO;
 817         }
 818         if (pci_set_dma_mask(pdev, 0xffffffff)) {
 819                 IVTV_ERR("No suitable DMA available.\n");
 820                 return -EIO;
 821         }
 822         if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
 823                 IVTV_ERR("Cannot request encoder memory region.\n");
 824                 return -EIO;
 825         }
 826
 827         if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
 828                                 IVTV_REG_SIZE, "ivtv registers")) {
 829                 IVTV_ERR("Cannot request register memory region.\n");
 830                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 831                 return -EIO;
 832         }
 833
 834         if (itv->has_cx23415 &&
 835             !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
 836                                 IVTV_DECODER_SIZE, "ivtv decoder")) {
 837                 IVTV_ERR("Cannot request decoder memory region.\n");
 838                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 839                 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
 840                 return -EIO;
 841         }
 842
 843         /* Check for bus mastering */
 844         pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 845         if (!(cmd & PCI_COMMAND_MASTER)) {
 846                 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
 847                 pci_set_master(pdev);
 848                 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 849                 if (!(cmd & PCI_COMMAND_MASTER)) {
 850                         IVTV_ERR("Bus Mastering is not enabled\n");
 851                         return -ENXIO;
 852                 }
 853         }
 854         IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
 855
 856         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
 857
 858         if (pci_latency < 64 && ivtv_pci_latency) {
 859                 IVTV_INFO("Unreasonably low latency timer, "
 860                                "setting to 64 (was %d)\n", pci_latency);
 861                 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
 862                 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
 863         }
 864         /* This config space value relates to DMA latencies. The
 865            default value 0x8080 is too low however and will lead
 866            to DMA errors. 0xffff is the max value which solves
 867            these problems. */
 868         pci_write_config_dword(pdev, 0x40, 0xffff);
 869
 870         IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
 871                    "irq: %d, latency: %d, memory: 0x%lx\n",
 872                    pdev->device, pdev->revision, pdev->bus->number,
 873                    PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
 874                    pdev->irq, pci_latency, (unsigned long)itv->base_addr);
 875
 876         return 0;
 877 }
 878
 879 static void ivtv_load_and_init_modules(struct ivtv *itv)
 880 {
 881         u32 hw = itv->card->hw_all;
 882         unsigned i;
 883
 884         /* check which i2c devices are actually found */
 885         for (i = 0; i < 32; i++) {
 886                 u32 device = 1 << i;
 887
 888                 if (!(device & hw))
 889                         continue;
 890                 if (device == IVTV_HW_GPIO || device == IVTV_HW_TVEEPROM) {
 891                         /* GPIO and TVEEPROM do not use i2c probing */
 892                         itv->hw_flags |= device;
 893                         continue;
 894                 }
 895                 if (ivtv_i2c_register(itv, i) == 0)
 896                         itv->hw_flags |= device;
 897         }
 898
 899         /* probe for legacy IR controllers that aren't in card definitions */
 900         if ((itv->hw_flags & IVTV_HW_IR_ANY) == 0)
 901                 ivtv_i2c_new_ir_legacy(itv);
 902
 903         if (itv->card->hw_all & IVTV_HW_CX25840)
 904                 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_CX25840);
 905         else if (itv->card->hw_all & IVTV_HW_SAA717X)
 906                 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA717X);
 907         else if (itv->card->hw_all & IVTV_HW_SAA7114)
 908                 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7114);
 909         else
 910                 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7115);
 911         itv->sd_audio = ivtv_find_hw(itv, itv->card->hw_audio_ctrl);
 912         itv->sd_muxer = ivtv_find_hw(itv, itv->card->hw_muxer);
 913
 914         hw = itv->hw_flags;
 915
 916         if (itv->card->type == IVTV_CARD_CX23416GYC) {
 917                 /* Several variations of this card exist, detect which card
 918                    type should be used. */
 919                 if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
 920                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
 921                 else if ((hw & IVTV_HW_UPD64031A) == 0)
 922                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
 923         }
 924         else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
 925                  itv->card->type == IVTV_CARD_GV_MVPRX2E) {
 926                 /* The crystal frequency of GVMVPRX is 24.576MHz */
 927                 v4l2_subdev_call(itv->sd_video, video, s_crystal_freq,
 928                         SAA7115_FREQ_24_576_MHZ, SAA7115_FREQ_FL_UCGC);
 929         }
 930
 931         if (hw & IVTV_HW_CX25840) {
 932                 itv->vbi.raw_decoder_line_size = 1444;
 933                 itv->vbi.raw_decoder_sav_odd_field = 0x20;
 934                 itv->vbi.raw_decoder_sav_even_field = 0x60;
 935                 itv->vbi.sliced_decoder_line_size = 272;
 936                 itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
 937                 itv->vbi.sliced_decoder_sav_even_field = 0xF0;
 938         }
 939
 940         if (hw & IVTV_HW_SAA711X) {
 941                 struct v4l2_dbg_chip_ident v;
 942
 943                 /* determine the exact saa711x model */
 944                 itv->hw_flags &= ~IVTV_HW_SAA711X;
 945
 946                 v.match.type = V4L2_CHIP_MATCH_I2C_DRIVER;
 947                 strlcpy(v.match.name, "saa7115", sizeof(v.match.name));
 948                 ivtv_call_hw(itv, IVTV_HW_SAA711X, core, g_chip_ident, &v);
 949                 if (v.ident == V4L2_IDENT_SAA7114) {
 950                         itv->hw_flags |= IVTV_HW_SAA7114;
 951                         /* VBI is not yet supported by the saa7114 driver. */
 952                         itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
 953                 } else {
 954                         itv->hw_flags |= IVTV_HW_SAA7115;
 955                 }
 956                 itv->vbi.raw_decoder_line_size = 1443;
 957                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 958                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 959                 itv->vbi.sliced_decoder_line_size = 51;
 960                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 961                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 962         }
 963
 964         if (hw & IVTV_HW_SAA717X) {
 965                 itv->vbi.raw_decoder_line_size = 1443;
 966                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 967                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 968                 itv->vbi.sliced_decoder_line_size = 51;
 969                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 970                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 971         }
 972 }
 973
 974 static int __devinit ivtv_probe(struct pci_dev *pdev,
 975                                 const struct pci_device_id *pci_id)
 976 {
 977         int retval = 0;
 978         int vbi_buf_size;
 979         struct ivtv *itv;
 980
 981         itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
 982         if (itv == NULL)
 983                 return -ENOMEM;
 984         itv->pdev = pdev;
 985         itv->instance = v4l2_device_set_name(&itv->v4l2_dev, "ivtv",
 986                                                 &ivtv_instance);
 987
 988         retval = v4l2_device_register(&pdev->dev, &itv->v4l2_dev);
 989         if (retval) {
 990                 kfree(itv);
 991                 return retval;
 992         }
 993         IVTV_INFO("Initializing card %d\n", itv->instance);
 994
 995         ivtv_process_options(itv);
 996         if (itv->options.cardtype == -1) {
 997                 retval = -ENODEV;
 998                 goto err;
 999         }
1000         if (ivtv_init_struct1(itv)) {
1001                 retval = -ENOMEM;
1002                 goto err;
1003         }
1004         retval = cx2341x_handler_init(&itv->cxhdl, 50);
1005         if (retval)
1006                 goto err;
1007         itv->v4l2_dev.ctrl_handler = &itv->cxhdl.hdl;
1008         itv->cxhdl.ops = &ivtv_cxhdl_ops;
1009         itv->cxhdl.priv = itv;
1010         itv->cxhdl.func = ivtv_api_func;
1011
1012         IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv->base_addr);
1013
1014         /* PCI Device Setup */
1015         retval = ivtv_setup_pci(itv, pdev, pci_id);
1016         if (retval == -EIO)
1017                 goto free_worker;
1018         if (retval == -ENXIO)
1019                 goto free_mem;
1020
1021         /* map io memory */
1022         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1023                    itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1024         itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
1025                                        IVTV_ENCODER_SIZE);
1026         if (!itv->enc_mem) {
1027                 IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 "
1028                          "encoder memory\n");
1029                 IVTV_ERR("Each capture card with a CX23415/6 needs 8 MB of "
1030                          "vmalloc address space for this window\n");
1031                 IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1032                 IVTV_ERR("Use the vmalloc= kernel command line option to set "
1033                          "VmallocTotal to a larger value\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. Can't get a window into "
1045                                  "CX23415 decoder memory\n");
1046                         IVTV_ERR("Each capture card with a CX23415 needs 8 MB "
1047                                  "of vmalloc address space for this window\n");
1048                         IVTV_ERR("Check the output of 'grep Vmalloc "
1049                                  "/proc/meminfo'\n");
1050                         IVTV_ERR("Use the vmalloc= kernel command line option "
1051                                  "to set VmallocTotal to a larger value\n");
1052                         retval = -ENOMEM;
1053                         goto free_mem;
1054                 }
1055         }
1056         else {
1057                 itv->dec_mem = itv->enc_mem;
1058         }
1059
1060         /* map registers memory */
1061         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1062                    itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1063         itv->reg_mem =
1064             ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1065         if (!itv->reg_mem) {
1066                 IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 "
1067                          "register space\n");
1068                 IVTV_ERR("Each capture card with a CX23415/6 needs 64 kB of "
1069                          "vmalloc address space for this window\n");
1070                 IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1071                 IVTV_ERR("Use the vmalloc= kernel command line option to set "
1072                          "VmallocTotal to a larger value\n");
1073                 retval = -ENOMEM;
1074                 goto free_io;
1075         }
1076
1077         retval = ivtv_gpio_init(itv);
1078         if (retval)
1079                 goto free_io;
1080
1081         /* active i2c  */
1082         IVTV_DEBUG_INFO("activating i2c...\n");
1083         if (init_ivtv_i2c(itv)) {
1084                 IVTV_ERR("Could not initialize i2c\n");
1085                 goto free_io;
1086         }
1087
1088         if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1089                 /* Based on the model number the cardtype may be changed.
1090                    The PCI IDs are not always reliable. */
1091                 ivtv_process_eeprom(itv);
1092         }
1093         if (itv->card->comment)
1094                 IVTV_INFO("%s", itv->card->comment);
1095         if (itv->card->v4l2_capabilities == 0) {
1096                 /* card was detected but is not supported */
1097                 retval = -ENODEV;
1098                 goto free_i2c;
1099         }
1100
1101         if (itv->std == 0) {
1102                 itv->std = V4L2_STD_NTSC_M;
1103         }
1104
1105         if (itv->options.tuner == -1) {
1106                 int i;
1107
1108                 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1109                         if ((itv->std & itv->card->tuners[i].std) == 0)
1110                                 continue;
1111                         itv->options.tuner = itv->card->tuners[i].tuner;
1112                         break;
1113                 }
1114         }
1115         /* if no tuner was found, then pick the first tuner in the card list */
1116         if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1117                 itv->std = itv->card->tuners[0].std;
1118                 if (itv->std & V4L2_STD_PAL)
1119                         itv->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1120                 else if (itv->std & V4L2_STD_NTSC)
1121                         itv->std = V4L2_STD_NTSC_M;
1122                 else if (itv->std & V4L2_STD_SECAM)
1123                         itv->std = V4L2_STD_SECAM_L;
1124                 itv->options.tuner = itv->card->tuners[0].tuner;
1125         }
1126         if (itv->options.radio == -1)
1127                 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1128
1129         /* The card is now fully identified, continue with card-specific
1130            initialization. */
1131         ivtv_init_struct2(itv);
1132
1133         ivtv_load_and_init_modules(itv);
1134
1135         if (itv->std & V4L2_STD_525_60) {
1136                 itv->is_60hz = 1;
1137                 itv->is_out_60hz = 1;
1138         } else {
1139                 itv->is_50hz = 1;
1140                 itv->is_out_50hz = 1;
1141         }
1142
1143         itv->yuv_info.osd_full_w = 720;
1144         itv->yuv_info.osd_full_h = itv->is_out_50hz ? 576 : 480;
1145         itv->yuv_info.v4l2_src_w = itv->yuv_info.osd_full_w;
1146         itv->yuv_info.v4l2_src_h = itv->yuv_info.osd_full_h;
1147
1148         cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1149
1150         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1151         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1152         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1153         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = 0x10000;
1154         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = 0x08000;
1155
1156         /* Setup VBI Raw Size. Should be big enough to hold PAL.
1157            It is possible to switch between PAL and NTSC, so we need to
1158            take the largest size here. */
1159         /* 1456 is multiple of 16, real size = 1444 */
1160         itv->vbi.raw_size = 1456;
1161         /* We use a buffer size of 1/2 of the total size needed for a
1162            frame. This is actually very useful, since we now receive
1163            a field at a time and that makes 'compressing' the raw data
1164            down to size by stripping off the SAV codes a lot easier.
1165            Note: having two different buffer sizes prevents standard
1166            switching on the fly. We need to find a better solution... */
1167         vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1168         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1169         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1170
1171         if (itv->options.radio > 0)
1172                 itv->v4l2_cap |= V4L2_CAP_RADIO;
1173
1174         if (itv->options.tuner > -1) {
1175                 struct tuner_setup setup;
1176
1177                 setup.addr = ADDR_UNSET;
1178                 setup.type = itv->options.tuner;
1179                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1180                 if (itv->options.radio > 0)
1181                         setup.mode_mask |= T_RADIO;
1182                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1183                         ivtv_reset_tuner_gpio : NULL;
1184                 ivtv_call_all(itv, tuner, s_type_addr, &setup);
1185                 if (setup.type == TUNER_XC2028) {
1186                         static struct xc2028_ctrl ctrl = {
1187                                 .fname = XC2028_DEFAULT_FIRMWARE,
1188                                 .max_len = 64,
1189                         };
1190                         struct v4l2_priv_tun_config cfg = {
1191                                 .tuner = itv->options.tuner,
1192                                 .priv = &ctrl,
1193                         };
1194                         ivtv_call_all(itv, tuner, s_config, &cfg);
1195                 }
1196         }
1197
1198         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1199            are not. */
1200         itv->tuner_std = itv->std;
1201
1202         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1203                 ivtv_call_all(itv, video, s_std_output, itv->std);
1204                 /* Turn off the output signal. The mpeg decoder is not yet
1205                    active so without this you would get a green image until the
1206                    mpeg decoder becomes active. */
1207                 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1208         }
1209
1210         /* clear interrupt mask, effectively disabling interrupts */
1211         ivtv_set_irq_mask(itv, 0xffffffff);
1212
1213         /* Register IRQ */
1214         retval = request_irq(itv->pdev->irq, ivtv_irq_handler,
1215              IRQF_SHARED | IRQF_DISABLED, itv->v4l2_dev.name, (void *)itv);
1216         if (retval) {
1217                 IVTV_ERR("Failed to register irq %d\n", retval);
1218                 goto free_i2c;
1219         }
1220
1221         retval = ivtv_streams_setup(itv);
1222         if (retval) {
1223                 IVTV_ERR("Error %d setting up streams\n", retval);
1224                 goto free_irq;
1225         }
1226         retval = ivtv_streams_register(itv);
1227         if (retval) {
1228                 IVTV_ERR("Error %d registering devices\n", retval);
1229                 goto free_streams;
1230         }
1231         IVTV_INFO("Initialized card: %s\n", itv->card_name);
1232         return 0;
1233
1234 free_streams:
1235         ivtv_streams_cleanup(itv, 1);
1236 free_irq:
1237         free_irq(itv->pdev->irq, (void *)itv);
1238 free_i2c:
1239         exit_ivtv_i2c(itv);
1240 free_io:
1241         ivtv_iounmap(itv);
1242 free_mem:
1243         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1244         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1245         if (itv->has_cx23415)
1246                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1247 free_worker:
1248         kthread_stop(itv->irq_worker_task);
1249 err:
1250         if (retval == 0)
1251                 retval = -ENODEV;
1252         IVTV_ERR("Error %d on initialization\n", retval);
1253
1254         v4l2_device_unregister(&itv->v4l2_dev);
1255         kfree(itv);
1256         return retval;
1257 }
1258
1259 int ivtv_init_on_first_open(struct ivtv *itv)
1260 {
1261         struct v4l2_frequency vf;
1262         /* Needed to call ioctls later */
1263         struct ivtv_open_id fh;
1264         int fw_retry_count = 3;
1265         int video_input;
1266
1267         fh.itv = itv;
1268
1269         if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1270                 return -ENXIO;
1271
1272         if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1273                 return 0;
1274
1275         while (--fw_retry_count > 0) {
1276                 /* load firmware */
1277                 if (ivtv_firmware_init(itv) == 0)
1278                         break;
1279                 if (fw_retry_count > 1)
1280                         IVTV_WARN("Retry loading firmware\n");
1281         }
1282
1283         if (fw_retry_count == 0) {
1284                 set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1285                 return -ENXIO;
1286         }
1287
1288         /* Try and get firmware versions */
1289         IVTV_DEBUG_INFO("Getting firmware version..\n");
1290         ivtv_firmware_versions(itv);
1291
1292         if (itv->card->hw_all & IVTV_HW_CX25840)
1293                 v4l2_subdev_call(itv->sd_video, core, load_fw);
1294
1295         vf.tuner = 0;
1296         vf.type = V4L2_TUNER_ANALOG_TV;
1297         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1298
1299         /* Set initial frequency. For PAL/SECAM broadcasts no
1300            'default' channel exists AFAIK. */
1301         if (itv->std == V4L2_STD_NTSC_M_JP) {
1302                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1303         }
1304         else if (itv->std & V4L2_STD_NTSC_M) {
1305                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1306         }
1307
1308         video_input = itv->active_input;
1309         itv->active_input++;    /* Force update of input */
1310         ivtv_s_input(NULL, &fh, video_input);
1311
1312         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1313            in one place. */
1314         itv->std++;             /* Force full standard initialization */
1315         itv->std_out = itv->std;
1316         ivtv_s_frequency(NULL, &fh, &vf);
1317
1318         if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1319                 /* Turn on the TV-out: ivtv_init_mpeg_decoder() initializes
1320                    the mpeg decoder so now the saa7127 receives a proper
1321                    signal. */
1322                 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 1);
1323                 ivtv_init_mpeg_decoder(itv);
1324         }
1325
1326         /* On a cx23416 this seems to be able to enable DMA to the chip? */
1327         if (!itv->has_cx23415)
1328                 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1329
1330         ivtv_s_std_enc(itv, &itv->tuner_std);
1331
1332         /* Default interrupts enabled. For the PVR350 this includes the
1333            decoder VSYNC interrupt, which is always on. It is not only used
1334            during decoding but also by the OSD.
1335            Some old PVR250 cards had a cx23415, so testing for that is too
1336            general. Instead test if the card has video output capability. */
1337         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1338                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1339                 ivtv_set_osd_alpha(itv);
1340                 ivtv_s_std_dec(itv, &itv->tuner_std);
1341         } else {
1342                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1343         }
1344
1345         /* Setup initial controls */
1346         cx2341x_handler_setup(&itv->cxhdl);
1347         return 0;
1348 }
1349
1350 static void ivtv_remove(struct pci_dev *pdev)
1351 {
1352         struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1353         struct ivtv *itv = to_ivtv(v4l2_dev);
1354         int i;
1355
1356         IVTV_DEBUG_INFO("Removing card\n");
1357
1358         if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1359                 /* Stop all captures */
1360                 IVTV_DEBUG_INFO("Stopping all streams\n");
1361                 if (atomic_read(&itv->capturing) > 0)
1362                         ivtv_stop_all_captures(itv);
1363
1364                 /* Stop all decoding */
1365                 IVTV_DEBUG_INFO("Stopping decoding\n");
1366
1367                 /* Turn off the TV-out */
1368                 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1369                         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1370                 if (atomic_read(&itv->decoding) > 0) {
1371                         int type;
1372
1373                         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1374                                 type = IVTV_DEC_STREAM_TYPE_YUV;
1375                         else
1376                                 type = IVTV_DEC_STREAM_TYPE_MPG;
1377                         ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1378                                 VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1379                 }
1380                 ivtv_halt_firmware(itv);
1381         }
1382
1383         /* Interrupts */
1384         ivtv_set_irq_mask(itv, 0xffffffff);
1385         del_timer_sync(&itv->dma_timer);
1386
1387         /* Kill irq worker */
1388         flush_kthread_worker(&itv->irq_worker);
1389         kthread_stop(itv->irq_worker_task);
1390
1391         ivtv_streams_cleanup(itv, 1);
1392         ivtv_udma_free(itv);
1393
1394         exit_ivtv_i2c(itv);
1395
1396         free_irq(itv->pdev->irq, (void *)itv);
1397         ivtv_iounmap(itv);
1398
1399         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1400         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1401         if (itv->has_cx23415)
1402                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1403
1404         pci_disable_device(itv->pdev);
1405         for (i = 0; i < IVTV_VBI_FRAMES; i++)
1406                 kfree(itv->vbi.sliced_mpeg_data[i]);
1407
1408         printk(KERN_INFO "ivtv: Removed %s\n", itv->card_name);
1409
1410         v4l2_device_unregister(&itv->v4l2_dev);
1411         kfree(itv);
1412 }
1413
1414 /* define a pci_driver for card detection */
1415 static struct pci_driver ivtv_pci_driver = {
1416       .name =     "ivtv",
1417       .id_table = ivtv_pci_tbl,
1418       .probe =    ivtv_probe,
1419       .remove =   ivtv_remove,
1420 };
1421
1422 static int __init module_start(void)
1423 {
1424         printk(KERN_INFO "ivtv: Start initialization, version %s\n", IVTV_VERSION);
1425
1426         /* Validate parameters */
1427         if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1428                 printk(KERN_ERR "ivtv: Exiting, ivtv_first_minor must be between 0 and %d\n",
1429                      IVTV_MAX_CARDS - 1);
1430                 return -1;
1431         }
1432
1433         if (ivtv_debug < 0 || ivtv_debug > 2047) {
1434                 ivtv_debug = 0;
1435                 printk(KERN_INFO "ivtv: Debug value must be >= 0 and <= 2047\n");
1436         }
1437
1438         if (pci_register_driver(&ivtv_pci_driver)) {
1439                 printk(KERN_ERR "ivtv: Error detecting PCI card\n");
1440                 return -ENODEV;
1441         }
1442         printk(KERN_INFO "ivtv: End initialization\n");
1443         return 0;
1444 }
1445
1446 static void __exit module_cleanup(void)
1447 {
1448         pci_unregister_driver(&ivtv_pci_driver);
1449 }
1450
1451 /* Note: These symbols are exported because they are used by the ivtvfb
1452    framebuffer module and an infrared module for the IR-blaster. */
1453 EXPORT_SYMBOL(ivtv_set_irq_mask);
1454 EXPORT_SYMBOL(ivtv_api);
1455 EXPORT_SYMBOL(ivtv_vapi);
1456 EXPORT_SYMBOL(ivtv_vapi_result);
1457 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1458 EXPORT_SYMBOL(ivtv_debug);
1459 #ifdef CONFIG_VIDEO_ADV_DEBUG
1460 EXPORT_SYMBOL(ivtv_fw_debug);
1461 #endif
1462 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1463 EXPORT_SYMBOL(ivtv_udma_setup);
1464 EXPORT_SYMBOL(ivtv_udma_unmap);
1465 EXPORT_SYMBOL(ivtv_udma_alloc);
1466 EXPORT_SYMBOL(ivtv_udma_prepare);
1467 EXPORT_SYMBOL(ivtv_init_on_first_open);
1468 EXPORT_SYMBOL(ivtv_firmware_check);
1469
1470 module_init(module_start);
1471 module_exit(module_cleanup);