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