SAFE public projects git trees. - safe/jmp/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 <linux/vermagic.h>
  60 #include <media/tveeprom.h>
  61 #include <media/v4l2-chip-ident.h>
  62
  63 /* var to keep track of the number of array elements in use */
  64 int ivtv_cards_active = 0;
  65
  66 /* If you have already X v4l cards, then set this to X. This way
  67    the device numbers stay matched. Example: you have a WinTV card
  68    without radio and a PVR-350 with. Normally this would give a
  69    video1 device together with a radio0 device for the PVR. By
  70    setting this to 1 you ensure that radio0 is now also radio1. */
  71 int ivtv_first_minor = 0;
  72
  73 /* Master variable for all ivtv info */
  74 struct ivtv *ivtv_cards[IVTV_MAX_CARDS];
  75
  76 /* Protects ivtv_cards_active */
  77 spinlock_t ivtv_cards_lock = SPIN_LOCK_UNLOCKED;
  78
  79 /* add your revision and whatnot here */
  80 static struct pci_device_id ivtv_pci_tbl[] __devinitdata = {
  81         {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV15,
  82          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  83         {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV16,
  84          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  85         {0,}
  86 };
  87
  88 MODULE_DEVICE_TABLE(pci,ivtv_pci_tbl);
  89
  90 const u32 yuv_offset[4] = {
  91         IVTV_YUV_BUFFER_OFFSET,
  92         IVTV_YUV_BUFFER_OFFSET_1,
  93         IVTV_YUV_BUFFER_OFFSET_2,
  94         IVTV_YUV_BUFFER_OFFSET_3
  95 };
  96
  97 /* Parameter declarations */
  98 static int cardtype[IVTV_MAX_CARDS];
  99 static int tuner[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 100 static int radio[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 101
 102 static int cardtype_c = 1;
 103 static int tuner_c = 1;
 104 static int radio_c = 1;
 105 static char pal[] = "--";
 106 static char secam[] = "--";
 107 static char ntsc[] = "-";
 108
 109 /* Buffers */
 110 static int enc_mpg_buffers = IVTV_DEFAULT_ENC_MPG_BUFFERS;
 111 static int enc_yuv_buffers = IVTV_DEFAULT_ENC_YUV_BUFFERS;
 112 static int enc_vbi_buffers = IVTV_DEFAULT_ENC_VBI_BUFFERS;
 113 static int enc_pcm_buffers = IVTV_DEFAULT_ENC_PCM_BUFFERS;
 114 static int dec_mpg_buffers = IVTV_DEFAULT_DEC_MPG_BUFFERS;
 115 static int dec_yuv_buffers = IVTV_DEFAULT_DEC_YUV_BUFFERS;
 116 static int dec_vbi_buffers = IVTV_DEFAULT_DEC_VBI_BUFFERS;
 117
 118 static int ivtv_yuv_mode = 0;
 119 static int ivtv_yuv_threshold=480;
 120 static int ivtv_pci_latency = 1;
 121
 122 int ivtv_debug = 0;
 123
 124 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         itv->lock = SPIN_LOCK_UNLOCKED;
 629         itv->dma_reg_lock = SPIN_LOCK_UNLOCKED;
 630
 631         itv->vbi.work_queues = create_workqueue("ivtv_vbi");
 632         if (itv->vbi.work_queues == NULL) {
 633                 IVTV_ERR("Could not create VBI workqueue\n");
 634                 return -1;
 635         }
 636
 637         itv->yuv_info.work_queues = create_workqueue("ivtv_yuv");
 638         if (itv->yuv_info.work_queues == NULL) {
 639                 IVTV_ERR("Could not create YUV workqueue\n");
 640                 destroy_workqueue(itv->vbi.work_queues);
 641                 return -1;
 642         }
 643
 644         INIT_WORK(&itv->vbi.work_queue, vbi_work_handler);
 645         INIT_WORK(&itv->yuv_info.work_queue, ivtv_yuv_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->audio_stereo_mode = AUDIO_STEREO;
 664         itv->audio_bilingual_mode = AUDIO_MONO_LEFT;
 665
 666         /* Ctrls */
 667         itv->speed = 1000;
 668
 669         /* VBI */
 670         itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
 671         itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
 672
 673         /* OSD */
 674         itv->osd_global_alpha_state = 1;
 675         itv->osd_global_alpha = 255;
 676
 677         /* YUV */
 678         atomic_set(&itv->yuv_info.next_dma_frame, -1);
 679         itv->yuv_info.lace_mode = ivtv_yuv_mode;
 680         itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
 681         return 0;
 682 }
 683
 684 /* Second initialization part. Here the card type has been
 685    autodetected. */
 686 static void __devinit ivtv_init_struct2(struct ivtv *itv)
 687 {
 688         int i;
 689
 690         for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
 691                 if (itv->card->video_inputs[i].video_type == 0)
 692                         break;
 693         itv->nof_inputs = i;
 694         for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
 695                 if (itv->card->audio_inputs[i].audio_type == 0)
 696                         break;
 697         itv->nof_audio_inputs = i;
 698
 699         /* 0x00EF = saa7114(239) 0x00F0 = saa7115(240) 0x0106 = micro */
 700         if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
 701                 itv->digitizer = 0xF1;
 702         else if (itv->card->hw_all & IVTV_HW_SAA7114)
 703                 itv->digitizer = 0xEF;
 704         else /* cx25840 */
 705                 itv->digitizer = 0x140;
 706
 707         if (itv->card->hw_all & IVTV_HW_CX25840) {
 708                 itv->vbi.sliced_size = 288;  /* multiple of 16, real size = 284 */
 709         } else {
 710                 itv->vbi.sliced_size = 64;   /* multiple of 16, real size = 52 */
 711         }
 712
 713         /* Find tuner input */
 714         for (i = 0; i < itv->nof_inputs; i++) {
 715                 if (itv->card->video_inputs[i].video_type ==
 716                                 IVTV_CARD_INPUT_VID_TUNER)
 717                         break;
 718         }
 719         if (i == itv->nof_inputs)
 720                 i = 0;
 721         itv->active_input = i;
 722         itv->audio_input = itv->card->video_inputs[i].audio_index;
 723         if (itv->card->hw_all & IVTV_HW_CX25840)
 724                 itv->video_dec_func = ivtv_cx25840;
 725         else if (itv->card->hw_all & IVTV_HW_SAA717X)
 726                 itv->video_dec_func = ivtv_saa717x;
 727         else
 728                 itv->video_dec_func = ivtv_saa7115;
 729 }
 730
 731 static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *dev,
 732                           const struct pci_device_id *pci_id)
 733 {
 734         u16 cmd;
 735         unsigned char pci_latency;
 736
 737         IVTV_DEBUG_INFO("Enabling pci device\n");
 738
 739         if (pci_enable_device(dev)) {
 740                 IVTV_ERR("Can't enable device %d!\n", itv->num);
 741                 return -EIO;
 742         }
 743         if (pci_set_dma_mask(dev, 0xffffffff)) {
 744                 IVTV_ERR("No suitable DMA available on card %d.\n", itv->num);
 745                 return -EIO;
 746         }
 747         if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
 748                 IVTV_ERR("Cannot request encoder memory region on card %d.\n", itv->num);
 749                 return -EIO;
 750         }
 751
 752         if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
 753                                 IVTV_REG_SIZE, "ivtv registers")) {
 754                 IVTV_ERR("Cannot request register memory region on card %d.\n", itv->num);
 755                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 756                 return -EIO;
 757         }
 758
 759         if (itv->has_cx23415 &&
 760             !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
 761                                 IVTV_DECODER_SIZE, "ivtv decoder")) {
 762                 IVTV_ERR("Cannot request decoder memory region on card %d.\n", itv->num);
 763                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 764                 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
 765                 return -EIO;
 766         }
 767
 768         /* Check for bus mastering */
 769         pci_read_config_word(dev, PCI_COMMAND, &cmd);
 770         if (!(cmd & PCI_COMMAND_MASTER)) {
 771                 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
 772                 pci_set_master(dev);
 773                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
 774                 if (!(cmd & PCI_COMMAND_MASTER)) {
 775                         IVTV_ERR("Bus Mastering is not enabled\n");
 776                         return -ENXIO;
 777                 }
 778         }
 779         IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
 780
 781         pci_read_config_byte(dev, PCI_CLASS_REVISION, &itv->card_rev);
 782         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 783
 784         if (pci_latency < 64 && ivtv_pci_latency) {
 785                 IVTV_INFO("Unreasonably low latency timer, "
 786                                "setting to 64 (was %d)\n", pci_latency);
 787                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
 788                 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 789         }
 790         /* This config space value relates to DMA latencies. The
 791            default value 0x8080 is too low however and will lead
 792            to DMA errors. 0xffff is the max value which solves
 793            these problems. */
 794         pci_write_config_dword(dev, 0x40, 0xffff);
 795
 796         IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
 797                    "irq: %d, latency: %d, memory: 0x%lx\n",
 798                    itv->dev->device, itv->card_rev, dev->bus->number,
 799                    PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
 800                    itv->dev->irq, pci_latency, (unsigned long)itv->base_addr);
 801
 802         return 0;
 803 }
 804
 805 static void ivtv_request_module(struct ivtv *itv, const char *name)
 806 {
 807         if (request_module(name) != 0) {
 808                 IVTV_ERR("Failed to load module %s\n", name);
 809         } else {
 810                 IVTV_DEBUG_INFO("Loaded module %s\n", name);
 811         }
 812 }
 813
 814 static void ivtv_load_and_init_modules(struct ivtv *itv)
 815 {
 816         struct v4l2_control ctrl;
 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                 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
 899                 ctrl.id = V4L2_CID_PRIVATE_BASE;
 900                 ctrl.value = itv->pvr150_workaround;
 901                 itv->video_dec_func(itv, VIDIOC_S_CTRL, &ctrl);
 902
 903                 itv->vbi.raw_decoder_line_size = 1444;
 904                 itv->vbi.raw_decoder_sav_odd_field = 0x20;
 905                 itv->vbi.raw_decoder_sav_even_field = 0x60;
 906                 itv->vbi.sliced_decoder_line_size = 272;
 907                 itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
 908                 itv->vbi.sliced_decoder_sav_even_field = 0xF0;
 909         }
 910
 911         if (hw & IVTV_HW_SAA711X) {
 912                 struct v4l2_chip_ident v = { V4L2_CHIP_MATCH_I2C_DRIVER, I2C_DRIVERID_SAA711X };
 913
 914                 /* determine the exact saa711x model */
 915                 itv->hw_flags &= ~IVTV_HW_SAA711X;
 916
 917                 ivtv_saa7115(itv, VIDIOC_G_CHIP_IDENT, &v);
 918                 if (v.ident == V4L2_IDENT_SAA7114) {
 919                         itv->hw_flags |= IVTV_HW_SAA7114;
 920                         /* VBI is not yet supported by the saa7114 driver. */
 921                         itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
 922                 }
 923                 else {
 924                         itv->hw_flags |= IVTV_HW_SAA7115;
 925                 }
 926                 itv->vbi.raw_decoder_line_size = 1443;
 927                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 928                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 929                 itv->vbi.sliced_decoder_line_size = 51;
 930                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 931                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 932         }
 933
 934         if (hw & IVTV_HW_SAA717X) {
 935                 itv->vbi.raw_decoder_line_size = 1443;
 936                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 937                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 938                 itv->vbi.sliced_decoder_line_size = 51;
 939                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 940                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 941         }
 942 }
 943
 944 static int __devinit ivtv_probe(struct pci_dev *dev,
 945                                 const struct pci_device_id *pci_id)
 946 {
 947         int retval = 0;
 948         int video_input;
 949         int yuv_buf_size;
 950         int vbi_buf_size;
 951         int fw_retry_count = 3;
 952         struct ivtv *itv;
 953         struct v4l2_frequency vf;
 954
 955         spin_lock(&ivtv_cards_lock);
 956
 957         /* Make sure we've got a place for this card */
 958         if (ivtv_cards_active == IVTV_MAX_CARDS) {
 959                 printk(KERN_ERR "ivtv:  Maximum number of cards detected (%d).\n",
 960                               ivtv_cards_active);
 961                 spin_unlock(&ivtv_cards_lock);
 962                 return -ENOMEM;
 963         }
 964
 965         itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
 966         if (itv == 0) {
 967                 spin_unlock(&ivtv_cards_lock);
 968                 return -ENOMEM;
 969         }
 970         ivtv_cards[ivtv_cards_active] = itv;
 971         itv->dev = dev;
 972         itv->num = ivtv_cards_active++;
 973         snprintf(itv->name, sizeof(itv->name) - 1, "ivtv%d", itv->num);
 974         if (itv->num) {
 975                 printk(KERN_INFO "ivtv:  ======================  NEXT CARD  ======================\n");
 976         }
 977
 978         spin_unlock(&ivtv_cards_lock);
 979
 980         ivtv_process_options(itv);
 981         if (itv->options.cardtype == -1) {
 982                 retval = -ENODEV;
 983                 goto err;
 984         }
 985         if (ivtv_init_struct1(itv)) {
 986                 retval = -ENOMEM;
 987                 goto err;
 988         }
 989
 990         IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv->base_addr);
 991
 992         /* PCI Device Setup */
 993         if ((retval = ivtv_setup_pci(itv, dev, pci_id)) != 0) {
 994                 if (retval == -EIO)
 995                         goto free_workqueue;
 996                 else if (retval == -ENXIO)
 997                         goto free_mem;
 998         }
 999         /* save itv in the pci struct for later use */
