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 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 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->cur_pio_stream = -1;
 656         itv->audio_stereo_mode = AUDIO_STEREO;
 657         itv->audio_bilingual_mode = AUDIO_MONO_LEFT;
 658
 659         /* Ctrls */
 660         itv->speed = 1000;
 661
 662         /* VBI */
 663         itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
 664         itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
 665
 666         /* OSD */
 667         itv->osd_global_alpha_state = 1;
 668         itv->osd_global_alpha = 255;
 669
 670         /* YUV */
 671         atomic_set(&itv->yuv_info.next_dma_frame, -1);
 672         itv->yuv_info.lace_mode = ivtv_yuv_mode;
 673         itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
 674         return 0;
 675 }
 676
 677 /* Second initialization part. Here the card type has been
 678    autodetected. */
 679 static void __devinit ivtv_init_struct2(struct ivtv *itv)
 680 {
 681         int i;
 682
 683         for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
 684                 if (itv->card->video_inputs[i].video_type == 0)
 685                         break;
 686         itv->nof_inputs = i;
 687         for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
 688                 if (itv->card->audio_inputs[i].audio_type == 0)
 689                         break;
 690         itv->nof_audio_inputs = i;
 691
 692         /* 0x00EF = saa7114(239) 0x00F0 = saa7115(240) 0x0106 = micro */
 693         if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
 694                 itv->digitizer = 0xF1;
 695         else if (itv->card->hw_all & IVTV_HW_SAA7114)
 696                 itv->digitizer = 0xEF;
 697         else /* cx25840 */
 698                 itv->digitizer = 0x140;
 699
 700         if (itv->card->hw_all & IVTV_HW_CX25840) {
 701                 itv->vbi.sliced_size = 288;  /* multiple of 16, real size = 284 */
 702         } else {
 703                 itv->vbi.sliced_size = 64;   /* multiple of 16, real size = 52 */
 704         }
 705
 706         /* Find tuner input */
 707         for (i = 0; i < itv->nof_inputs; i++) {
 708                 if (itv->card->video_inputs[i].video_type ==
 709                                 IVTV_CARD_INPUT_VID_TUNER)
 710                         break;
 711         }
 712         if (i == itv->nof_inputs)
 713                 i = 0;
 714         itv->active_input = i;
 715         itv->audio_input = itv->card->video_inputs[i].audio_index;
 716         if (itv->card->hw_all & IVTV_HW_CX25840)
 717                 itv->video_dec_func = ivtv_cx25840;
 718         else if (itv->card->hw_all & IVTV_HW_SAA717X)
 719                 itv->video_dec_func = ivtv_saa717x;
 720         else
 721                 itv->video_dec_func = ivtv_saa7115;
 722 }
 723
 724 static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *dev,
 725                           const struct pci_device_id *pci_id)
 726 {
 727         u16 cmd;
 728         unsigned char pci_latency;
 729
 730         IVTV_DEBUG_INFO("Enabling pci device\n");
 731
 732         if (pci_enable_device(dev)) {
 733                 IVTV_ERR("Can't enable device %d!\n", itv->num);
 734                 return -EIO;
 735         }
 736         if (pci_set_dma_mask(dev, 0xffffffff)) {
 737                 IVTV_ERR("No suitable DMA available on card %d.\n", itv->num);
 738                 return -EIO;
 739         }
 740         if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
 741                 IVTV_ERR("Cannot request encoder memory region on card %d.\n", itv->num);
 742                 return -EIO;
 743         }
 744
 745         if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
 746                                 IVTV_REG_SIZE, "ivtv registers")) {
 747                 IVTV_ERR("Cannot request register memory region on card %d.\n", itv->num);
 748                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 749                 return -EIO;
 750         }
 751
 752         if (itv->has_cx23415 &&
 753             !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
 754                                 IVTV_DECODER_SIZE, "ivtv decoder")) {
 755                 IVTV_ERR("Cannot request decoder memory region on card %d.\n", itv->num);
 756                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 757                 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
 758                 return -EIO;
 759         }
 760
 761         /* Check for bus mastering */
 762         pci_read_config_word(dev, PCI_COMMAND, &cmd);
 763         if (!(cmd & PCI_COMMAND_MASTER)) {
 764                 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
 765                 pci_set_master(dev);
 766                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
 767                 if (!(cmd & PCI_COMMAND_MASTER)) {
 768                         IVTV_ERR("Bus Mastering is not enabled\n");
 769                         return -ENXIO;
 770                 }
 771         }
 772         IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
 773
 774         pci_read_config_byte(dev, PCI_CLASS_REVISION, &itv->card_rev);
 775         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 776
 777         if (pci_latency < 64 && ivtv_pci_latency) {
 778                 IVTV_INFO("Unreasonably low latency timer, "
 779                                "setting to 64 (was %d)\n", pci_latency);
 780                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
 781                 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 782         }
 783         /* This config space value relates to DMA latencies. The
 784            default value 0x8080 is too low however and will lead
 785            to DMA errors. 0xffff is the max value which solves
 786            these problems. */
 787         pci_write_config_dword(dev, 0x40, 0xffff);
 788
 789         IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
 790                    "irq: %d, latency: %d, memory: 0x%lx\n",
 791                    itv->dev->device, itv->card_rev, dev->bus->number,
 792                    PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
 793                    itv->dev->irq, pci_latency, (unsigned long)itv->base_addr);
 794
 795         return 0;
 796 }
 797
 798 static void ivtv_request_module(struct ivtv *itv, const char *name)
 799 {
 800         if (request_module(name) != 0) {
 801                 IVTV_ERR("Failed to load module %s\n", name);
 802         } else {
 803                 IVTV_DEBUG_INFO("Loaded module %s\n", name);
 804         }
 805 }
 806
 807 static void ivtv_load_and_init_modules(struct ivtv *itv)
 808 {
 809         struct v4l2_control ctrl;
 810         u32 hw = itv->card->hw_all;
 811         int i;
 812
 813         /* load modules */
 814 #ifndef CONFIG_VIDEO_TUNER
 815         if (hw & IVTV_HW_TUNER) {
 816                 ivtv_request_module(itv, "tuner");
 817 #ifdef HAVE_XC3028
 818                 if (itv->options.tuner == TUNER_XCEIVE_XC3028)
 819                         ivtv_request_module(itv, "xc3028-tuner");
 820 #endif
 821         }
 822 #endif
 823 #ifndef CONFIG_VIDEO_CX25840
 824         if (hw & IVTV_HW_CX25840)
 825                 ivtv_request_module(itv, "cx25840");
 826 #endif
 827 #ifndef CONFIG_VIDEO_SAA711X
 828         if (hw & IVTV_HW_SAA711X)
 829                 ivtv_request_module(itv, "saa7115");
 830 #endif
 831 #ifndef CONFIG_VIDEO_SAA7127
 832         if (hw & IVTV_HW_SAA7127)
 833                 ivtv_request_module(itv, "saa7127");
 834 #endif
 835         if (hw & IVTV_HW_SAA717X)
 836                 ivtv_request_module(itv, "saa717x");
 837 #ifndef CONFIG_VIDEO_UPD64031A
 838         if (hw & IVTV_HW_UPD64031A)
 839                 ivtv_request_module(itv, "upd64031a");
 840 #endif
 841 #ifndef CONFIG_VIDEO_UPD64083
 842         if (hw & IVTV_HW_UPD6408X)
 843                 ivtv_request_module(itv, "upd64083");
 844 #endif
 845 #ifndef CONFIG_VIDEO_MSP3400
 846         if (hw & IVTV_HW_MSP34XX)
 847                 ivtv_request_module(itv, "msp3400");
 848 #endif
 849         if (hw & IVTV_HW_TVAUDIO)
 850                 ivtv_request_module(itv, "tvaudio");
 851 #ifndef CONFIG_VIDEO_WM8775
 852         if (hw & IVTV_HW_WM8775)
 853                 ivtv_request_module(itv, "wm8775");
 854 #endif
 855 #ifndef CONFIG_VIDEO_WM8739
 856         if (hw & IVTV_HW_WM8739)
 857                 ivtv_request_module(itv, "wm8739");
 858 #endif
 859 #ifndef CONFIG_VIDEO_CS53L32A
 860         if (hw & IVTV_HW_CS53L32A)
 861                 ivtv_request_module(itv, "cs53l32a");
 862 #endif
 863
 864         /* check which i2c devices are actually found */
 865         for (i = 0; i < 32; i++) {
 866                 u32 device = 1 << i;
 867
 868                 if (!(device & hw))
 869                         continue;
 870                 if (device == IVTV_HW_GPIO) {
 871                         /* GPIO is always available */
 872                         itv->hw_flags |= IVTV_HW_GPIO;
 873                         continue;
 874                 }
 875                 if (ivtv_i2c_hw_addr(itv, device) > 0)
 876                         itv->hw_flags |= device;
 877         }
 878
 879         hw = itv->hw_flags;
 880
 881         if (itv->card->type == IVTV_CARD_CX23416GYC) {
 882                 /* Several variations of this card exist, detect which card
 883                    type should be used. */
 884                 if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
 885                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
 886                 else if ((hw & IVTV_HW_UPD64031A) == 0)
 887                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
 888         }
 889
 890         if (hw & IVTV_HW_CX25840) {
 891                 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
 892                 ctrl.id = V4L2_CID_PRIVATE_BASE;
 893                 ctrl.value = itv->pvr150_workaround;
 894                 itv->video_dec_func(itv, VIDIOC_S_CTRL, &ctrl);
 895
 896                 itv->vbi.raw_decoder_line_size = 1444;
 897                 itv->vbi.raw_decoder_sav_odd_field = 0x20;
 898                 itv->vbi.raw_decoder_sav_even_field = 0x60;
 899                 itv->vbi.sliced_decoder_line_size = 272;
 900                 itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
 901                 itv->vbi.sliced_decoder_sav_even_field = 0xF0;
 902         }
 903
 904         if (hw & IVTV_HW_SAA711X) {
 905                 struct v4l2_chip_ident v = { V4L2_CHIP_MATCH_I2C_DRIVER, I2C_DRIVERID_SAA711X };
 906
 907                 /* determine the exact saa711x model */
 908                 itv->hw_flags &= ~IVTV_HW_SAA711X;
 909
 910                 ivtv_saa7115(itv, VIDIOC_G_CHIP_IDENT, &v);
 911                 if (v.ident == V4L2_IDENT_SAA7114) {
 912                         itv->hw_flags |= IVTV_HW_SAA7114;
 913                         /* VBI is not yet supported by the saa7114 driver. */
 914                         itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
 915                 }
 916                 else {
 917                         itv->hw_flags |= IVTV_HW_SAA7115;
 918                 }
 919                 itv->vbi.raw_decoder_line_size = 1443;
 920                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 921                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 922                 itv->vbi.sliced_decoder_line_size = 51;
 923                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 924                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 925         }
 926
 927         if (hw & IVTV_HW_SAA717X) {
 928                 itv->vbi.raw_decoder_line_size = 1443;
 929                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 930                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 931                 itv->vbi.sliced_decoder_line_size = 51;
 932                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 933                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 934         }
 935 }
 936
 937 static int __devinit ivtv_probe(struct pci_dev *dev,
 938                                 const struct pci_device_id *pci_id)
 939 {
 940         int retval = 0;
 941         int video_input;
 942         int yuv_buf_size;
 943         int vbi_buf_size;
 944         int fw_retry_count = 3;
 945         struct ivtv *itv;
 946         struct v4l2_frequency vf;
 947
 948         spin_lock(&ivtv_cards_lock);
 949
 950         /* Make sure we've got a place for this card */
 951         if (ivtv_cards_active == IVTV_MAX_CARDS) {
 952                 printk(KERN_ERR "ivtv:  Maximum number of cards detected (%d).\n",
 953                               ivtv_cards_active);
 954                 spin_unlock(&ivtv_cards_lock);
 955                 return -ENOMEM;
 956         }
 957
 958         itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
 959         if (itv == 0) {
 960                 spin_unlock(&ivtv_cards_lock);
 961                 return -ENOMEM;
 962         }
 963         ivtv_cards[ivtv_cards_active] = itv;
 964         itv->dev = dev;
 965         itv->num = ivtv_cards_active++;
 966         snprintf(itv->name, sizeof(itv->name) - 1, "ivtv%d", itv->num);
 967         if (itv->num) {
 968                 printk(KERN_INFO "ivtv:  ======================  NEXT CARD  ======================\n");
 969         }
 970
 971         spin_unlock(&ivtv_cards_lock);
 972
 973         ivtv_process_options(itv);
 974         if (itv->options.cardtype == -1) {
 975                 retval = -ENODEV;
 976                 goto err;
 977         }
 978         if (ivtv_init_struct1(itv)) {
 979                 retval = -ENOMEM;
 980                 goto err;
 981         }
 982
 983         IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv->base_addr);
 984
 985         /* PCI Device Setup */
 986         if ((retval = ivtv_setup_pci(itv, dev, pci_id)) != 0) {
 987                 if (retval == -EIO)
 988                         goto free_workqueue;
 989                 else if (retval == -ENXIO)
 990                         goto free_mem;
 991         }
 992         /* save itv in the pci struct for later use */
 993         pci_set_drvdata(dev, itv);
 994
 995         /* map io memory */
 996         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
 997                    itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
 998         itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
 999                                        IVTV_ENCODER_SIZE);
