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