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