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

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