drivers/media/video/cx18/cx18-driver.c

   1 /*
   2  *  cx18 driver initialization and card probing
   3  *
   4  *  Derived from ivtv-driver.c
   5  *
   6  *  Copyright (C) 2007  Hans Verkuil <hverkuil@xs4all.nl>
   7  *  Copyright (C) 2008  Andy Walls <awalls@radix.net>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  22  *  02111-1307  USA
  23  */
  24
  25 #include "cx18-driver.h"
  26 #include "cx18-io.h"
  27 #include "cx18-version.h"
  28 #include "cx18-cards.h"
  29 #include "cx18-i2c.h"
  30 #include "cx18-irq.h"
  31 #include "cx18-gpio.h"
  32 #include "cx18-firmware.h"
  33 #include "cx18-queue.h"
  34 #include "cx18-streams.h"
  35 #include "cx18-av-core.h"
  36 #include "cx18-scb.h"
  37 #include "cx18-mailbox.h"
  38 #include "cx18-ioctl.h"
  39 #include "tuner-xc2028.h"
  40
  41 #include <media/tveeprom.h>
  42
  43 /* If you have already X v4l cards, then set this to X. This way
  44    the device numbers stay matched. Example: you have a WinTV card
  45    without radio and a Compro H900 with. Normally this would give a
  46    video1 device together with a radio0 device for the Compro. By
  47    setting this to 1 you ensure that radio0 is now also radio1. */
  48 int cx18_first_minor;
  49
  50 /* add your revision and whatnot here */
  51 static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
  52         {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
  53          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  54         {0,}
  55 };
  56
  57 MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
  58
  59 static atomic_t cx18_instance = ATOMIC_INIT(0);
  60
  61 /* Parameter declarations */
  62 static int cardtype[CX18_MAX_CARDS];
  63 static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  64                                      -1, -1, -1, -1, -1, -1, -1, -1,
  65                                      -1, -1, -1, -1, -1, -1, -1, -1,
  66                                      -1, -1, -1, -1, -1, -1, -1, -1 };
  67 static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  68                                      -1, -1, -1, -1, -1, -1, -1, -1,
  69                                      -1, -1, -1, -1, -1, -1, -1, -1,
  70                                      -1, -1, -1, -1, -1, -1, -1, -1 };
  71 static unsigned cardtype_c = 1;
  72 static unsigned tuner_c = 1;
  73 static unsigned radio_c = 1;
  74 static char pal[] = "--";
  75 static char secam[] = "--";
  76 static char ntsc[] = "-";
  77
  78 /* Buffers */
  79 static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
  80 static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
  81 static int enc_idx_buffers = CX18_DEFAULT_ENC_IDX_BUFFERS;
  82 static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
  83 static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
  84 static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
  85
  86 static int enc_ts_bufsize = CX18_DEFAULT_ENC_TS_BUFSIZE;
  87 static int enc_mpg_bufsize = CX18_DEFAULT_ENC_MPG_BUFSIZE;
  88 static int enc_idx_bufsize = CX18_DEFAULT_ENC_IDX_BUFSIZE;
  89 static int enc_yuv_bufsize = CX18_DEFAULT_ENC_YUV_BUFSIZE;
  90 static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE;
  91
  92 static int enc_ts_bufs = -1;
  93 static int enc_mpg_bufs = -1;
  94 static int enc_idx_bufs = CX18_MAX_FW_MDLS_PER_STREAM;
  95 static int enc_yuv_bufs = -1;
  96 static int enc_vbi_bufs = -1;
  97 static int enc_pcm_bufs = -1;
  98
  99
 100 static int cx18_pci_latency = 1;
 101
 102 static int mmio_ndelay;
 103 static int retry_mmio = 1;
 104
 105 int cx18_debug;
 106
 107 module_param_array(tuner, int, &tuner_c, 0644);
 108 module_param_array(radio, bool, &radio_c, 0644);
 109 module_param_array(cardtype, int, &cardtype_c, 0644);
 110 module_param_string(pal, pal, sizeof(pal), 0644);
 111 module_param_string(secam, secam, sizeof(secam), 0644);
 112 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
 113 module_param_named(debug, cx18_debug, int, 0644);
 114 module_param(mmio_ndelay, int, 0644);
 115 module_param(retry_mmio, int, 0644);
 116 module_param(cx18_pci_latency, int, 0644);
 117 module_param(cx18_first_minor, int, 0644);
 118
 119 module_param(enc_ts_buffers, int, 0644);
 120 module_param(enc_mpg_buffers, int, 0644);
 121 module_param(enc_idx_buffers, int, 0644);
 122 module_param(enc_yuv_buffers, int, 0644);
 123 module_param(enc_vbi_buffers, int, 0644);
 124 module_param(enc_pcm_buffers, int, 0644);
 125
 126 module_param(enc_ts_bufsize, int, 0644);
 127 module_param(enc_mpg_bufsize, int, 0644);
 128 module_param(enc_idx_bufsize, int, 0644);
 129 module_param(enc_yuv_bufsize, int, 0644);
 130 module_param(enc_pcm_bufsize, int, 0644);
 131
 132 module_param(enc_ts_bufs, int, 0644);
 133 module_param(enc_mpg_bufs, int, 0644);
 134 module_param(enc_idx_bufs, int, 0644);
 135 module_param(enc_yuv_bufs, int, 0644);
 136 module_param(enc_vbi_bufs, int, 0644);
 137 module_param(enc_pcm_bufs, int, 0644);
 138
 139 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
 140                         "\t\t\tsee tuner.h for values");
 141 MODULE_PARM_DESC(radio,
 142                  "Enable or disable the radio. Use only if autodetection\n"
 143                  "\t\t\tfails. 0 = disable, 1 = enable");
 144 MODULE_PARM_DESC(cardtype,
 145                  "Only use this option if your card is not detected properly.\n"
 146                  "\t\tSpecify card type:\n"
 147                  "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
 148                  "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
 149                  "\t\t\t 3 = Compro VideoMate H900\n"
 150                  "\t\t\t 4 = Yuan MPC718\n"
 151                  "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
 152                  "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
 153                  "\t\t\t 7 = Leadtek WinFast PVR2100\n"
 154                  "\t\t\t 8 = Leadtek WinFast DVR3100 H\n"
 155                  "\t\t\t 0 = Autodetect (default)\n"
 156                  "\t\t\t-1 = Ignore this card\n\t\t");
 157 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
 158 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
 159 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
 160 MODULE_PARM_DESC(debug,
 161                  "Debug level (bitmask). Default: 0\n"
 162                  "\t\t\t  1/0x0001: warning\n"
 163                  "\t\t\t  2/0x0002: info\n"
 164                  "\t\t\t  4/0x0004: mailbox\n"
 165                  "\t\t\t  8/0x0008: dma\n"
 166                  "\t\t\t 16/0x0010: ioctl\n"
 167                  "\t\t\t 32/0x0020: file\n"
 168                  "\t\t\t 64/0x0040: i2c\n"
 169                  "\t\t\t128/0x0080: irq\n"
 170                  "\t\t\t256/0x0100: high volume\n");
 171 MODULE_PARM_DESC(cx18_pci_latency,
 172                  "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
 173                  "\t\t\tDefault: Yes");
 174 MODULE_PARM_DESC(retry_mmio,
 175                  "(Deprecated) MMIO writes are now always checked and retried\n"
 176                  "\t\t\tEffectively: 1 [Yes]");
 177 MODULE_PARM_DESC(mmio_ndelay,
 178                  "(Deprecated) MMIO accesses are now never purposely delayed\n"
 179                  "\t\t\tEffectively: 0 ns");
 180 MODULE_PARM_DESC(enc_ts_buffers,
 181                  "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
 182                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
 183 MODULE_PARM_DESC(enc_ts_bufsize,
 184                  "Size of an encoder TS buffer (kB)\n"
 185                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE));
 186 MODULE_PARM_DESC(enc_ts_bufs,
 187                  "Number of encoder TS buffers\n"
 188                  "\t\t\tDefault is computed from other enc_ts_* parameters");
 189 MODULE_PARM_DESC(enc_mpg_buffers,
 190                  "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
 191                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
 192 MODULE_PARM_DESC(enc_mpg_bufsize,
 193                  "Size of an encoder MPG buffer (kB)\n"
 194                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE));
 195 MODULE_PARM_DESC(enc_mpg_bufs,
 196                  "Number of encoder MPG buffers\n"
 197                  "\t\t\tDefault is computed from other enc_mpg_* parameters");
 198 MODULE_PARM_DESC(enc_idx_buffers,
 199                  "(Deprecated) Encoder IDX buffer memory (MB)\n"
 200                  "\t\t\tIgnored, except 0 disables IDX buffer allocations\n"
 201                  "\t\t\tDefault: 1 [Enabled]");
 202 MODULE_PARM_DESC(enc_idx_bufsize,
 203                  "Size of an encoder IDX buffer (kB)\n"
 204                  "\t\t\tAllowed values are multiples of 1.5 kB rounded up\n"
 205                  "\t\t\t(multiples of size required for 64 index entries)\n"
 206                  "\t\t\tDefault: 2");
 207 MODULE_PARM_DESC(enc_idx_bufs,
 208                  "Number of encoder IDX buffers\n"
 209                  "\t\t\tDefault: " __stringify(CX18_MAX_FW_MDLS_PER_STREAM));
 210 MODULE_PARM_DESC(enc_yuv_buffers,
 211                  "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
 212                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
 213 MODULE_PARM_DESC(enc_yuv_bufsize,
 214                  "Size of an encoder YUV buffer (kB)\n"
 215                  "\t\t\tAllowed values are multiples of 33.75 kB rounded up\n"
 216                  "\t\t\t(multiples of size required for 32 screen lines)\n"
 217                  "\t\t\tDefault: 102");
 218 MODULE_PARM_DESC(enc_yuv_bufs,
 219                  "Number of encoder YUV buffers\n"
 220                  "\t\t\tDefault is computed from other enc_yuv_* parameters");
 221 MODULE_PARM_DESC(enc_vbi_buffers,
 222                  "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
 223                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
 224 MODULE_PARM_DESC(enc_vbi_bufs,
 225                  "Number of encoder VBI buffers\n"
 226                  "\t\t\tDefault is computed from enc_vbi_buffers");
 227 MODULE_PARM_DESC(enc_pcm_buffers,
 228                  "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
 229                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
 230 MODULE_PARM_DESC(enc_pcm_bufsize,
 231                  "Size of an encoder PCM buffer (kB)\n"
 232                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE));
 233 MODULE_PARM_DESC(enc_pcm_bufs,
 234                  "Number of encoder PCM buffers\n"
 235                  "\t\t\tDefault is computed from other enc_pcm_* parameters");
 236
 237 MODULE_PARM_DESC(cx18_first_minor, "Set device node number assigned to first card");
 238
 239 MODULE_AUTHOR("Hans Verkuil");
 240 MODULE_DESCRIPTION("CX23418 driver");
 241 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
 242 MODULE_LICENSE("GPL");
 243
 244 MODULE_VERSION(CX18_VERSION);
 245
 246 /* Generic utility functions */
 247 int cx18_msleep_timeout(unsigned int msecs, int intr)
 248 {
 249         long int timeout = msecs_to_jiffies(msecs);
 250         int sig;
 251
 252         do {
 253                 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
 254                 timeout = schedule_timeout(timeout);
 255                 sig = intr ? signal_pending(current) : 0;
 256         } while (!sig && timeout);
 257         return sig;
 258 }
 259
 260 /* Release ioremapped memory */
 261 static void cx18_iounmap(struct cx18 *cx)
 262 {
 263         if (cx == NULL)
 264                 return;
 265
 266         /* Release io memory */
 267         if (cx->enc_mem != NULL) {
 268                 CX18_DEBUG_INFO("releasing enc_mem\n");
 269                 iounmap(cx->enc_mem);
 270                 cx->enc_mem = NULL;
 271         }
 272 }
 273
 274 static void cx18_eeprom_dump(struct cx18 *cx, unsigned char *eedata, int len)
 275 {
 276         int i;
 277
 278         CX18_INFO("eeprom dump:\n");
 279         for (i = 0; i < len; i++) {
 280                 if (0 == (i % 16))
 281                         CX18_INFO("eeprom %02x:", i);
 282                 printk(KERN_CONT " %02x", eedata[i]);
 283                 if (15 == (i % 16))
 284                         printk(KERN_CONT "\n");
 285         }
 286 }
 287
 288 /* Hauppauge card? get values from tveeprom */
 289 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
 290 {
 291         struct i2c_client c;
 292         u8 eedata[256];
 293
 294         memset(&c, 0, sizeof(c));
 295         strlcpy(c.name, "cx18 tveeprom tmp", sizeof(c.name));
 296         c.adapter = &cx->i2c_adap[0];
 297         c.addr = 0xA0 >> 1;
 298
 299         memset(tv, 0, sizeof(*tv));
 300         if (tveeprom_read(&c, eedata, sizeof(eedata)))
 301                 return;
 302
 303         switch (cx->card->type) {
 304         case CX18_CARD_HVR_1600_ESMT:
 305         case CX18_CARD_HVR_1600_SAMSUNG:
 306                 tveeprom_hauppauge_analog(&c, tv, eedata);
 307                 break;
 308         case CX18_CARD_YUAN_MPC718:
 309                 tv->model = 0x718;
 310                 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
 311                 CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n",
 312                           eedata[2], eedata[1], eedata[4], eedata[3]);
 313                 break;
 314         default:
 315                 tv->model = 0xffffffff;
 316                 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
 317                 break;
 318         }
 319 }
 320
 321 static void cx18_process_eeprom(struct cx18 *cx)
 322 {
 323         struct tveeprom tv;
 324
 325         cx18_read_eeprom(cx, &tv);
 326
 327         /* Many thanks to Steven Toth from Hauppauge for providing the
 328            model numbers */
 329         /* Note: the Samsung memory models cannot be reliably determined
 330            from the model number. Use the cardtype module option if you
 331            have one of these preproduction models. */
 332         switch (tv.model) {
 333         case 74000 ... 74999:
 334                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 335                 break;
 336         case 0x718:
 337                 return;
 338         case 0xffffffff:
 339                 CX18_INFO("Unknown EEPROM encoding\n");
 340                 return;
 341         case 0:
 342                 CX18_ERR("Invalid EEPROM\n");
 343                 return;
 344         default:
 345                 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
 346                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 347                 break;
 348         }
 349
 350         cx->v4l2_cap = cx->card->v4l2_capabilities;
 351         cx->card_name = cx->card->name;
 352         cx->card_i2c = cx->card->i2c;
 353
 354         CX18_INFO("Autodetected %s\n", cx->card_name);
 355
 356         if (tv.tuner_type == TUNER_ABSENT)
 357                 CX18_ERR("tveeprom cannot autodetect tuner!\n");
 358
 359         if (cx->options.tuner == -1)
 360                 cx->options.tuner = tv.tuner_type;
 361         if (cx->options.radio == -1)
 362                 cx->options.radio = (tv.has_radio != 0);
 363
 364         if (cx->std != 0)
 365                 /* user specified tuner standard */
 366                 return;
 367
 368         /* autodetect tuner standard */
 369         if (tv.tuner_formats & V4L2_STD_PAL) {
 370                 CX18_DEBUG_INFO("PAL tuner detected\n");
 371                 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 372         } else if (tv.tuner_formats & V4L2_STD_NTSC) {
 373                 CX18_DEBUG_INFO("NTSC tuner detected\n");
 374                 cx->std |= V4L2_STD_NTSC_M;
 375         } else if (tv.tuner_formats & V4L2_STD_SECAM) {
 376                 CX18_DEBUG_INFO("SECAM tuner detected\n");
 377                 cx->std |= V4L2_STD_SECAM_L;
 378         } else {
 379                 CX18_INFO("No tuner detected, default to NTSC-M\n");
 380                 cx->std |= V4L2_STD_NTSC_M;
 381         }
 382 }
 383
 384 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
 385 {
 386         switch (pal[0]) {
 387         case '6':
 388                 return V4L2_STD_PAL_60;
 389         case 'b':
 390         case 'B':
 391         case 'g':
 392         case 'G':
 393                 return V4L2_STD_PAL_BG;
 394         case 'h':
 395         case 'H':
 396                 return V4L2_STD_PAL_H;
 397         case 'n':
 398         case 'N':
 399                 if (pal[1] == 'c' || pal[1] == 'C')
 400                         return V4L2_STD_PAL_Nc;
 401                 return V4L2_STD_PAL_N;
 402         case 'i':
 403         case 'I':
 404                 return V4L2_STD_PAL_I;
 405         case 'd':
 406         case 'D':
 407         case 'k':
 408         case 'K':
 409                 return V4L2_STD_PAL_DK;
 410         case 'M':
 411         case 'm':
 412                 return V4L2_STD_PAL_M;
 413         case '-':
 414                 break;
 415         default:
 416                 CX18_WARN("pal= argument not recognised\n");
 417                 return 0;
 418         }
 419
 420         switch (secam[0]) {
 421         case 'b':
 422         case 'B':
 423         case 'g':
 424         case 'G':
 425         case 'h':
 426         case 'H':
 427                 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 428         case 'd':
 429         case 'D':
 430         case 'k':
 431         case 'K':
 432                 return V4L2_STD_SECAM_DK;
 433         case 'l':
 434         case 'L':
 435                 if (secam[1] == 'C' || secam[1] == 'c')
 436                         return V4L2_STD_SECAM_LC;
 437                 return V4L2_STD_SECAM_L;
 438         case '-':
 439                 break;
 440         default:
 441                 CX18_WARN("secam= argument not recognised\n");
 442                 return 0;
 443         }
 444
 445         switch (ntsc[0]) {
 446         case 'm':
 447         case 'M':
 448                 return V4L2_STD_NTSC_M;
 449         case 'j':
 450         case 'J':
 451                 return V4L2_STD_NTSC_M_JP;
 452         case 'k':
 453         case 'K':
 454                 return V4L2_STD_NTSC_M_KR;
 455         case '-':
 456                 break;
 457         default:
 458                 CX18_WARN("ntsc= argument not recognised\n");
 459                 return 0;
 460         }
 461
 462         /* no match found */
 463         return 0;
 464 }
 465
 466 static void cx18_process_options(struct cx18 *cx)
 467 {
 468         int i, j;
 469
 470         cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
 471         cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
 472         cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
 473         cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
 474         cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
 475         cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
 476         cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */
 477
 478         cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs;
 479         cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs;
 480         cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs;
 481         cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs;
 482         cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs;
 483         cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs;
 484         cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */
 485
 486         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize;
 487         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize;
 488         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize;
 489         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize;
 490         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_active_samples * 36;
 491         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize;
 492         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */
 493
 494         /* Ensure stream_buffers & stream_buf_size are valid */
 495         for (i = 0; i < CX18_MAX_STREAMS; i++) {
 496                 if (cx->stream_buffers[i] == 0 ||     /* User said 0 buffers */
 497                     cx->options.megabytes[i] <= 0 ||  /* User said 0 MB total */
 498                     cx->stream_buf_size[i] <= 0) {    /* User said buf size 0 */
 499                         cx->options.megabytes[i] = 0;
 500                         cx->stream_buffers[i] = 0;
 501                         cx->stream_buf_size[i] = 0;
 502                         continue;
 503                 }
 504                 /*
 505                  * YUV is a special case where the stream_buf_size needs to be
 506                  * an integral multiple of 33.75 kB (storage for 32 screens
 507                  * lines to maintain alignment in case of lost buffers).
 508                  *
 509                  * IDX is a special case where the stream_buf_size should be
 510                  * an integral multiple of 1.5 kB (storage for 64 index entries
 511                  * to maintain alignment in case of lost buffers).
 512                  *
 513                  */
 514                 if (i == CX18_ENC_STREAM_TYPE_YUV) {
 515                         cx->stream_buf_size[i] *= 1024;
 516                         cx->stream_buf_size[i] -=
 517                            (cx->stream_buf_size[i] % CX18_UNIT_ENC_YUV_BUFSIZE);
 518
 519                         if (cx->stream_buf_size[i] < CX18_UNIT_ENC_YUV_BUFSIZE)
 520                                 cx->stream_buf_size[i] =
 521                                                 CX18_UNIT_ENC_YUV_BUFSIZE;
 522                 } else if (i == CX18_ENC_STREAM_TYPE_IDX) {
 523                         cx->stream_buf_size[i] *= 1024;
 524                         cx->stream_buf_size[i] -=
 525                            (cx->stream_buf_size[i] % CX18_UNIT_ENC_IDX_BUFSIZE);
 526
 527                         if (cx->stream_buf_size[i] < CX18_UNIT_ENC_IDX_BUFSIZE)
 528                                 cx->stream_buf_size[i] =
 529                                                 CX18_UNIT_ENC_IDX_BUFSIZE;
 530                 }
 531                 /*
 532                  * YUV and IDX are special cases where the stream_buf_size is
 533                  * now in bytes.
 534                  * VBI is a special case where the stream_buf_size is fixed
 535                  * and already in bytes
 536                  */
 537                 if (i == CX18_ENC_STREAM_TYPE_VBI ||
 538                     i == CX18_ENC_STREAM_TYPE_YUV ||
 539                     i == CX18_ENC_STREAM_TYPE_IDX) {
 540                         if (cx->stream_buffers[i] < 0) {
 541                                 cx->stream_buffers[i] =
 542                                         cx->options.megabytes[i] * 1024 * 1024
 543                                         / cx->stream_buf_size[i];
 544                         } else {
 545                                 /* N.B. This might round down to 0 */
 546                                 cx->options.megabytes[i] =
 547                                         cx->stream_buffers[i]
 548                                         * cx->stream_buf_size[i]/(1024 * 1024);
 549                         }
 550                 } else {
 551                         /* All other streams have stream_buf_size in kB here */
 552                         if (cx->stream_buffers[i] < 0) {
 553                                 cx->stream_buffers[i] =
 554                                                 cx->options.megabytes[i] * 1024
 555                                                 / cx->stream_buf_size[i];
 556                         } else {
 557                                 /* N.B. This might round down to 0 */
 558                                 cx->options.megabytes[i] =
 559                                                 cx->stream_buffers[i]
 560                                                 * cx->stream_buf_size[i] / 1024;
 561                         }
 562                         /* convert from kB to bytes */
 563                         cx->stream_buf_size[i] *= 1024;
 564                 }
 565                 CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, "
 566                                 "%d bytes\n", i, cx->options.megabytes[i],
 567                                 cx->stream_buffers[i], cx->stream_buf_size[i]);
 568         }
 569
 570         cx->options.cardtype = cardtype[cx->instance];
 571         cx->options.tuner = tuner[cx->instance];
 572         cx->options.radio = radio[cx->instance];
 573
 574         cx->std = cx18_parse_std(cx);
 575         if (cx->options.cardtype == -1) {
 576                 CX18_INFO("Ignore card\n");
 577                 return;
 578         }
 579         cx->card = cx18_get_card(cx->options.cardtype - 1);
 580         if (cx->card)
 581                 CX18_INFO("User specified %s card\n", cx->card->name);
 582         else if (cx->options.cardtype != 0)
 583                 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
 584         if (cx->card == NULL) {
 585                 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
 586                         cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 587                         CX18_INFO("Autodetected Hauppauge card\n");
 588                 }
 589         }
 590         if (cx->card == NULL) {
 591                 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
 592                         if (cx->card->pci_list == NULL)
 593                                 continue;
 594                         for (j = 0; cx->card->pci_list[j].device; j++) {
 595                                 if (cx->pci_dev->device !=
 596                                     cx->card->pci_list[j].device)
 597                                         continue;
 598                                 if (cx->pci_dev->subsystem_vendor !=
 599                                     cx->card->pci_list[j].subsystem_vendor)
 600                                         continue;
 601                                 if (cx->pci_dev->subsystem_device !=
 602                                     cx->card->pci_list[j].subsystem_device)
 603                                         continue;
 604                                 CX18_INFO("Autodetected %s card\n", cx->card->name);
 605                                 goto done;
 606                         }
 607                 }
 608         }
 609 done:
 610
 611         if (cx->card == NULL) {
 612                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 613                 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
 614                          cx->pci_dev->vendor, cx->pci_dev->device);
 615                 CX18_ERR("              subsystem vendor/device: [%04x:%04x]\n",
 616                          cx->pci_dev->subsystem_vendor,
 617                          cx->pci_dev->subsystem_device);
 618                 CX18_ERR("Defaulting to %s card\n", cx->card->name);
 619                 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
 620                 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
 621                 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
 622         }
 623         cx->v4l2_cap = cx->card->v4l2_capabilities;
 624         cx->card_name = cx->card->name;
 625         cx->card_i2c = cx->card->i2c;
 626 }
 627
 628 static int __devinit cx18_create_in_workq(struct cx18 *cx)
 629 {
 630         snprintf(cx->in_workq_name, sizeof(cx->in_workq_name), "%s-in",
 631                  cx->v4l2_dev.name);
 632         cx->in_work_queue = create_singlethread_workqueue(cx->in_workq_name);
 633         if (cx->in_work_queue == NULL) {
 634                 CX18_ERR("Unable to create incoming mailbox handler thread\n");
 635                 return -ENOMEM;
 636         }
 637         return 0;
 638 }
 639
 640 static int __devinit cx18_create_out_workq(struct cx18 *cx)
 641 {
 642         snprintf(cx->out_workq_name, sizeof(cx->out_workq_name), "%s-out",
 643                  cx->v4l2_dev.name);
 644         cx->out_work_queue = create_workqueue(cx->out_workq_name);
 645         if (cx->out_work_queue == NULL) {
 646                 CX18_ERR("Unable to create outgoing mailbox handler threads\n");
 647                 return -ENOMEM;
 648         }
 649         return 0;
 650 }
 651
 652 static void __devinit cx18_init_in_work_orders(struct cx18 *cx)
 653 {
 654         int i;
 655         for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) {
 656                 cx->in_work_order[i].cx = cx;
 657                 cx->in_work_order[i].str = cx->epu_debug_str;
 658                 INIT_WORK(&cx->in_work_order[i].work, cx18_in_work_handler);
 659         }
 660 }
 661
 662 /* Precondition: the cx18 structure has been memset to 0. Only
 663    the dev and instance fields have been filled in.
 664    No assumptions on the card type may be made here (see cx18_init_struct2
 665    for that).
 666  */
 667 static int __devinit cx18_init_struct1(struct cx18 *cx)
 668 {
 669         int ret;
 670
 671         cx->base_addr = pci_resource_start(cx->pci_dev, 0);
 672
 673         mutex_init(&cx->serialize_lock);
 674         mutex_init(&cx->gpio_lock);
 675         mutex_init(&cx->epu2apu_mb_lock);
 676         mutex_init(&cx->epu2cpu_mb_lock);
 677
 678         ret = cx18_create_out_workq(cx);
 679         if (ret)
 680                 return ret;
 681
 682         ret = cx18_create_in_workq(cx);
 683         if (ret) {
 684                 destroy_workqueue(cx->out_work_queue);
 685                 return ret;
 686         }
 687
 688         cx18_init_in_work_orders(cx);
 689
 690         /* start counting open_id at 1 */
 691         cx->open_id = 1;
 692
 693         /* Initial settings */
 694         cx2341x_fill_defaults(&cx->params);
 695         cx->temporal_strength = cx->params.video_temporal_filter;
 696         cx->spatial_strength = cx->params.video_spatial_filter;
 697         cx->filter_mode = cx->params.video_spatial_filter_mode |
 698                 (cx->params.video_temporal_filter_mode << 1) |
 699                 (cx->params.video_median_filter_type << 2);
 700         cx->params.port = CX2341X_PORT_MEMORY;
 701         cx->params.capabilities =
 702                                 CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_SLICED_VBI;
 703         init_waitqueue_head(&cx->cap_w);
 704         init_waitqueue_head(&cx->mb_apu_waitq);
 705         init_waitqueue_head(&cx->mb_cpu_waitq);
 706         init_waitqueue_head(&cx->dma_waitq);
 707
 708         /* VBI */
 709         cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
 710         cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
 711
 712         /* IVTV style VBI insertion into MPEG streams */
 713         INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_buf.list);
 714         INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.list);
 715         INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.buf_list);
 716         list_add(&cx->vbi.sliced_mpeg_buf.list,
 717                  &cx->vbi.sliced_mpeg_mdl.buf_list);
 718         return 0;
 719 }
 720
 721 /* Second initialization part. Here the card type has been
 722    autodetected. */
 723 static void __devinit cx18_init_struct2(struct cx18 *cx)
 724 {
 725         int i;
 726
 727         for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
 728                 if (cx->card->video_inputs[i].video_type == 0)
 729                         break;
 730         cx->nof_inputs = i;
 731         for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
 732                 if (cx->card->audio_inputs[i].audio_type == 0)
 733                         break;
 734         cx->nof_audio_inputs = i;
 735
 736         /* Find tuner input */
 737         for (i = 0; i < cx->nof_inputs; i++) {
 738                 if (cx->card->video_inputs[i].video_type ==
 739                                 CX18_CARD_INPUT_VID_TUNER)
 740                         break;
 741         }
 742         if (i == cx->nof_inputs)
 743                 i = 0;
 744         cx->active_input = i;
 745         cx->audio_input = cx->card->video_inputs[i].audio_index;
 746 }
 747
 748 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
 749                           const struct pci_device_id *pci_id)
 750 {
 751         u16 cmd;
 752         unsigned char pci_latency;
 753
 754         CX18_DEBUG_INFO("Enabling pci device\n");
 755
 756         if (pci_enable_device(pci_dev)) {
 757                 CX18_ERR("Can't enable device %d!\n", cx->instance);
 758                 return -EIO;
 759         }
 760         if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
 761                 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
 762                 return -EIO;
 763         }
 764         if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
 765                 CX18_ERR("Cannot request encoder memory region, card %d\n",
 766                          cx->instance);
 767                 return -EIO;
 768         }
 769
 770         /* Enable bus mastering and memory mapped IO for the CX23418 */
 771         pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
 772         cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
 773         pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
 774
 775         pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
 776         pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
 777
 778         if (pci_latency < 64 && cx18_pci_latency) {
 779                 CX18_INFO("Unreasonably low latency timer, "
 780                                "setting to 64 (was %d)\n", pci_latency);
 781                 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
 782                 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
 783         }
 784
 785         CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
 786                    "irq: %d, latency: %d, memory: 0x%lx\n",
 787                    cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
 788                    PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
 789                    cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
 790
 791         return 0;
 792 }
 793
 794 static void cx18_init_subdevs(struct cx18 *cx)
 795 {
 796         u32 hw = cx->card->hw_all;
 797         u32 device;
 798         int i;
 799
 800         for (i = 0, device = 1; i < 32; i++, device <<= 1) {
 801
 802                 if (!(device & hw))
 803                         continue;
 804
 805                 switch (device) {
 806                 case CX18_HW_DVB:
 807                 case CX18_HW_TVEEPROM:
 808                         /* These subordinate devices do not use probing */
 809                         cx->hw_flags |= device;
 810                         break;
 811                 case CX18_HW_418_AV:
 812                         /* The A/V decoder gets probed earlier to set PLLs */
 813                         /* Just note that the card uses it (i.e. has analog) */
 814                         cx->hw_flags |= device;
 815                         break;
 816                 case CX18_HW_GPIO_RESET_CTRL:
 817                         /*
 818                          * The Reset Controller gets probed and added to
 819                          * hw_flags earlier for i2c adapter/bus initialization
 820                          */
 821                         break;
 822                 case CX18_HW_GPIO_MUX:
 823                         if (cx18_gpio_register(cx, device) == 0)
 824                                 cx->hw_flags |= device;
 825                         break;
 826                 default:
 827                         if (cx18_i2c_register(cx, i) == 0)
 828                                 cx->hw_flags |= device;
 829                         break;
 830                 }
 831         }
 832
 833         if (cx->hw_flags & CX18_HW_418_AV)
 834                 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV);
 835
 836         if (cx->card->hw_muxer != 0)
 837                 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer);
 838 }
 839
 840 static int __devinit cx18_probe(struct pci_dev *pci_dev,
 841                                 const struct pci_device_id *pci_id)
 842 {
 843         int retval = 0;
 844         int i;
 845         u32 devtype;
 846         struct cx18 *cx;
 847
 848         /* FIXME - module parameter arrays constrain max instances */
 849         i = atomic_inc_return(&cx18_instance) - 1;
 850         if (i >= CX18_MAX_CARDS) {
 851                 printk(KERN_ERR "cx18: cannot manage card %d, driver has a "
 852                        "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1);
 853                 return -ENOMEM;
 854         }
 855
 856         cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
 857         if (cx == NULL) {
 858                 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
 859                        i);
 860                 return -ENOMEM;
 861         }
 862         cx->pci_dev = pci_dev;
 863         cx->instance = i;
 864
 865         retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
 866         if (retval) {
 867                 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
 868                        "\n", cx->instance);
 869                 kfree(cx);
 870                 return retval;
 871         }
 872         snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
 873                  cx->instance);
 874         CX18_INFO("Initializing card %d\n", cx->instance);
 875
 876         cx18_process_options(cx);
 877         if (cx->options.cardtype == -1) {
 878                 retval = -ENODEV;
 879                 goto err;
 880         }
 881
 882         retval = cx18_init_struct1(cx);
 883         if (retval)
 884                 goto err;
 885
 886         CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
 887
 888         /* PCI Device Setup */
 889         retval = cx18_setup_pci(cx, pci_dev, pci_id);
 890         if (retval != 0)
 891                 goto free_workqueues;
 892
 893         /* map io memory */
 894         CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
 895                    cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
 896         cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
 897                                        CX18_MEM_SIZE);
 898         if (!cx->enc_mem) {
 899                 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
 900                 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
 901                 retval = -ENOMEM;
 902                 goto free_mem;
 903         }
 904         cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
 905         devtype = cx18_read_reg(cx, 0xC72028);
 906         switch (devtype & 0xff000000) {
 907         case 0xff000000:
 908                 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
 909                 break;
 910         case 0x01000000:
 911                 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
 912                 break;
 913         default:
 914                 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
 915                 break;
 916         }
 917
 918         cx18_init_power(cx, 1);
 919         cx18_init_memory(cx);
 920
 921         cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
 922         cx18_init_scb(cx);
 923
 924         cx18_gpio_init(cx);
 925
 926         /* Initialize integrated A/V decoder early to set PLLs, just in case */
 927         retval = cx18_av_probe(cx);
 928         if (retval) {
 929                 CX18_ERR("Could not register A/V decoder subdevice\n");
 930                 goto free_map;
 931         }
 932
 933         /* Initialize GPIO Reset Controller to do chip resets during i2c init */
 934         if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) {
 935                 if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0)
 936                         CX18_WARN("Could not register GPIO reset controller"
 937                                   "subdevice; proceeding anyway.\n");
 938                 else
 939                         cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL;
 940         }
 941
 942         /* active i2c  */
 943         CX18_DEBUG_INFO("activating i2c...\n");
 944         retval = init_cx18_i2c(cx);
 945         if (retval) {
 946                 CX18_ERR("Could not initialize i2c\n");
 947                 goto free_map;
 948         }
 949
 950         if (cx->card->hw_all & CX18_HW_TVEEPROM) {
 951                 /* Based on the model number the cardtype may be changed.
 952                    The PCI IDs are not always reliable. */
 953                 cx18_process_eeprom(cx);
 954         }
 955         if (cx->card->comment)
 956                 CX18_INFO("%s", cx->card->comment);
 957         if (cx->card->v4l2_capabilities == 0) {
 958                 retval = -ENODEV;
 959                 goto free_i2c;
 960         }
 961         cx18_init_memory(cx);
 962         cx18_init_scb(cx);
 963
 964         /* Register IRQ */
 965         retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
 966                              IRQF_SHARED | IRQF_DISABLED,
 967                              cx->v4l2_dev.name, (void *)cx);
 968         if (retval) {
 969                 CX18_ERR("Failed to register irq %d\n", retval);
 970                 goto free_i2c;
 971         }
 972
 973         if (cx->std == 0)
 974                 cx->std = V4L2_STD_NTSC_M;
 975
 976         if (cx->options.tuner == -1) {
 977                 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
 978                         if ((cx->std & cx->card->tuners[i].std) == 0)
 979                                 continue;
 980                         cx->options.tuner = cx->card->tuners[i].tuner;
 981                         break;
 982                 }
 983         }
 984         /* if no tuner was found, then pick the first tuner in the card list */
 985         if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
 986                 cx->std = cx->card->tuners[0].std;
 987                 if (cx->std & V4L2_STD_PAL)
 988                         cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 989                 else if (cx->std & V4L2_STD_NTSC)
 990                         cx->std = V4L2_STD_NTSC_M;
 991                 else if (cx->std & V4L2_STD_SECAM)
 992                         cx->std = V4L2_STD_SECAM_L;
 993                 cx->options.tuner = cx->card->tuners[0].tuner;
 994         }
 995         if (cx->options.radio == -1)
 996                 cx->options.radio = (cx->card->radio_input.audio_type != 0);
 997
 998         /* The card is now fully identified, continue with card-specific
 999            initialization. */