1000         pci_set_drvdata(dev, itv);
1001
1002         /* map io memory */
1003         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1004                    itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1005         itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
1006                                        IVTV_ENCODER_SIZE);
1007         if (!itv->enc_mem) {
1008                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1009                 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1010                 retval = -ENOMEM;
1011                 goto free_mem;
1012         }
1013
1014         if (itv->has_cx23415) {
1015                 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1016                                 itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1017                 itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
1018                                 IVTV_DECODER_SIZE);
1019                 if (!itv->dec_mem) {
1020                         IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1021                         IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1022                         retval = -ENOMEM;
1023                         goto free_mem;
1024                 }
1025         }
1026         else {
1027                 itv->dec_mem = itv->enc_mem;
1028         }
1029
1030         /* map registers memory */
1031         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1032                    itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1033         itv->reg_mem =
1034             ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1035         if (!itv->reg_mem) {
1036                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1037                 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1038                 retval = -ENOMEM;
1039                 goto free_io;
1040         }
1041
1042         while (--fw_retry_count > 0) {
1043                 /* load firmware */
1044                 if (ivtv_firmware_init(itv) == 0)
1045                         break;
1046                 if (fw_retry_count > 1)
1047                         IVTV_WARN("Retry loading firmware\n");
1048         }
1049         if (fw_retry_count == 0) {
1050                 IVTV_ERR("Error initializing firmware\n");
1051                 goto free_i2c;
1052         }
1053
1054         /* Try and get firmware versions */
1055         IVTV_DEBUG_INFO("Getting firmware version..\n");
1056         ivtv_firmware_versions(itv);
1057
1058         /* Check yuv output filter table */
1059         if (itv->has_cx23415) ivtv_yuv_filter_check(itv);
1060
1061         ivtv_gpio_init(itv);
1062
1063         /* active i2c  */
1064         IVTV_DEBUG_INFO("activating i2c...\n");
1065         if (init_ivtv_i2c(itv)) {
1066                 IVTV_ERR("Could not initialize i2c\n");
1067                 goto free_irq;
1068         }
1069
1070         IVTV_DEBUG_INFO("Active card count: %d.\n", ivtv_cards_active);
1071
1072         if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1073 #ifdef CONFIG_VIDEO_TVEEPROM_MODULE
1074                 ivtv_request_module(itv, "tveeprom");
1075 #endif
1076                 /* Based on the model number the cardtype may be changed.
1077                    The PCI IDs are not always reliable. */
1078                 ivtv_process_eeprom(itv);
1079         }
1080
1081         if (itv->std == 0) {
1082                 itv->std = V4L2_STD_NTSC_M;
1083         }
1084
1085         if (itv->options.tuner == -1) {
1086                 int i;
1087
1088                 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1089                         if ((itv->std & itv->card->tuners[i].std) == 0)
1090                                 continue;
1091                         itv->options.tuner = itv->card->tuners[i].tuner;
1092                         break;
1093                 }
1094         }
1095         /* if no tuner was found, then pick the first tuner in the card list */
1096         if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1097                 itv->std = itv->card->tuners[0].std;
1098                 itv->options.tuner = itv->card->tuners[0].tuner;
1099         }
1100         if (itv->options.radio == -1)
1101                 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1102
1103         /* The card is now fully identified, continue with card-specific
1104            initialization. */
1105         ivtv_init_struct2(itv);
1106
1107         ivtv_load_and_init_modules(itv);
1108
1109         if (itv->std & V4L2_STD_525_60) {
1110                 itv->is_60hz = 1;
1111                 itv->is_out_60hz = 1;
1112         } else {
1113                 itv->is_50hz = 1;
1114                 itv->is_out_50hz = 1;
1115         }
1116         itv->params.video_gop_size = itv->is_60hz ? 15 : 12;
1117
1118         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1119         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1120         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1121
1122         /* 0x15180 == 720 * 480 / 4, 0x19500 == 720 * 576 / 4 */
1123         yuv_buf_size = itv->is_60hz ? 0x15180 : 0x19500;
1124         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = yuv_buf_size / 2;
1125         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = yuv_buf_size / 8;
1126
1127         /* Setup VBI Raw Size. Should be big enough to hold PAL.
1128            It is possible to switch between PAL and NTSC, so we need to
1129            take the largest size here. */
1130         /* 1456 is multiple of 16, real size = 1444 */
1131         itv->vbi.raw_size = 1456;
1132         /* We use a buffer size of 1/2 of the total size needed for a
1133            frame. This is actually very useful, since we now receive
1134            a field at a time and that makes 'compressing' the raw data
1135            down to size by stripping off the SAV codes a lot easier.
1136            Note: having two different buffer sizes prevents standard
1137            switching on the fly. We need to find a better solution... */
1138         vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1139         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1140         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1141
1142         if (itv->options.radio > 0)
1143                 itv->v4l2_cap |= V4L2_CAP_RADIO;
1144
1145         retval = ivtv_streams_setup(itv);
1146         if (retval) {
1147                 IVTV_ERR("Error %d setting up streams\n", retval);
1148                 goto free_i2c;
1149         }
1150
1151         /* Start Threads */
1152         IVTV_DEBUG_INFO("Starting Threads\n");
1153
1154         /* Decoder Thread */
1155         if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1156                 ivtv_init_mpeg_decoder(itv);
1157         }
1158
1159         IVTV_DEBUG_IRQ("Masking interrupts\n");
1160         /* clear interrupt mask, effectively disabling interrupts */
1161         ivtv_set_irq_mask(itv, 0xffffffff);
1162
1163         /* Register IRQ */
1164         retval = request_irq(itv->dev->irq, ivtv_irq_handler,
1165                              SA_SHIRQ | SA_INTERRUPT, itv->name, (void *)itv);
1166         if (retval) {
1167                 IVTV_ERR("Failed to register irq %d\n", retval);
1168                 goto free_streams;
1169         }
1170
1171         /* On a cx23416 this seems to be able to enable DMA to the chip? */
1172         if (!itv->has_cx23415)
1173                 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1174
1175         /* Default interrupts enabled. For the PVR350 this includes the
1176            decoder VSYNC interrupt, which is always on. It is not only used
1177            during decoding but also by the OSD.
1178            Some old PVR250 cards had a cx23415, so testing for that is too
1179            general. Instead test if the card has video output capability. */
1180         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1181                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1182         else
1183                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1184
1185         if (itv->options.tuner > -1) {
1186                 struct tuner_setup setup;
1187
1188                 setup.addr = ADDR_UNSET;
1189                 setup.type = itv->options.tuner;
1190                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1191 #ifdef HAVE_XC3028
1192                 setup.initmode = V4L2_TUNER_ANALOG_TV;
1193                 if (itv->options.tuner == TUNER_XCEIVE_XC3028) {
1194                         setup.gpio_write = ivtv_reset_tuner_gpio;
1195                         setup.gpio_priv = itv;
1196                 }
1197 #endif
1198                 ivtv_call_i2c_clients(itv, TUNER_SET_TYPE_ADDR, &setup);
1199         }
1200
1201         vf.tuner = 0;
1202         vf.type = V4L2_TUNER_ANALOG_TV;
1203         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1204         if (itv->std & V4L2_STD_NTSC_M) {
1205                 /* Why on earth? */
1206                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1207         }
1208
1209         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1210            are not. */
1211         itv->tuner_std = itv->std;
1212
1213         video_input = itv->active_input;
1214         itv->active_input++;    /* Force update of input */
1215         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_INPUT, &video_input);
1216
1217         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1218            in one place. */
1219         itv->std++;             /* Force full standard initialization */
1220         itv->std_out = itv->std;
1221         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_STD, &itv->tuner_std);
1222         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_FREQUENCY, &vf);
1223         if (itv->has_cx23415)
1224                 ivtv_set_osd_alpha(itv);
1225
1226         IVTV_INFO("Initialized %s, card #%d\n", itv->card_name, itv->num);
1227
1228         return 0;
1229
1230       free_irq:
1231         free_irq(itv->dev->irq, (void *)itv);
1232       free_streams:
1233         ivtv_streams_cleanup(itv);
1234       free_i2c:
1235         exit_ivtv_i2c(itv);
1236       free_io:
1237         ivtv_iounmap(itv);
1238       free_mem:
1239         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1240         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1241         if (itv->has_cx23415)
1242                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1243       free_workqueue:
1244         destroy_workqueue(itv->vbi.work_queues);
1245         destroy_workqueue(itv->yuv_info.work_queues);
1246       err:
1247         if (retval == 0)
1248                 retval = -ENODEV;
1249         IVTV_ERR("Error %d on initialization\n", retval);
1250
1251         kfree(ivtv_cards[ivtv_cards_active]);
1252         ivtv_cards[ivtv_cards_active] = NULL;
1253         return retval;
1254 }
1255
1256 static void ivtv_remove(struct pci_dev *pci_dev)
1257 {
1258         struct ivtv *itv = pci_get_drvdata(pci_dev);
1259
1260         IVTV_DEBUG_INFO("Removing Card #%d.\n", itv->num);
1261
1262         /* Stop all captures */
1263         IVTV_DEBUG_INFO(" Stopping all streams.\n");
1264         if (atomic_read(&itv->capturing) > 0)
1265                 ivtv_stop_all_captures(itv);
1266
1267         /* Stop all decoding */
1268         IVTV_DEBUG_INFO(" Stopping decoding.\n");
1269         if (atomic_read(&itv->decoding) > 0) {
1270                 int type;
1271
1272                 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1273                         type = IVTV_DEC_STREAM_TYPE_YUV;
1274                 else
1275                         type = IVTV_DEC_STREAM_TYPE_MPG;
1276                 ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1277                         VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1278         }
1279
1280         /* Interrupts */
1281         IVTV_DEBUG_INFO(" Disabling interrupts.\n");
1282         ivtv_set_irq_mask(itv, 0xffffffff);
1283         del_timer_sync(&itv->dma_timer);
1284
1285         /* Stop all Work Queues */
1286         IVTV_DEBUG_INFO(" Stop Work Queues.\n");
1287         flush_workqueue(itv->vbi.work_queues);
1288         flush_workqueue(itv->yuv_info.work_queues);
1289         destroy_workqueue(itv->vbi.work_queues);
1290         destroy_workqueue(itv->yuv_info.work_queues);
1291
1292         IVTV_DEBUG_INFO(" Stopping Firmware.\n");
1293         ivtv_halt_firmware(itv);
1294
1295         IVTV_DEBUG_INFO(" Unregistering v4l devices.\n");
1296         ivtv_streams_cleanup(itv);
1297         IVTV_DEBUG_INFO(" Freeing dma resources.\n");
1298         ivtv_udma_free(itv);
1299
1300         exit_ivtv_i2c(itv);
1301
1302         IVTV_DEBUG_INFO(" Releasing irq.\n");
1303         free_irq(itv->dev->irq, (void *)itv);
1304
1305         if (itv->dev) {
1306                 ivtv_iounmap(itv);
1307         }
1308
1309         IVTV_DEBUG_INFO(" Releasing mem.\n");
1310         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1311         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1312         if (itv->has_cx23415)
1313                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1314
1315         pci_disable_device(itv->dev);
1316
1317         IVTV_INFO("Removed %s, card #%d\n", itv->card_name, itv->num);
1318 }
1319
1320 /* define a pci_driver for card detection */
1321 static struct pci_driver ivtv_pci_driver = {
1322       .name =     "ivtv",
1323       .id_table = ivtv_pci_tbl,
1324       .probe =    ivtv_probe,
1325       .remove =   ivtv_remove,
1326 };
1327
1328 static int module_start(void)
1329 {
1330         printk(KERN_INFO "ivtv:  ==================== START INIT IVTV ====================\n");
1331         printk(KERN_INFO "ivtv:  version %s (" VERMAGIC_STRING ") loading\n", IVTV_VERSION);
1332
1333         memset(ivtv_cards, 0, sizeof(ivtv_cards));
1334
1335         /* Validate parameters */
1336         if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1337                 printk(KERN_ERR "ivtv:  ivtv_first_minor must be between 0 and %d. Exiting...\n",
1338                      IVTV_MAX_CARDS - 1);
1339                 return -1;
1340         }
1341
1342         if (ivtv_debug < 0 || ivtv_debug > 511) {
1343                 ivtv_debug = 0;
1344                 printk(KERN_INFO "ivtv:  debug value must be >= 0 and <= 511!\n");
1345         }
1346
1347         if (pci_module_init(&ivtv_pci_driver)) {
1348                 printk(KERN_ERR "ivtv:  Error detecting PCI card\n");
1349                 return -ENODEV;
1350         }
1351         printk(KERN_INFO "ivtv:  ====================  END INIT IVTV  ====================\n");
1352         return 0;
1353 }
1354
1355 static void module_cleanup(void)
1356 {
1357         int i, j;
1358
1359         for (i = 0; i < ivtv_cards_active; i++) {
1360                 if (ivtv_cards[i] == NULL)
1361                         continue;
1362                 for (j = 0; j < IVTV_VBI_FRAMES; j++) {
1363                         kfree(ivtv_cards[i]->vbi.sliced_mpeg_data[j]);
1364                 }
1365                 kfree(ivtv_cards[i]);
1366         }
1367         pci_unregister_driver(&ivtv_pci_driver);
1368 }
1369
1370 EXPORT_SYMBOL(ivtv_set_irq_mask);
1371 EXPORT_SYMBOL(ivtv_cards_active);
1372 EXPORT_SYMBOL(ivtv_cards);
1373 EXPORT_SYMBOL(ivtv_api);
1374 EXPORT_SYMBOL(ivtv_vapi);
1375 EXPORT_SYMBOL(ivtv_vapi_result);
1376 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1377 EXPORT_SYMBOL(ivtv_debug);
1378 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1379 EXPORT_SYMBOL(ivtv_udma_setup);
1380 EXPORT_SYMBOL(ivtv_udma_unmap);
1381 EXPORT_SYMBOL(ivtv_udma_alloc);
1382 EXPORT_SYMBOL(ivtv_udma_prepare);
1383
1384 module_init(module_start);
1385 module_exit(module_cleanup);