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