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