git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/cx18/cx18-driver.c

   1 /*
   2  *  cx18 driver initialization and card probing
   3  *
   4  *  Derived from ivtv-driver.c
   5  *
   6  *  Copyright (C) 2007  Hans Verkuil <hverkuil@xs4all.nl>
   7  *  Copyright (C) 2008  Andy Walls <awalls@radix.net>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  22  *  02111-1307  USA
  23  */
  24
  25 #include "cx18-driver.h"
  26 #include "cx18-io.h"
  27 #include "cx18-version.h"
  28 #include "cx18-cards.h"
  29 #include "cx18-i2c.h"
  30 #include "cx18-irq.h"
  31 #include "cx18-gpio.h"
  32 #include "cx18-firmware.h"
  33 #include "cx18-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/DVR3100 H\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] = vbi_active_samples * 36;
 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         /* Ensure stream_buffers & stream_buf_size are valid */
 456         for (i = 0; i < CX18_MAX_STREAMS; i++) {
 457                 if (cx->stream_buffers[i] == 0 ||     /* User said 0 buffers */
 458                     cx->options.megabytes[i] <= 0 ||  /* User said 0 MB total */
 459                     cx->stream_buf_size[i] <= 0) {    /* User said buf size 0 */
 460                         cx->options.megabytes[i] = 0;
 461                         cx->stream_buffers[i] = 0;
 462                         cx->stream_buf_size[i] = 0;
 463                         continue;
 464                 }
 465                 /*
 466                  * VBI is a special case where the stream_buf_size is fixed
 467                  * and already in bytes
 468                  */
 469                 if (i == CX18_ENC_STREAM_TYPE_VBI) {
 470                         if (cx->stream_buffers[i] < 0) {
 471                                 cx->stream_buffers[i] =
 472                                         cx->options.megabytes[i] * 1024 * 1024
 473                                         / cx->stream_buf_size[i];
 474                         } else {
 475                                 /* N.B. This might round down to 0 */
 476                                 cx->options.megabytes[i] =
 477                                         cx->stream_buffers[i]
 478                                         * cx->stream_buf_size[i]/(1024 * 1024);
 479                         }
 480                         continue;
 481                 }
 482                 /* All other streams have stream_buf_size in kB at this point */
 483                 if (cx->stream_buffers[i] < 0) {
 484                         cx->stream_buffers[i] = cx->options.megabytes[i] * 1024
 485                                                 / cx->stream_buf_size[i];
 486                 } else {
 487                         /* N.B. This might round down to 0 */
 488                         cx->options.megabytes[i] =
 489                           cx->stream_buffers[i] * cx->stream_buf_size[i] / 1024;
 490                 }
 491                 cx->stream_buf_size[i] *= 1024; /* convert from kB to bytes */
 492         }
 493
 494         cx->options.cardtype = cardtype[cx->num];
 495         cx->options.tuner = tuner[cx->num];
 496         cx->options.radio = radio[cx->num];
 497
 498         cx->std = cx18_parse_std(cx);
 499         if (cx->options.cardtype == -1) {
 500                 CX18_INFO("Ignore card\n");
 501                 return;
 502         }
 503         cx->card = cx18_get_card(cx->options.cardtype - 1);
 504         if (cx->card)
 505                 CX18_INFO("User specified %s card\n", cx->card->name);
 506         else if (cx->options.cardtype != 0)
 507                 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
 508         if (cx->card == NULL) {
 509                 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
 510                         cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 511                         CX18_INFO("Autodetected Hauppauge card\n");
 512                 }
 513         }
 514         if (cx->card == NULL) {
 515                 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
 516                         if (cx->card->pci_list == NULL)
 517                                 continue;
 518                         for (j = 0; cx->card->pci_list[j].device; j++) {
 519                                 if (cx->pci_dev->device !=
 520                                     cx->card->pci_list[j].device)
 521                                         continue;
 522                                 if (cx->pci_dev->subsystem_vendor !=
 523                                     cx->card->pci_list[j].subsystem_vendor)
 524                                         continue;
 525                                 if (cx->pci_dev->subsystem_device !=
 526                                     cx->card->pci_list[j].subsystem_device)
 527                                         continue;
 528                                 CX18_INFO("Autodetected %s card\n", cx->card->name);
 529                                 goto done;
 530                         }
 531                 }
 532         }
 533 done:
 534
 535         if (cx->card == NULL) {
 536                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 537                 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
 538                          cx->pci_dev->vendor, cx->pci_dev->device);
 539                 CX18_ERR("              subsystem vendor/device: [%04x:%04x]\n",
 540                          cx->pci_dev->subsystem_vendor,
 541                          cx->pci_dev->subsystem_device);
 542                 CX18_ERR("Defaulting to %s card\n", cx->card->name);
 543                 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
 544                 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
 545                 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
 546         }
 547         cx->v4l2_cap = cx->card->v4l2_capabilities;
 548         cx->card_name = cx->card->name;
 549         cx->card_i2c = cx->card->i2c;
 550 }
 551
 552 /* Precondition: the cx18 structure has been memset to 0. Only
 553    the dev and num fields have been filled in.
 554    No assumptions on the card type may be made here (see cx18_init_struct2
 555    for that).
 556  */
 557 static int __devinit cx18_init_struct1(struct cx18 *cx)
 558 {
 559         int i;
 560
 561         cx->base_addr = pci_resource_start(cx->pci_dev, 0);
 562
 563         mutex_init(&cx->serialize_lock);
 564         mutex_init(&cx->i2c_bus_lock[0]);
 565         mutex_init(&cx->i2c_bus_lock[1]);
 566         mutex_init(&cx->gpio_lock);
 567         mutex_init(&cx->epu2apu_mb_lock);
 568         mutex_init(&cx->epu2cpu_mb_lock);
 569
 570         cx->work_queue = create_singlethread_workqueue(cx->name);
 571         if (cx->work_queue == NULL) {
 572                 CX18_ERR("Unable to create work hander thread\n");
 573                 return -ENOMEM;
 574         }
 575
 576         for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++) {
 577                 cx->epu_work_order[i].cx = cx;
 578                 cx->epu_work_order[i].str = cx->epu_debug_str;
 579                 INIT_WORK(&cx->epu_work_order[i].work, cx18_epu_work_handler);
 580         }
 581
 582         /* start counting open_id at 1 */
 583         cx->open_id = 1;
 584
 585         /* Initial settings */
 586         cx2341x_fill_defaults(&cx->params);
 587         cx->temporal_strength = cx->params.video_temporal_filter;
 588         cx->spatial_strength = cx->params.video_spatial_filter;
 589         cx->filter_mode = cx->params.video_spatial_filter_mode |
 590                 (cx->params.video_temporal_filter_mode << 1) |
 591                 (cx->params.video_median_filter_type << 2);
 592         cx->params.port = CX2341X_PORT_MEMORY;
 593         cx->params.capabilities =
 594           CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_AC3 | CX2341X_CAP_HAS_SLICED_VBI;
 595         init_waitqueue_head(&cx->cap_w);
 596         init_waitqueue_head(&cx->mb_apu_waitq);
 597         init_waitqueue_head(&cx->mb_cpu_waitq);
 598         init_waitqueue_head(&cx->dma_waitq);
 599
 600         /* VBI */
 601         cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
 602         cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
 603
 604         return 0;
 605 }
 606
 607 /* Second initialization part. Here the card type has been
 608    autodetected. */
 609 static void __devinit cx18_init_struct2(struct cx18 *cx)
 610 {
 611         int i;
 612
 613         for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
 614                 if (cx->card->video_inputs[i].video_type == 0)
 615                         break;
 616         cx->nof_inputs = i;
 617         for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
 618                 if (cx->card->audio_inputs[i].audio_type == 0)
 619                         break;
 620         cx->nof_audio_inputs = i;
 621
 622         /* Find tuner input */
 623         for (i = 0; i < cx->nof_inputs; i++) {
 624                 if (cx->card->video_inputs[i].video_type ==
 625                                 CX18_CARD_INPUT_VID_TUNER)
 626                         break;
 627         }
 628         if (i == cx->nof_inputs)
 629                 i = 0;
 630         cx->active_input = i;
 631         cx->audio_input = cx->card->video_inputs[i].audio_index;
 632         cx->av_state.vid_input = CX18_AV_COMPOSITE7;
 633         cx->av_state.aud_input = CX18_AV_AUDIO8;
 634         cx->av_state.audclk_freq = 48000;
 635         cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
 636         cx->av_state.slicer_line_delay = 0;
 637         cx->av_state.slicer_line_offset =
 638                 (10 + cx->av_state.slicer_line_delay - 2);
 639 }
 640
 641 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
 642                           const struct pci_device_id *pci_id)
 643 {
 644         u16 cmd;
 645         unsigned char pci_latency;
 646
 647         CX18_DEBUG_INFO("Enabling pci device\n");
 648
 649         if (pci_enable_device(pci_dev)) {
 650                 CX18_ERR("Can't enable device %d!\n", cx->num);
 651                 return -EIO;
 652         }
 653         if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
 654                 CX18_ERR("No suitable DMA available on card %d.\n", cx->num);
 655                 return -EIO;
 656         }
 657         if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
 658                 CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num);
 659                 return -EIO;
 660         }
 661
 662         /* Enable bus mastering and memory mapped IO for the CX23418 */
 663         pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
 664         cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
 665         pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
 666
 667         pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
 668         pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
 669
 670         if (pci_latency < 64 && cx18_pci_latency) {
 671                 CX18_INFO("Unreasonably low latency timer, "
 672                                "setting to 64 (was %d)\n", pci_latency);
 673                 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
 674                 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
 675         }
 676
 677         CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
 678                    "irq: %d, latency: %d, memory: 0x%lx\n",
 679                    cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
 680                    PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
 681                    cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
 682
 683         return 0;
 684 }
 685
 686 #ifdef MODULE
 687 static u32 cx18_request_module(struct cx18 *cx, u32 hw,
 688                 const char *name, u32 id)
 689 {
 690         if ((hw & id) == 0)
 691                 return hw;
 692         if (request_module("%s", name) != 0) {
 693                 CX18_ERR("Failed to load module %s\n", name);
 694                 return hw & ~id;
 695         }
 696         CX18_DEBUG_INFO("Loaded module %s\n", name);
 697         return hw;
 698 }
 699 #endif
 700
 701 static void cx18_load_and_init_modules(struct cx18 *cx)
 702 {
 703         u32 hw = cx->card->hw_all;
 704         int i;
 705
 706 #ifdef MODULE
 707         /* load modules */
 708 #ifdef CONFIG_MEDIA_TUNER_MODULE
 709         hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
 710 #endif
 711 #ifdef CONFIG_VIDEO_CS5345_MODULE
 712         hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
 713 #endif
 714 #endif
 715
 716         /* check which i2c devices are actually found */
 717         for (i = 0; i < 32; i++) {
 718                 u32 device = 1 << i;
 719
 720                 if (!(device & hw))
 721                         continue;
 722                 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
 723                     device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
 724                         /* These 'devices' do not use i2c probing */
 725                         cx->hw_flags |= device;
 726                         continue;
 727                 }
 728                 cx18_i2c_register(cx, i);
 729                 if (cx18_i2c_hw_addr(cx, device) > 0)
 730                         cx->hw_flags |= device;
 731         }
 732
 733         hw = cx->hw_flags;
 734 }
 735
 736 static int __devinit cx18_probe(struct pci_dev *pci_dev,
 737                                 const struct pci_device_id *pci_id)
 738 {
 739         int retval = 0;
 740         int i;
 741         u32 devtype;
 742         struct cx18 *cx;
 743
 744         spin_lock(&cx18_cards_lock);
 745
 746         /* Make sure we've got a place for this card */
 747         if (cx18_cards_active == CX18_MAX_CARDS) {
 748                 printk(KERN_ERR "cx18:  Maximum number of cards detected (%d).\n",
 749                               cx18_cards_active);
 750                 spin_unlock(&cx18_cards_lock);
 751                 return -ENOMEM;
 752         }
 753
 754         cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
 755         if (!cx) {
 756                 spin_unlock(&cx18_cards_lock);
 757                 return -ENOMEM;
 758         }
 759         cx18_cards[cx18_cards_active] = cx;
 760         cx->num = cx18_cards_active++;
 761         snprintf(cx->name, sizeof(cx->name), "cx18-%d", cx->num);
 762         CX18_INFO("Initializing card #%d\n", cx->num);
 763
 764         spin_unlock(&cx18_cards_lock);
 765
 766         cx->pci_dev = pci_dev;
 767         retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
 768         if (retval) {
 769                 CX18_ERR("Call to v4l2_device_register() failed\n");
 770                 goto err;
 771         }
 772         CX18_DEBUG_INFO("registered v4l2_device name: %s\n", cx->v4l2_dev.name);
 773
 774         cx18_process_options(cx);
 775         if (cx->options.cardtype == -1) {
 776                 retval = -ENODEV;
 777                 goto unregister_v4l2;
 778         }
 779         if (cx18_init_struct1(cx)) {
 780                 retval = -ENOMEM;
 781                 goto unregister_v4l2;
 782         }
 783
 784         CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
 785
 786         /* PCI Device Setup */
 787         retval = cx18_setup_pci(cx, pci_dev, pci_id);
 788         if (retval != 0)
 789                 goto free_workqueue;
 790
 791         /* map io memory */
 792         CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
 793                    cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
 794         cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
 795                                        CX18_MEM_SIZE);
 796         if (!cx->enc_mem) {
 797                 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
 798                 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
 799                 retval = -ENOMEM;
 800                 goto free_mem;
 801         }
 802         cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
 803         devtype = cx18_read_reg(cx, 0xC72028);
 804         switch (devtype & 0xff000000) {
 805         case 0xff000000:
 806                 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
 807                 break;
 808         case 0x01000000:
 809                 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
 810                 break;
 811         default:
 812                 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
 813                 break;
 814         }
 815
 816         cx18_init_power(cx, 1);
 817         cx18_init_memory(cx);
 818
 819         cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
 820         cx18_init_scb(cx);
 821
 822         cx18_gpio_init(cx);
 823
 824         /* active i2c  */
 825         CX18_DEBUG_INFO("activating i2c...\n");
 826         retval = init_cx18_i2c(cx);
 827         if (retval) {
 828                 CX18_ERR("Could not initialize i2c\n");
 829                 goto free_map;
 830         }
 831
 832         CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active);
 833
 834         if (cx->card->hw_all & CX18_HW_TVEEPROM) {
 835                 /* Based on the model number the cardtype may be changed.
 836                    The PCI IDs are not always reliable. */
 837                 cx18_process_eeprom(cx);
 838         }
 839         if (cx->card->comment)
 840                 CX18_INFO("%s", cx->card->comment);
 841         if (cx->card->v4l2_capabilities == 0) {
 842                 retval = -ENODEV;
 843                 goto free_i2c;
 844         }
 845         cx18_init_memory(cx);
 846         cx18_init_scb(cx);
 847
 848         /* Register IRQ */
 849         retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
 850                              IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx);
 851         if (retval) {
 852                 CX18_ERR("Failed to register irq %d\n", retval);
 853                 goto free_i2c;
 854         }
 855
 856         if (cx->std == 0)
 857                 cx->std = V4L2_STD_NTSC_M;
 858
 859         if (cx->options.tuner == -1) {
 860                 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
 861                         if ((cx->std & cx->card->tuners[i].std) == 0)
 862                                 continue;
 863                         cx->options.tuner = cx->card->tuners[i].tuner;
 864                         break;
 865                 }
 866         }
 867         /* if no tuner was found, then pick the first tuner in the card list */
 868         if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
 869                 cx->std = cx->card->tuners[0].std;
 870                 if (cx->std & V4L2_STD_PAL)
 871                         cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 872                 else if (cx->std & V4L2_STD_NTSC)
 873                         cx->std = V4L2_STD_NTSC_M;
 874                 else if (cx->std & V4L2_STD_SECAM)
 875                         cx->std = V4L2_STD_SECAM_L;
 876                 cx->options.tuner = cx->card->tuners[0].tuner;
 877         }
 878         if (cx->options.radio == -1)
 879                 cx->options.radio = (cx->card->radio_input.audio_type != 0);
 880
 881         /* The card is now fully identified, continue with card-specific
 882            initialization. */
 883         cx18_init_struct2(cx);
 884
 885         cx18_load_and_init_modules(cx);
 886
 887         if (cx->std & V4L2_STD_525_60) {
 888                 cx->is_60hz = 1;
 889                 cx->is_out_60hz = 1;
 890         } else {
 891                 cx->is_50hz = 1;
 892                 cx->is_out_50hz = 1;
 893         }
 894         cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
 895
 896         if (cx->options.radio > 0)
 897                 cx->v4l2_cap |= V4L2_CAP_RADIO;
 898
 899         if (cx->options.tuner > -1) {
 900                 struct tuner_setup setup;
 901
 902                 setup.addr = ADDR_UNSET;
 903                 setup.type = cx->options.tuner;
 904                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
 905                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
 906                         cx18_reset_tuner_gpio : NULL;
 907                 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
 908                 if (setup.type == TUNER_XC2028) {
 909                         static struct xc2028_ctrl ctrl = {
 910                                 .fname = XC2028_DEFAULT_FIRMWARE,
 911                                 .max_len = 64,
 912                         };
 913                         struct v4l2_priv_tun_config cfg = {
 914                                 .tuner = cx->options.tuner,
 915                                 .priv = &ctrl,
 916                         };
 917                         cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
 918                 }
 919         }
 920
 921         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
 922            are not. */
 923         cx->tuner_std = cx->std;
 924
 925         retval = cx18_streams_setup(cx);
 926         if (retval) {
 927                 CX18_ERR("Error %d setting up streams\n", retval);
 928                 goto free_irq;
 929         }
 930         retval = cx18_streams_register(cx);
 931         if (retval) {
 932                 CX18_ERR("Error %d registering devices\n", retval);
 933                 goto free_streams;
 934         }
 935
 936         CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
 937
 938         return 0;
 939
 940 free_streams:
 941         cx18_streams_cleanup(cx, 1);
 942 free_irq:
 943         free_irq(cx->pci_dev->irq, (void *)cx);
 944 free_i2c:
 945         exit_cx18_i2c(cx);
 946 free_map:
 947         cx18_iounmap(cx);
 948 free_mem:
 949         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
 950 free_workqueue:
 951         destroy_workqueue(cx->work_queue);
 952 unregister_v4l2:
 953         v4l2_device_unregister(&cx->v4l2_dev);
 954 err:
 955         if (retval == 0)
 956                 retval = -ENODEV;
 957         CX18_ERR("Error %d on initialization\n", retval);
 958
 959         i = cx->num;
 960         spin_lock(&cx18_cards_lock);
 961         kfree(cx18_cards[i]);
 962         cx18_cards[i] = NULL;
 963         spin_unlock(&cx18_cards_lock);
 964         return retval;
 965 }
 966
 967 int cx18_init_on_first_open(struct cx18 *cx)
 968 {
 969         int video_input;
 970         int fw_retry_count = 3;
 971         struct v4l2_frequency vf;
 972         struct cx18_open_id fh;
 973
 974         fh.cx = cx;
 975
 976         if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
 977                 return -ENXIO;
 978
 979         if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
 980                 return 0;
 981
 982         while (--fw_retry_count > 0) {
 983                 /* load firmware */
 984                 if (cx18_firmware_init(cx) == 0)
 985                         break;
 986                 if (fw_retry_count > 1)
 987                         CX18_WARN("Retry loading firmware\n");
 988         }
 989
 990         if (fw_retry_count == 0) {
 991                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
 992                 return -ENXIO;
 993         }
 994         set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
 995
 996         /*
 997          * Init the firmware twice to work around a silicon bug
 998          * with the digital TS.
 999          *
1000          * The second firmware load requires us to normalize the APU state,
1001          * or the audio for the first analog capture will be badly incorrect.
1002          *
1003          * I can't seem to call APU_RESETAI and have it succeed without the
1004          * APU capturing audio, so we start and stop it here to do the reset
1005          */
1006
1007         /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1008         cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1009         cx18_vapi(cx, CX18_APU_RESETAI, 0);
1010         cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1011
1012         fw_retry_count = 3;
1013         while (--fw_retry_count > 0) {
1014                 /* load firmware */
1015                 if (cx18_firmware_init(cx) == 0)
1016                         break;
1017                 if (fw_retry_count > 1)
1018                         CX18_WARN("Retry loading firmware\n");
1019         }
1020
1021         if (fw_retry_count == 0) {
1022                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1023                 return -ENXIO;
1024         }
1025
1026         /*
1027          * The second firmware load requires us to normalize the APU state,
1028          * or the audio for the first analog capture will be badly incorrect.
1029          *
1030          * I can't seem to call APU_RESETAI and have it succeed without the
1031          * APU capturing audio, so we start and stop it here to do the reset
1032          */
1033
1034         /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1035         cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1036         cx18_vapi(cx, CX18_APU_RESETAI, 0);
1037         cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1038
1039         vf.tuner = 0;
1040         vf.type = V4L2_TUNER_ANALOG_TV;
1041         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1042
1043         /* Set initial frequency. For PAL/SECAM broadcasts no
1044            'default' channel exists AFAIK. */
1045         if (cx->std == V4L2_STD_NTSC_M_JP)
1046                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1047         else if (cx->std & V4L2_STD_NTSC_M)
1048                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1049
1050         video_input = cx->active_input;
1051         cx->active_input++;     /* Force update of input */
1052         cx18_s_input(NULL, &fh, video_input);
1053
1054         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1055            in one place. */
1056         cx->std++;              /* Force full standard initialization */
1057         cx18_s_std(NULL, &fh, &cx->tuner_std);
1058         cx18_s_frequency(NULL, &fh, &vf);
1059         return 0;
1060 }
1061
1062 static void cx18_cancel_epu_work_orders(struct cx18 *cx)
1063 {
1064         int i;
1065         for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++)
1066                 cancel_work_sync(&cx->epu_work_order[i].work);
1067 }
1068
1069 static void cx18_remove(struct pci_dev *pci_dev)
1070 {
1071         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1072         struct cx18 *cx = container_of(v4l2_dev, struct cx18, v4l2_dev);
1073
1074         CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
1075
1076         /* Stop all captures */
1077         CX18_DEBUG_INFO("Stopping all streams\n");
1078         if (atomic_read(&cx->tot_capturing) > 0)
1079                 cx18_stop_all_captures(cx);
1080
1081         /* Interrupts */
1082         cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1083         cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1084
1085         cx18_halt_firmware(cx);
1086
1087         cx18_cancel_epu_work_orders(cx);
1088
1089         destroy_workqueue(cx->work_queue);
1090
1091         cx18_streams_cleanup(cx, 1);
1092
1093         exit_cx18_i2c(cx);
1094
1095         free_irq(cx->pci_dev->irq, (void *)cx);
1096
1097         cx18_iounmap(cx);
1098
1099         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1100
1101         pci_disable_device(cx->pci_dev);
1102
1103         v4l2_device_unregister(v4l2_dev);
1104
1105         CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
1106 }
1107
1108 /* define a pci_driver for card detection */
1109 static struct pci_driver cx18_pci_driver = {
1110       .name =     "cx18",
1111       .id_table = cx18_pci_tbl,
1112       .probe =    cx18_probe,
1113       .remove =   cx18_remove,
1114 };
1115
1116 static int module_start(void)
1117 {
1118         printk(KERN_INFO "cx18:  Start initialization, version %s\n", CX18_VERSION);
1119
1120         memset(cx18_cards, 0, sizeof(cx18_cards));
1121
1122         /* Validate parameters */
1123         if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1124                 printk(KERN_ERR "cx18:  Exiting, cx18_first_minor must be between 0 and %d\n",
1125                      CX18_MAX_CARDS - 1);
1126                 return -1;
1127         }
1128
1129         if (cx18_debug < 0 || cx18_debug > 511) {
1130                 cx18_debug = 0;
1131                 printk(KERN_INFO "cx18:   Debug value must be >= 0 and <= 511!\n");
1132         }
1133
1134         if (pci_register_driver(&cx18_pci_driver)) {
1135                 printk(KERN_ERR "cx18:   Error detecting PCI card\n");
1136                 return -ENODEV;
1137         }
1138         printk(KERN_INFO "cx18:  End initialization\n");
1139         return 0;
1140 }
1141
1142 static void module_cleanup(void)
1143 {
1144         int i;
1145
1146         pci_unregister_driver(&cx18_pci_driver);
1147
1148         for (i = 0; i < cx18_cards_active; i++) {
1149                 if (cx18_cards[i] == NULL)
1150                         continue;
1151                 kfree(cx18_cards[i]);
1152         }
1153
1154 }
1155
1156 module_init(module_start);
1157 module_exit(module_cleanup);