1000         if (!itv->enc_mem) {
1001                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1002                 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1003                 retval = -ENOMEM;
1004                 goto free_mem;
1005         }
1006
1007         if (itv->has_cx23415) {
1008                 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1009                                 itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1010                 itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
1011                                 IVTV_DECODER_SIZE);
1012                 if (!itv->dec_mem) {
1013                         IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1014                         IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1015                         retval = -ENOMEM;
1016                         goto free_mem;
1017                 }
1018         }
1019         else {
1020                 itv->dec_mem = itv->enc_mem;
1021         }
1022
1023         /* map registers memory */
1024         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1025                    itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1026         itv->reg_mem =
1027             ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1028         if (!itv->reg_mem) {
1029                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1030                 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1031                 retval = -ENOMEM;
1032                 goto free_io;
1033         }
1034
1035         while (--fw_retry_count > 0) {
1036                 /* load firmware */
1037                 if (ivtv_firmware_init(itv) == 0)
1038                         break;
1039                 if (fw_retry_count > 1)
1040                         IVTV_WARN("Retry loading firmware\n");
1041         }
1042         if (fw_retry_count == 0) {
1043                 IVTV_ERR("Error initializing firmware\n");
1044                 goto free_i2c;
1045         }
1046
1047         /* Try and get firmware versions */
1048         IVTV_DEBUG_INFO("Getting firmware version..\n");
1049         ivtv_firmware_versions(itv);
1050
1051         /* Check yuv output filter table */
1052         if (itv->has_cx23415) ivtv_yuv_filter_check(itv);
1053
1054         ivtv_gpio_init(itv);
1055
1056         /* active i2c  */
1057         IVTV_DEBUG_INFO("activating i2c...\n");
1058         if (init_ivtv_i2c(itv)) {
1059                 IVTV_ERR("Could not initialize i2c\n");
1060                 goto free_irq;
1061         }
1062
1063         IVTV_DEBUG_INFO("Active card count: %d.\n", ivtv_cards_active);
1064
1065         if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1066 #ifdef CONFIG_VIDEO_TVEEPROM_MODULE
1067                 ivtv_request_module(itv, "tveeprom");
1068 #endif
1069                 /* Based on the model number the cardtype may be changed.
1070                    The PCI IDs are not always reliable. */
1071                 ivtv_process_eeprom(itv);
1072         }
1073
1074         if (itv->std == 0) {
1075                 itv->std = V4L2_STD_NTSC_M;
1076         }
1077
1078         if (itv->options.tuner == -1) {
1079                 int i;
1080
1081                 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1082                         if ((itv->std & itv->card->tuners[i].std) == 0)
1083                                 continue;
1084                         itv->options.tuner = itv->card->tuners[i].tuner;
1085                         break;
1086                 }
1087         }
1088         /* if no tuner was found, then pick the first tuner in the card list */
1089         if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1090                 itv->std = itv->card->tuners[0].std;
1091                 itv->options.tuner = itv->card->tuners[0].tuner;
1092         }
1093         if (itv->options.radio == -1)
1094                 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1095
1096         /* The card is now fully identified, continue with card-specific
1097            initialization. */
1098         ivtv_init_struct2(itv);
1099
1100         ivtv_load_and_init_modules(itv);
1101
1102         if (itv->std & V4L2_STD_525_60) {
1103                 itv->is_60hz = 1;
1104                 itv->is_out_60hz = 1;
1105         } else {
1106                 itv->is_50hz = 1;
1107                 itv->is_out_50hz = 1;
1108         }
1109         itv->params.video_gop_size = itv->is_60hz ? 15 : 12;
1110
1111         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1112         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1113         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1114
1115         /* 0x15180 == 720 * 480 / 4, 0x19500 == 720 * 576 / 4 */
1116         yuv_buf_size = itv->is_60hz ? 0x15180 : 0x19500;
1117         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = yuv_buf_size / 2;
1118         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = yuv_buf_size / 8;
1119
1120         /* Setup VBI Raw Size. Should be big enough to hold PAL.
1121            It is possible to switch between PAL and NTSC, so we need to
1122            take the largest size here. */
1123         /* 1456 is multiple of 16, real size = 1444 */
1124         itv->vbi.raw_size = 1456;
1125         /* We use a buffer size of 1/2 of the total size needed for a
1126            frame. This is actually very useful, since we now receive
1127            a field at a time and that makes 'compressing' the raw data
1128            down to size by stripping off the SAV codes a lot easier.
1129            Note: having two different buffer sizes prevents standard
1130            switching on the fly. We need to find a better solution... */
1131         vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1132         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1133         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1134
1135         if (itv->options.radio > 0)
1136                 itv->v4l2_cap |= V4L2_CAP_RADIO;
1137
1138         if (itv->options.tuner > -1) {
1139                 struct tuner_setup setup;
1140
1141                 setup.addr = ADDR_UNSET;
1142                 setup.type = itv->options.tuner;
1143                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1144 #ifdef HAVE_XC3028
1145                 setup.initmode = V4L2_TUNER_ANALOG_TV;
1146                 if (itv->options.tuner == TUNER_XCEIVE_XC3028) {
1147                         setup.gpio_write = ivtv_reset_tuner_gpio;
1148                         setup.gpio_priv = itv;
1149                 }
1150 #endif
1151                 ivtv_call_i2c_clients(itv, TUNER_SET_TYPE_ADDR, &setup);
1152         }
1153
1154         vf.tuner = 0;
1155         vf.type = V4L2_TUNER_ANALOG_TV;
1156         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1157         if (itv->std & V4L2_STD_NTSC_M) {
1158                 /* Why on earth? */
1159                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1160         }
1161
1162         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1163            are not. */
1164         itv->tuner_std = itv->std;
1165
1166         video_input = itv->active_input;
1167         itv->active_input++;    /* Force update of input */
1168         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_INPUT, &video_input);
1169
1170         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1171            in one place. */
1172         itv->std++;             /* Force full standard initialization */
1173         itv->std_out = itv->std;
1174         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_FREQUENCY, &vf);
1175
1176         retval = ivtv_streams_setup(itv);
1177         if (retval) {
1178                 IVTV_ERR("Error %d setting up streams\n", retval);
1179                 goto free_i2c;
1180         }
1181
1182         if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1183                 ivtv_init_mpeg_decoder(itv);
1184         }
1185         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_STD, &itv->tuner_std);
1186
1187         IVTV_DEBUG_IRQ("Masking interrupts\n");
1188         /* clear interrupt mask, effectively disabling interrupts */
1189         ivtv_set_irq_mask(itv, 0xffffffff);
1190
1191         /* Register IRQ */
1192         retval = request_irq(itv->dev->irq, ivtv_irq_handler,
1193                              IRQF_SHARED | IRQF_DISABLED, itv->name, (void *)itv);
1194         if (retval) {
1195                 IVTV_ERR("Failed to register irq %d\n", retval);
1196                 goto free_streams;
1197         }
1198
1199         /* On a cx23416 this seems to be able to enable DMA to the chip? */
1200         if (!itv->has_cx23415)
1201                 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1202
1203         /* Default interrupts enabled. For the PVR350 this includes the
1204            decoder VSYNC interrupt, which is always on. It is not only used
1205            during decoding but also by the OSD.
1206            Some old PVR250 cards had a cx23415, so testing for that is too
1207            general. Instead test if the card has video output capability. */
1208         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1209                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1210         else
1211                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1212
1213         if (itv->has_cx23415)
1214                 ivtv_set_osd_alpha(itv);
1215
1216         IVTV_INFO("Initialized %s, card #%d\n", itv->card_name, itv->num);
1217
1218         return 0;
1219
1220       free_irq:
1221         free_irq(itv->dev->irq, (void *)itv);
1222       free_streams:
1223         ivtv_streams_cleanup(itv);
1224       free_i2c:
1225         exit_ivtv_i2c(itv);
1226       free_io:
1227         ivtv_iounmap(itv);
1228       free_mem:
1229         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1230         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1231         if (itv->has_cx23415)
1232                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1233       free_workqueue:
1234         destroy_workqueue(itv->irq_work_queues);
1235       err:
1236         if (retval == 0)
1237                 retval = -ENODEV;
1238         IVTV_ERR("Error %d on initialization\n", retval);
1239
1240         kfree(ivtv_cards[ivtv_cards_active]);
1241         ivtv_cards[ivtv_cards_active] = NULL;
1242         return retval;
1243 }
1244
1245 static void ivtv_remove(struct pci_dev *pci_dev)
1246 {
1247         struct ivtv *itv = pci_get_drvdata(pci_dev);
1248
1249         IVTV_DEBUG_INFO("Removing Card #%d.\n", itv->num);
1250
1251         /* Stop all captures */
1252         IVTV_DEBUG_INFO(" Stopping all streams.\n");
1253         if (atomic_read(&itv->capturing) > 0)
1254                 ivtv_stop_all_captures(itv);
1255
1256         /* Stop all decoding */
1257         IVTV_DEBUG_INFO(" Stopping decoding.\n");
1258         if (atomic_read(&itv->decoding) > 0) {
1259                 int type;
1260
1261                 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1262                         type = IVTV_DEC_STREAM_TYPE_YUV;
1263                 else
1264                         type = IVTV_DEC_STREAM_TYPE_MPG;
1265                 ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1266                         VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1267         }
1268
1269         /* Interrupts */
1270         IVTV_DEBUG_INFO(" Disabling interrupts.\n");
1271         ivtv_set_irq_mask(itv, 0xffffffff);
1272         del_timer_sync(&itv->dma_timer);
1273
1274         /* Stop all Work Queues */
1275         IVTV_DEBUG_INFO(" Stop Work Queues.\n");
1276         flush_workqueue(itv->irq_work_queues);
1277         destroy_workqueue(itv->irq_work_queues);
1278
1279         IVTV_DEBUG_INFO(" Stopping Firmware.\n");
1280         ivtv_halt_firmware(itv);
1281
1282         IVTV_DEBUG_INFO(" Unregistering v4l devices.\n");
1283         ivtv_streams_cleanup(itv);
1284         IVTV_DEBUG_INFO(" Freeing dma resources.\n");
1285         ivtv_udma_free(itv);
1286
1287         exit_ivtv_i2c(itv);
1288
1289         IVTV_DEBUG_INFO(" Releasing irq.\n");
1290         free_irq(itv->dev->irq, (void *)itv);
1291
1292         if (itv->dev) {
1293                 ivtv_iounmap(itv);
1294         }
1295
1296         IVTV_DEBUG_INFO(" Releasing mem.\n");
1297         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1298         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1299         if (itv->has_cx23415)
1300                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1301
1302         pci_disable_device(itv->dev);
1303
1304         IVTV_INFO("Removed %s, card #%d\n", itv->card_name, itv->num);
1305 }
1306
1307 /* define a pci_driver for card detection */
1308 static struct pci_driver ivtv_pci_driver = {
1309       .name =     "ivtv",
1310       .id_table = ivtv_pci_tbl,
1311       .probe =    ivtv_probe,
1312       .remove =   ivtv_remove,
1313 };
1314
1315 static int module_start(void)
1316 {
1317         printk(KERN_INFO "ivtv:  ==================== START INIT IVTV ====================\n");
1318         printk(KERN_INFO "ivtv:  version %s (" VERMAGIC_STRING ") loading\n", IVTV_VERSION);
1319
1320         memset(ivtv_cards, 0, sizeof(ivtv_cards));
1321
1322         /* Validate parameters */
1323         if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1324                 printk(KERN_ERR "ivtv:  ivtv_first_minor must be between 0 and %d. Exiting...\n",
1325                      IVTV_MAX_CARDS - 1);
1326                 return -1;
1327         }
1328
1329         if (ivtv_debug < 0 || ivtv_debug > 511) {
1330                 ivtv_debug = 0;
1331                 printk(KERN_INFO "ivtv:  debug value must be >= 0 and <= 511!\n");
1332         }
1333
1334         if (pci_register_driver(&ivtv_pci_driver)) {
1335                 printk(KERN_ERR "ivtv:  Error detecting PCI card\n");
1336                 return -ENODEV;
1337         }
1338         printk(KERN_INFO "ivtv:  ====================  END INIT IVTV  ====================\n");
1339         return 0;
1340 }
1341
1342 static void module_cleanup(void)
1343 {
1344         int i, j;
1345
1346         pci_unregister_driver(&ivtv_pci_driver);
1347
1348         for (i = 0; i < ivtv_cards_active; i++) {
1349                 if (ivtv_cards[i] == NULL)
1350                         continue;
1351                 for (j = 0; j < IVTV_VBI_FRAMES; j++) {
1352                         kfree(ivtv_cards[i]->vbi.sliced_mpeg_data[j]);
1353                 }
1354                 kfree(ivtv_cards[i]);
1355         }
1356 }
1357
1358 /* Note: These symbols are exported because they are used by the ivtv-fb
1359    framebuffer module and an infrared module for the IR-blaster. */
1360 EXPORT_SYMBOL(ivtv_set_irq_mask);
1361 EXPORT_SYMBOL(ivtv_cards_active);
1362 EXPORT_SYMBOL(ivtv_cards);
1363 EXPORT_SYMBOL(ivtv_api);
1364 EXPORT_SYMBOL(ivtv_vapi);
1365 EXPORT_SYMBOL(ivtv_vapi_result);
1366 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1367 EXPORT_SYMBOL(ivtv_debug);
1368 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1369 EXPORT_SYMBOL(ivtv_udma_setup);
1370 EXPORT_SYMBOL(ivtv_udma_unmap);
1371 EXPORT_SYMBOL(ivtv_udma_alloc);
1372 EXPORT_SYMBOL(ivtv_udma_prepare);
1373
1374 module_init(module_start);
1375 module_exit(module_cleanup);