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