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