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