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