1000         cx18_init_struct2(cx);
1001
1002         cx18_init_subdevs(cx);
1003
1004         if (cx->std & V4L2_STD_525_60)
1005                 cx->is_60hz = 1;
1006         else
1007                 cx->is_50hz = 1;
1008
1009         cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
1010
1011         if (cx->options.radio > 0)
1012                 cx->v4l2_cap |= V4L2_CAP_RADIO;
1013
1014         if (cx->options.tuner > -1) {
1015                 struct tuner_setup setup;
1016
1017                 setup.addr = ADDR_UNSET;
1018                 setup.type = cx->options.tuner;
1019                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1020                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1021                         cx18_reset_tuner_gpio : NULL;
1022                 cx18_call_all(cx, tuner, s_type_addr, &setup);
1023                 if (setup.type == TUNER_XC2028) {
1024                         static struct xc2028_ctrl ctrl = {
1025                                 .fname = XC2028_DEFAULT_FIRMWARE,
1026                                 .max_len = 64,
1027                         };
1028                         struct v4l2_priv_tun_config cfg = {
1029                                 .tuner = cx->options.tuner,
1030                                 .priv = &ctrl,
1031                         };
1032                         cx18_call_all(cx, tuner, s_config, &cfg);
1033                 }
1034         }
1035
1036         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1037            are not. */
1038         cx->tuner_std = cx->std;
1039
1040         retval = cx18_streams_setup(cx);
1041         if (retval) {
1042                 CX18_ERR("Error %d setting up streams\n", retval);
1043                 goto free_irq;
1044         }
1045         retval = cx18_streams_register(cx);
1046         if (retval) {
1047                 CX18_ERR("Error %d registering devices\n", retval);
1048                 goto free_streams;
1049         }
1050
1051         CX18_INFO("Initialized card: %s\n", cx->card_name);
1052         return 0;
1053
1054 free_streams:
1055         cx18_streams_cleanup(cx, 1);
1056 free_irq:
1057         free_irq(cx->pci_dev->irq, (void *)cx);
1058 free_i2c:
1059         exit_cx18_i2c(cx);
1060 free_map:
1061         cx18_iounmap(cx);
1062 free_mem:
1063         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1064 free_workqueues:
1065         destroy_workqueue(cx->in_work_queue);
1066         destroy_workqueue(cx->out_work_queue);
1067 err:
1068         if (retval == 0)
1069                 retval = -ENODEV;
1070         CX18_ERR("Error %d on initialization\n", retval);
1071
1072         v4l2_device_unregister(&cx->v4l2_dev);
1073         kfree(cx);
1074         return retval;
1075 }
1076
1077 int cx18_init_on_first_open(struct cx18 *cx)
1078 {
1079         int video_input;
1080         int fw_retry_count = 3;
1081         struct v4l2_frequency vf;
1082         struct cx18_open_id fh;
1083
1084         fh.cx = cx;
1085
1086         if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
1087                 return -ENXIO;
1088
1089         if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
1090                 return 0;
1091
1092         while (--fw_retry_count > 0) {
1093                 /* load firmware */
1094                 if (cx18_firmware_init(cx) == 0)
1095                         break;
1096                 if (fw_retry_count > 1)
1097                         CX18_WARN("Retry loading firmware\n");
1098         }
1099
1100         if (fw_retry_count == 0) {
1101                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1102                 return -ENXIO;
1103         }
1104         set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
1105
1106         /*
1107          * Init the firmware twice to work around a silicon bug
1108          * with the digital TS.
1109          *
1110          * The second firmware load requires us to normalize the APU state,
1111          * or the audio for the first analog capture will be badly incorrect.
1112          *
1113          * I can't seem to call APU_RESETAI and have it succeed without the
1114          * APU capturing audio, so we start and stop it here to do the reset
1115          */
1116
1117         /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1118         cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1119         cx18_vapi(cx, CX18_APU_RESETAI, 0);
1120         cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1121
1122         fw_retry_count = 3;
1123         while (--fw_retry_count > 0) {
1124                 /* load firmware */
1125                 if (cx18_firmware_init(cx) == 0)
1126                         break;
1127                 if (fw_retry_count > 1)
1128                         CX18_WARN("Retry loading firmware\n");
1129         }
1130
1131         if (fw_retry_count == 0) {
1132                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1133                 return -ENXIO;
1134         }
1135
1136         /*
1137          * The second firmware load requires us to normalize the APU state,
1138          * or the audio for the first analog capture will be badly incorrect.
1139          *
1140          * I can't seem to call APU_RESETAI and have it succeed without the
1141          * APU capturing audio, so we start and stop it here to do the reset
1142          */
1143
1144         /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1145         cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1146         cx18_vapi(cx, CX18_APU_RESETAI, 0);
1147         cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1148
1149         /* Init the A/V decoder, if it hasn't been already */
1150         v4l2_subdev_call(cx->sd_av, core, load_fw);
1151
1152         vf.tuner = 0;
1153         vf.type = V4L2_TUNER_ANALOG_TV;
1154         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1155
1156         /* Set initial frequency. For PAL/SECAM broadcasts no
1157            'default' channel exists AFAIK. */
1158         if (cx->std == V4L2_STD_NTSC_M_JP)
1159                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1160         else if (cx->std & V4L2_STD_NTSC_M)
1161                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1162
1163         video_input = cx->active_input;
1164         cx->active_input++;     /* Force update of input */
1165         cx18_s_input(NULL, &fh, video_input);
1166
1167         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1168            in one place. */
1169         cx->std++;              /* Force full standard initialization */
1170         cx18_s_std(NULL, &fh, &cx->tuner_std);
1171         cx18_s_frequency(NULL, &fh, &vf);
1172         return 0;
1173 }
1174
1175 static void cx18_cancel_in_work_orders(struct cx18 *cx)
1176 {
1177         int i;
1178         for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++)
1179                 cancel_work_sync(&cx->in_work_order[i].work);
1180 }
1181
1182 static void cx18_cancel_out_work_orders(struct cx18 *cx)
1183 {
1184         int i;
1185         for (i = 0; i < CX18_MAX_STREAMS; i++)
1186                 if (&cx->streams[i].video_dev != NULL)
1187                         cancel_work_sync(&cx->streams[i].out_work_order);
1188 }
1189
1190 static void cx18_remove(struct pci_dev *pci_dev)
1191 {
1192         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1193         struct cx18 *cx = to_cx18(v4l2_dev);
1194         int i;
1195
1196         CX18_DEBUG_INFO("Removing Card\n");
1197
1198         /* Stop all captures */
1199         CX18_DEBUG_INFO("Stopping all streams\n");
1200         if (atomic_read(&cx->tot_capturing) > 0)
1201                 cx18_stop_all_captures(cx);
1202
1203         /* Stop interrupts that cause incoming work to be queued */
1204         cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1205
1206         /* Incoming work can cause outgoing work, so clean up incoming first */
1207         cx18_cancel_in_work_orders(cx);
1208         cx18_cancel_out_work_orders(cx);
1209
1210         /* Stop ack interrupts that may have been needed for work to finish */
1211         cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1212
1213         cx18_halt_firmware(cx);
1214
1215         destroy_workqueue(cx->in_work_queue);
1216         destroy_workqueue(cx->out_work_queue);
1217
1218         cx18_streams_cleanup(cx, 1);
1219
1220         exit_cx18_i2c(cx);
1221
1222         free_irq(cx->pci_dev->irq, (void *)cx);
1223
1224         cx18_iounmap(cx);
1225
1226         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1227
1228         pci_disable_device(cx->pci_dev);
1229
1230         if (cx->vbi.sliced_mpeg_data[0] != NULL)
1231                 for (i = 0; i < CX18_VBI_FRAMES; i++)
1232                         kfree(cx->vbi.sliced_mpeg_data[i]);
1233
1234         CX18_INFO("Removed %s\n", cx->card_name);
1235
1236         v4l2_device_unregister(v4l2_dev);
1237         kfree(cx);
1238 }
1239
1240 /* define a pci_driver for card detection */
1241 static struct pci_driver cx18_pci_driver = {
1242       .name =     "cx18",
1243       .id_table = cx18_pci_tbl,
1244       .probe =    cx18_probe,
1245       .remove =   cx18_remove,
1246 };
1247
1248 static int __init module_start(void)
1249 {
1250         printk(KERN_INFO "cx18:  Start initialization, version %s\n", CX18_VERSION);
1251
1252         /* Validate parameters */
1253         if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1254                 printk(KERN_ERR "cx18:  Exiting, cx18_first_minor must be between 0 and %d\n",
1255                      CX18_MAX_CARDS - 1);
1256                 return -1;
1257         }
1258
1259         if (cx18_debug < 0 || cx18_debug > 511) {
1260                 cx18_debug = 0;
1261                 printk(KERN_INFO "cx18:   Debug value must be >= 0 and <= 511!\n");
1262         }
1263
1264         if (pci_register_driver(&cx18_pci_driver)) {
1265                 printk(KERN_ERR "cx18:   Error detecting PCI card\n");
1266                 return -ENODEV;
1267         }
1268         printk(KERN_INFO "cx18:  End initialization\n");
1269         return 0;
1270 }
1271
1272 static void __exit module_cleanup(void)
1273 {
1274         pci_unregister_driver(&cx18_pci_driver);
1275 }
1276
1277 module_init(module_start);
1278 module_exit(module_cleanup);