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