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(&c, 0, sizeof(c)); 331 strlcpy(c.name, "cx18 tveeprom tmp", sizeof(c.name)); 332 c.adapter = &cx->i2c_adap[0]; 333 c.addr = 0xA0 >> 1; 334 335 memset(tv, 0, sizeof(*tv)); 336 if (tveeprom_read(&c, eedata, sizeof(eedata))) 337 return; 338 339 switch (cx->card->type) { 340 case CX18_CARD_HVR_1600_ESMT: 341 case CX18_CARD_HVR_1600_SAMSUNG: 342 case CX18_CARD_HVR_1600_S5H1411: 343 tveeprom_hauppauge_analog(&c, tv, eedata); 344 break; 345 case CX18_CARD_YUAN_MPC718: 346 case CX18_CARD_GOTVIEW_PCI_DVD3: 347 tv->model = 0x718; 348 cx18_eeprom_dump(cx, eedata, sizeof(eedata)); 349 CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n", 350 eedata[2], eedata[1], eedata[4], eedata[3]); 351 break; 352 default: 353 tv->model = 0xffffffff; 354 cx18_eeprom_dump(cx, eedata, sizeof(eedata)); 355 break; 356 } 357 } 358 359 static void cx18_process_eeprom(struct cx18 *cx) 360 { 361 struct tveeprom tv; 362 363 cx18_read_eeprom(cx, &tv); 364 365 /* Many thanks to Steven Toth from Hauppauge for providing the 366 model numbers */ 367 /* Note: the Samsung memory models cannot be reliably determined 368 from the model number. Use the cardtype module option if you 369 have one of these preproduction models. */ 370 switch (tv.model) { 371 case 74301: /* Retail models */ 372 case 74321: 373 case 74351: /* OEM models */ 374 case 74361: 375 /* Digital side is s5h1411/tda18271 */ 376 cx->card = cx18_get_card(CX18_CARD_HVR_1600_S5H1411); 377 break; 378 case 74021: /* Retail models */ 379 case 74031: 380 case 74041: 381 case 74141: 382 case 74541: /* OEM models */ 383 case 74551: 384 case 74591: 385 case 74651: 386 case 74691: 387 case 74751: 388 case 74891: 389 /* Digital side is s5h1409/mxl5005s */ 390 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); 391 break; 392 case 0x718: 393 return; 394 case 0xffffffff: 395 CX18_INFO("Unknown EEPROM encoding\n"); 396 return; 397 case 0: 398 CX18_ERR("Invalid EEPROM\n"); 399 return; 400 default: 401 CX18_ERR("Unknown model %d, defaulting to original HVR-1600 " 402 "(cardtype=1)\n", tv.model); 403 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); 404 break; 405 } 406 407 cx->v4l2_cap = cx->card->v4l2_capabilities; 408 cx->card_name = cx->card->name; 409 cx->card_i2c = cx->card->i2c; 410 411 CX18_INFO("Autodetected %s\n", cx->card_name); 412 413 if (tv.tuner_type == TUNER_ABSENT) 414 CX18_ERR("tveeprom cannot autodetect tuner!\n"); 415 416 if (cx->options.tuner == -1) 417 cx->options.tuner = tv.tuner_type; 418 if (cx->options.radio == -1) 419 cx->options.radio = (tv.has_radio != 0); 420 421 if (cx->std != 0) 422 /* user specified tuner standard */ 423 return; 424 425 /* autodetect tuner standard */ 426 #define TVEEPROM_TUNER_FORMAT_ALL (V4L2_STD_B | V4L2_STD_GH | \ 427 V4L2_STD_MN | \ 428 V4L2_STD_PAL_I | \ 429 V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC | \ 430 V4L2_STD_DK) 431 if ((tv.tuner_formats & TVEEPROM_TUNER_FORMAT_ALL) 432 == TVEEPROM_TUNER_FORMAT_ALL) { 433 CX18_DEBUG_INFO("Worldwide tuner detected\n"); 434 cx->std = V4L2_STD_ALL; 435 } else if (tv.tuner_formats & V4L2_STD_PAL) { 436 CX18_DEBUG_INFO("PAL tuner detected\n"); 437 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H; 438 } else if (tv.tuner_formats & V4L2_STD_NTSC) { 439 CX18_DEBUG_INFO("NTSC tuner detected\n"); 440 cx->std |= V4L2_STD_NTSC_M; 441 } else if (tv.tuner_formats & V4L2_STD_SECAM) { 442 CX18_DEBUG_INFO("SECAM tuner detected\n"); 443 cx->std |= V4L2_STD_SECAM_L; 444 } else { 445 CX18_INFO("No tuner detected, default to NTSC-M\n"); 446 cx->std |= V4L2_STD_NTSC_M; 447 } 448 } 449 450 static v4l2_std_id cx18_parse_std(struct cx18 *cx) 451 { 452 switch (pal[0]) { 453 case '6': 454 return V4L2_STD_PAL_60; 455 case 'b': 456 case 'B': 457 case 'g': 458 case 'G': 459 return V4L2_STD_PAL_BG; 460 case 'h': 461 case 'H': 462 return V4L2_STD_PAL_H; 463 case 'n': 464 case 'N': 465 if (pal[1] == 'c' || pal[1] == 'C') 466 return V4L2_STD_PAL_Nc; 467 return V4L2_STD_PAL_N; 468 case 'i': 469 case 'I': 470 return V4L2_STD_PAL_I; 471 case 'd': 472 case 'D': 473 case 'k': 474 case 'K': 475 return V4L2_STD_PAL_DK; 476 case 'M': 477 case 'm': 478 return V4L2_STD_PAL_M; 479 case '-': 480 break; 481 default: 482 CX18_WARN("pal= argument not recognised\n"); 483 return 0; 484 } 485 486 switch (secam[0]) { 487 case 'b': 488 case 'B': 489 case 'g': 490 case 'G': 491 case 'h': 492 case 'H': 493 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H; 494 case 'd': 495 case 'D': 496 case 'k': 497 case 'K': 498 return V4L2_STD_SECAM_DK; 499 case 'l': 500 case 'L': 501 if (secam[1] == 'C' || secam[1] == 'c') 502 return V4L2_STD_SECAM_LC; 503 return V4L2_STD_SECAM_L; 504 case '-': 505 break; 506 default: 507 CX18_WARN("secam= argument not recognised\n"); 508 return 0; 509 } 510 511 switch (ntsc[0]) { 512 case 'm': 513 case 'M': 514 return V4L2_STD_NTSC_M; 515 case 'j': 516 case 'J': 517 return V4L2_STD_NTSC_M_JP; 518 case 'k': 519 case 'K': 520 return V4L2_STD_NTSC_M_KR; 521 case '-': 522 break; 523 default: 524 CX18_WARN("ntsc= argument not recognised\n"); 525 return 0; 526 } 527 528 /* no match found */ 529 return 0; 530 } 531 532 static void cx18_process_options(struct cx18 *cx) 533 { 534 int i, j; 535 536 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers; 537 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers; 538 cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers; 539 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers; 540 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers; 541 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers; 542 cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */ 543 544 cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs; 545 cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs; 546 cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs; 547 cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs; 548 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs; 549 cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs; 550 cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */ 551 552 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize; 553 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize; 554 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize; 555 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize; 556 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_active_samples * 36; 557 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize; 558 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */ 559 560 /* Ensure stream_buffers & stream_buf_size are valid */ 561 for (i = 0; i < CX18_MAX_STREAMS; i++) { 562 if (cx->stream_buffers[i] == 0 || /* User said 0 buffers */ 563 cx->options.megabytes[i] <= 0 || /* User said 0 MB total */ 564 cx->stream_buf_size[i] <= 0) { /* User said buf size 0 */ 565 cx->options.megabytes[i] = 0; 566 cx->stream_buffers[i] = 0; 567 cx->stream_buf_size[i] = 0; 568 continue; 569 } 570 /* 571 * YUV is a special case where the stream_buf_size needs to be 572 * an integral multiple of 33.75 kB (storage for 32 screens 573 * lines to maintain alignment in case of lost buffers). 574 * 575 * IDX is a special case where the stream_buf_size should be 576 * an integral multiple of 1.5 kB (storage for 64 index entries 577 * to maintain alignment in case of lost buffers). 578 * 579 */ 580 if (i == CX18_ENC_STREAM_TYPE_YUV) { 581 cx->stream_buf_size[i] *= 1024; 582 cx->stream_buf_size[i] -= 583 (cx->stream_buf_size[i] % CX18_UNIT_ENC_YUV_BUFSIZE); 584 585 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_YUV_BUFSIZE) 586 cx->stream_buf_size[i] = 587 CX18_UNIT_ENC_YUV_BUFSIZE; 588 } else if (i == CX18_ENC_STREAM_TYPE_IDX) { 589 cx->stream_buf_size[i] *= 1024; 590 cx->stream_buf_size[i] -= 591 (cx->stream_buf_size[i] % CX18_UNIT_ENC_IDX_BUFSIZE); 592 593 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_IDX_BUFSIZE) 594 cx->stream_buf_size[i] = 595 CX18_UNIT_ENC_IDX_BUFSIZE; 596 } 597 /* 598 * YUV and IDX are special cases where the stream_buf_size is 599 * now in bytes. 600 * VBI is a special case where the stream_buf_size is fixed 601 * and already in bytes 602 */ 603 if (i == CX18_ENC_STREAM_TYPE_VBI || 604 i == CX18_ENC_STREAM_TYPE_YUV || 605 i == CX18_ENC_STREAM_TYPE_IDX) { 606 if (cx->stream_buffers[i] < 0) { 607 cx->stream_buffers[i] = 608 cx->options.megabytes[i] * 1024 * 1024 609 / cx->stream_buf_size[i]; 610 } else { 611 /* N.B. This might round down to 0 */ 612 cx->options.megabytes[i] = 613 cx->stream_buffers[i] 614 * cx->stream_buf_size[i]/(1024 * 1024); 615 } 616 } else { 617 /* All other streams have stream_buf_size in kB here */ 618 if (cx->stream_buffers[i] < 0) { 619 cx->stream_buffers[i] = 620 cx->options.megabytes[i] * 1024 621 / cx->stream_buf_size[i]; 622 } else { 623 /* N.B. This might round down to 0 */ 624 cx->options.megabytes[i] = 625 cx->stream_buffers[i] 626 * cx->stream_buf_size[i] / 1024; 627 } 628 /* convert from kB to bytes */ 629 cx->stream_buf_size[i] *= 1024; 630 } 631 CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, " 632 "%d bytes\n", i, cx->options.megabytes[i], 633 cx->stream_buffers[i], cx->stream_buf_size[i]); 634 } 635 636 cx->options.cardtype = cardtype[cx->instance]; 637 cx->options.tuner = tuner[cx->instance]; 638 cx->options.radio = radio[cx->instance]; 639 640 cx->std = cx18_parse_std(cx); 641 if (cx->options.cardtype == -1) { 642 CX18_INFO("Ignore card\n"); 643 return; 644 } 645 cx->card = cx18_get_card(cx->options.cardtype - 1); 646 if (cx->card) 647 CX18_INFO("User specified %s card\n", cx->card->name); 648 else if (cx->options.cardtype != 0) 649 CX18_ERR("Unknown user specified type, trying to autodetect card\n"); 650 if (cx->card == NULL) { 651 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) { 652 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); 653 CX18_INFO("Autodetected Hauppauge card\n"); 654 } 655 } 656 if (cx->card == NULL) { 657 for (i = 0; (cx->card = cx18_get_card(i)); i++) { 658 if (cx->card->pci_list == NULL) 659 continue; 660 for (j = 0; cx->card->pci_list[j].device; j++) { 661 if (cx->pci_dev->device != 662 cx->card->pci_list[j].device) 663 continue; 664 if (cx->pci_dev->subsystem_vendor != 665 cx->card->pci_list[j].subsystem_vendor) 666 continue; 667 if (cx->pci_dev->subsystem_device != 668 cx->card->pci_list[j].subsystem_device) 669 continue; 670 CX18_INFO("Autodetected %s card\n", cx->card->name); 671 goto done; 672 } 673 } 674 } 675 done: 676 677 if (cx->card == NULL) { 678 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); 679 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n", 680 cx->pci_dev->vendor, cx->pci_dev->device); 681 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n", 682 cx->pci_dev->subsystem_vendor, 683 cx->pci_dev->subsystem_device); 684 CX18_ERR("Defaulting to %s card\n", cx->card->name); 685 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n"); 686 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n"); 687 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n"); 688 } 689 cx->v4l2_cap = cx->card->v4l2_capabilities; 690 cx->card_name = cx->card->name; 691 cx->card_i2c = cx->card->i2c; 692 } 693 694 static int cx18_create_in_workq(struct cx18 *cx) 695 { 696 snprintf(cx->in_workq_name, sizeof(cx->in_workq_name), "%s-in", 697 cx->v4l2_dev.name); 698 cx->in_work_queue = alloc_ordered_workqueue(cx->in_workq_name, 0); 699 if (cx->in_work_queue == NULL) { 700 CX18_ERR("Unable to create incoming mailbox handler thread\n"); 701 return -ENOMEM; 702 } 703 return 0; 704 } 705 706 static void cx18_init_in_work_orders(struct cx18 *cx) 707 { 708 int i; 709 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) { 710 cx->in_work_order[i].cx = cx; 711 cx->in_work_order[i].str = cx->epu_debug_str; 712 INIT_WORK(&cx->in_work_order[i].work, cx18_in_work_handler); 713 } 714 } 715 716 /* Precondition: the cx18 structure has been memset to 0. Only 717 the dev and instance fields have been filled in. 718 No assumptions on the card type may be made here (see cx18_init_struct2 719 for that). 720 */ 721 static int cx18_init_struct1(struct cx18 *cx) 722 { 723 int ret; 724 725 cx->base_addr = pci_resource_start(cx->pci_dev, 0); 726 727 mutex_init(&cx->serialize_lock); 728 mutex_init(&cx->gpio_lock); 729 mutex_init(&cx->epu2apu_mb_lock); 730 mutex_init(&cx->epu2cpu_mb_lock); 731 732 ret = cx18_create_in_workq(cx); 733 if (ret) 734 return ret; 735 736 cx18_init_in_work_orders(cx); 737 738 /* start counting open_id at 1 */ 739 cx->open_id = 1; 740 741 /* Initial settings */ 742 cx->cxhdl.port = CX2341X_PORT_MEMORY; 743 cx->cxhdl.capabilities = CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_SLICED_VBI; 744 cx->cxhdl.ops = &cx18_cxhdl_ops; 745 cx->cxhdl.func = cx18_api_func; 746 cx->cxhdl.priv = &cx->streams[CX18_ENC_STREAM_TYPE_MPG]; 747 ret = cx2341x_handler_init(&cx->cxhdl, 50); 748 if (ret) 749 return ret; 750 cx->v4l2_dev.ctrl_handler = &cx->cxhdl.hdl; 751 752 cx->temporal_strength = cx->cxhdl.video_temporal_filter->cur.val; 753 cx->spatial_strength = cx->cxhdl.video_spatial_filter->cur.val; 754 cx->filter_mode = cx->cxhdl.video_spatial_filter_mode->cur.val | 755 (cx->cxhdl.video_temporal_filter_mode->cur.val << 1) | 756 (cx->cxhdl.video_median_filter_type->cur.val << 2); 757 758 init_waitqueue_head(&cx->cap_w); 759 init_waitqueue_head(&cx->mb_apu_waitq); 760 init_waitqueue_head(&cx->mb_cpu_waitq); 761 init_waitqueue_head(&cx->dma_waitq); 762 763 /* VBI */ 764 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE; 765 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced; 766 767 /* IVTV style VBI insertion into MPEG streams */ 768 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_buf.list); 769 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.list); 770 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.buf_list); 771 list_add(&cx->vbi.sliced_mpeg_buf.list, 772 &cx->vbi.sliced_mpeg_mdl.buf_list); 773 return 0; 774 } 775 776 /* Second initialization part. Here the card type has been 777 autodetected. */ 778 static void cx18_init_struct2(struct cx18 *cx) 779 { 780 int i; 781 782 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++) 783 if (cx->card->video_inputs[i].video_type == 0) 784 break; 785 cx->nof_inputs = i; 786 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++) 787 if (cx->card->audio_inputs[i].audio_type == 0) 788 break; 789 cx->nof_audio_inputs = i; 790 791 /* Find tuner input */ 792 for (i = 0; i < cx->nof_inputs; i++) { 793 if (cx->card->video_inputs[i].video_type == 794 CX18_CARD_INPUT_VID_TUNER) 795 break; 796 } 797 if (i == cx->nof_inputs) 798 i = 0; 799 cx->active_input = i; 800 cx->audio_input = cx->card->video_inputs[i].audio_index; 801 } 802 803 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev, 804 const struct pci_device_id *pci_id) 805 { 806 u16 cmd; 807 unsigned char pci_latency; 808 809 CX18_DEBUG_INFO("Enabling pci device\n"); 810 811 if (pci_enable_device(pci_dev)) { 812 CX18_ERR("Can't enable device %d!\n", cx->instance); 813 return -EIO; 814 } 815 if (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32))) { 816 CX18_ERR("No suitable DMA available, card %d\n", cx->instance); 817 return -EIO; 818 } 819 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) { 820 CX18_ERR("Cannot request encoder memory region, card %d\n", 821 cx->instance); 822 return -EIO; 823 } 824 825 /* Enable bus mastering and memory mapped IO for the CX23418 */ 826 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd); 827 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER; 828 pci_write_config_word(pci_dev, PCI_COMMAND, cmd); 829 830 cx->card_rev = pci_dev->revision; 831 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency); 832 833 if (pci_latency < 64 && cx18_pci_latency) { 834 CX18_INFO("Unreasonably low latency timer, " 835 "setting to 64 (was %d)\n", pci_latency); 836 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64); 837 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency); 838 } 839 840 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, " 841 "irq: %d, latency: %d, memory: 0x%llx\n", 842 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number, 843 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn), 844 cx->pci_dev->irq, pci_latency, (u64)cx->base_addr); 845 846 return 0; 847 } 848 849 static void cx18_init_subdevs(struct cx18 *cx) 850 { 851 u32 hw = cx->card->hw_all; 852 u32 device; 853 int i; 854 855 for (i = 0, device = 1; i < 32; i++, device <<= 1) { 856 857 if (!(device & hw)) 858 continue; 859 860 switch (device) { 861 case CX18_HW_DVB: 862 case CX18_HW_TVEEPROM: 863 /* These subordinate devices do not use probing */ 864 cx->hw_flags |= device; 865 break; 866 case CX18_HW_418_AV: 867 /* The A/V decoder gets probed earlier to set PLLs */ 868 /* Just note that the card uses it (i.e. has analog) */ 869 cx->hw_flags |= device; 870 break; 871 case CX18_HW_GPIO_RESET_CTRL: 872 /* 873 * The Reset Controller gets probed and added to 874 * hw_flags earlier for i2c adapter/bus initialization 875 */ 876 break; 877 case CX18_HW_GPIO_MUX: 878 if (cx18_gpio_register(cx, device) == 0) 879 cx->hw_flags |= device; 880 break; 881 default: 882 if (cx18_i2c_register(cx, i) == 0) 883 cx->hw_flags |= device; 884 break; 885 } 886 } 887 888 if (cx->hw_flags & CX18_HW_418_AV) 889 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV); 890 891 if (cx->card->hw_muxer != 0) 892 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer); 893 } 894 895 static int cx18_probe(struct pci_dev *pci_dev, 896 const struct pci_device_id *pci_id) 897 { 898 int retval = 0; 899 int i; 900 u32 devtype; 901 struct cx18 *cx; 902 903 /* FIXME - module parameter arrays constrain max instances */ 904 i = atomic_inc_return(&cx18_instance) - 1; 905 if (i >= CX18_MAX_CARDS) { 906 printk(KERN_ERR "cx18: cannot manage card %d, driver has a " 907 "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1); 908 return -ENOMEM; 909 } 910 911 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC); 912 if (cx == NULL) { 913 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n", 914 i); 915 return -ENOMEM; 916 } 917 cx->pci_dev = pci_dev; 918 cx->instance = i; 919 920 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev); 921 if (retval) { 922 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed" 923 "\n", cx->instance); 924 kfree(cx); 925 return retval; 926 } 927 snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d", 928 cx->instance); 929 CX18_INFO("Initializing card %d\n", cx->instance); 930 931 cx18_process_options(cx); 932 if (cx->options.cardtype == -1) { 933 retval = -ENODEV; 934 goto err; 935 } 936 937 retval = cx18_init_struct1(cx); 938 if (retval) 939 goto err; 940 941 CX18_DEBUG_INFO("base addr: 0x%llx\n", (u64)cx->base_addr); 942 943 /* PCI Device Setup */ 944 retval = cx18_setup_pci(cx, pci_dev, pci_id); 945 if (retval != 0) 946 goto free_workqueues; 947 948 /* map io memory */ 949 CX18_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n", 950 (u64)cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE); 951 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET, 952 CX18_MEM_SIZE); 953 if (!cx->enc_mem) { 954 CX18_ERR("ioremap failed. Can't get a window into CX23418 " 955 "memory and register space\n"); 956 CX18_ERR("Each capture card with a CX23418 needs 64 MB of " 957 "vmalloc address space for the window\n"); 958 CX18_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n"); 959 CX18_ERR("Use the vmalloc= kernel command line option to set " 960 "VmallocTotal to a larger value\n"); 961 retval = -ENOMEM; 962 goto free_mem; 963 } 964 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET; 965 devtype = cx18_read_reg(cx, 0xC72028); 966 switch (devtype & 0xff000000) { 967 case 0xff000000: 968 CX18_INFO("cx23418 revision %08x (A)\n", devtype); 969 break; 970 case 0x01000000: 971 CX18_INFO("cx23418 revision %08x (B)\n", devtype); 972 break; 973 default: 974 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype); 975 break; 976 } 977 978 cx18_init_power(cx, 1); 979 cx18_init_memory(cx); 980 981 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET); 982 cx18_init_scb(cx); 983 984 cx18_gpio_init(cx); 985 986 /* Initialize integrated A/V decoder early to set PLLs, just in case */ 987 retval = cx18_av_probe(cx); 988 if (retval) { 989 CX18_ERR("Could not register A/V decoder subdevice\n"); 990 goto free_map; 991 } 992 993 /* Initialize GPIO Reset Controller to do chip resets during i2c init */ 994 if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) { 995 if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0) 996 CX18_WARN("Could not register GPIO reset controller" 997 "subdevice; proceeding anyway.\n"); 998 else 999 cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL; 1000 } 1001 1002 /* active i2c */ 1003 CX18_DEBUG_INFO("activating i2c...\n"); 1004 retval = init_cx18_i2c(cx); 1005 if (retval) { 1006 CX18_ERR("Could not initialize i2c\n"); 1007 goto free_map; 1008 } 1009 1010 if (cx->card->hw_all & CX18_HW_TVEEPROM) { 1011 /* Based on the model number the cardtype may be changed. 1012 The PCI IDs are not always reliable. */ 1013 const struct cx18_card *orig_card = cx->card; 1014 cx18_process_eeprom(cx); 1015 1016 if (cx->card != orig_card) { 1017 /* Changed the cardtype; re-reset the I2C chips */ 1018 cx18_gpio_init(cx); 1019 cx18_call_hw(cx, CX18_HW_GPIO_RESET_CTRL, 1020 core, reset, (u32) CX18_GPIO_RESET_I2C); 1021 } 1022 } 1023 if (cx->card->comment) 1024 CX18_INFO("%s", cx->card->comment); 1025 if (cx->card->v4l2_capabilities == 0) { 1026 retval = -ENODEV; 1027 goto free_i2c; 1028 } 1029 cx18_init_memory(cx); 1030 cx18_init_scb(cx); 1031 1032 /* Register IRQ */ 1033 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler, 1034 IRQF_SHARED | IRQF_DISABLED, 1035 cx->v4l2_dev.name, (void *)cx); 1036 if (retval) { 1037 CX18_ERR("Failed to register irq %d\n", retval); 1038 goto free_i2c; 1039 } 1040 1041 if (cx->std == 0) 1042 cx->std = V4L2_STD_NTSC_M; 1043 1044 if (cx->options.tuner == -1) { 1045 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) { 1046 if ((cx->std & cx->card->tuners[i].std) == 0) 1047 continue; 1048 cx->options.tuner = cx->card->tuners[i].tuner; 1049 break; 1050 } 1051 } 1052 /* if no tuner was found, then pick the first tuner in the card list */ 1053 if (cx->options.tuner == -1 && cx->card->tuners[0].std) { 1054 cx->std = cx->card->tuners[0].std; 1055 if (cx->std & V4L2_STD_PAL) 1056 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H; 1057 else if (cx->std & V4L2_STD_NTSC) 1058 cx->std = V4L2_STD_NTSC_M; 1059 else if (cx->std & V4L2_STD_SECAM) 1060 cx->std = V4L2_STD_SECAM_L; 1061 cx->options.tuner = cx->card->tuners[0].tuner; 1062 } 1063 if (cx->options.radio == -1) 1064 cx->options.radio = (cx->card->radio_input.audio_type != 0); 1065 1066 /* The card is now fully identified, continue with card-specific 1067 initialization. */ 1068 cx18_init_struct2(cx); 1069 1070 cx18_init_subdevs(cx); 1071 1072 if (cx->std & V4L2_STD_525_60) 1073 cx->is_60hz = 1; 1074 else 1075 cx->is_50hz = 1; 1076 1077 cx2341x_handler_set_50hz(&cx->cxhdl, !cx->is_60hz); 1078 1079 if (cx->options.radio > 0) 1080 cx->v4l2_cap |= V4L2_CAP_RADIO; 1081 1082 if (cx->options.tuner > -1) { 1083 struct tuner_setup setup; 1084 1085 setup.addr = ADDR_UNSET; 1086 setup.type = cx->options.tuner; 1087 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */ 1088 if (cx->options.radio > 0) 1089 setup.mode_mask |= T_RADIO; 1090 setup.tuner_callback = (setup.type == TUNER_XC2028) ? 1091 cx18_reset_tuner_gpio : NULL; 1092 cx18_call_all(cx, tuner, s_type_addr, &setup); 1093 if (setup.type == TUNER_XC2028) { 1094 static struct xc2028_ctrl ctrl = { 1095 .fname = XC2028_DEFAULT_FIRMWARE, 1096 .max_len = 64, 1097 }; 1098 struct v4l2_priv_tun_config cfg = { 1099 .tuner = cx->options.tuner, 1100 .priv = &ctrl, 1101 }; 1102 cx18_call_all(cx, tuner, s_config, &cfg); 1103 } 1104 } 1105 1106 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video) 1107 are not. */ 1108 cx->tuner_std = cx->std; 1109 if (cx->std == V4L2_STD_ALL) 1110 cx->std = V4L2_STD_NTSC_M; 1111 1112 retval = cx18_streams_setup(cx); 1113 if (retval) { 1114 CX18_ERR("Error %d setting up streams\n", retval); 1115 goto free_irq; 1116 } 1117 retval = cx18_streams_register(cx); 1118 if (retval) { 1119 CX18_ERR("Error %d registering devices\n", retval); 1120 goto free_streams; 1121 } 1122 1123 CX18_INFO("Initialized card: %s\n", cx->card_name); 1124 1125 /* Load cx18 submodules (cx18-alsa) */ 1126 request_modules(cx); 1127 return 0; 1128 1129 free_streams: 1130 cx18_streams_cleanup(cx, 1); 1131 free_irq: 1132 free_irq(cx->pci_dev->irq, (void *)cx); 1133 free_i2c: 1134 exit_cx18_i2c(cx); 1135 free_map: 1136 cx18_iounmap(cx); 1137 free_mem: 1138 release_mem_region(cx->base_addr, CX18_MEM_SIZE); 1139 free_workqueues: 1140 destroy_workqueue(cx->in_work_queue); 1141 err: 1142 if (retval == 0) 1143 retval = -ENODEV; 1144 CX18_ERR("Error %d on initialization\n", retval); 1145 1146 v4l2_device_unregister(&cx->v4l2_dev); 1147 kfree(cx); 1148 return retval; 1149 } 1150 1151 int cx18_init_on_first_open(struct cx18 *cx) 1152 { 1153 int video_input; 1154 int fw_retry_count = 3; 1155 struct v4l2_frequency vf; 1156 struct cx18_open_id fh; 1157 v4l2_std_id std; 1158 1159 fh.cx = cx; 1160 1161 if (test_bit(CX18_F_I_FAILED, &cx->i_flags)) 1162 return -ENXIO; 1163 1164 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags)) 1165 return 0; 1166 1167 while (--fw_retry_count > 0) { 1168 /* load firmware */ 1169 if (cx18_firmware_init(cx) == 0) 1170 break; 1171 if (fw_retry_count > 1) 1172 CX18_WARN("Retry loading firmware\n"); 1173 } 1174 1175 if (fw_retry_count == 0) { 1176 set_bit(CX18_F_I_FAILED, &cx->i_flags); 1177 return -ENXIO; 1178 } 1179 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags); 1180 1181 /* 1182 * Init the firmware twice to work around a silicon bug 1183 * with the digital TS. 1184 * 1185 * The second firmware load requires us to normalize the APU state, 1186 * or the audio for the first analog capture will be badly incorrect. 1187 * 1188 * I can't seem to call APU_RESETAI and have it succeed without the 1189 * APU capturing audio, so we start and stop it here to do the reset 1190 */ 1191 1192 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */ 1193 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0); 1194 cx18_vapi(cx, CX18_APU_RESETAI, 0); 1195 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG); 1196 1197 fw_retry_count = 3; 1198 while (--fw_retry_count > 0) { 1199 /* load firmware */ 1200 if (cx18_firmware_init(cx) == 0) 1201 break; 1202 if (fw_retry_count > 1) 1203 CX18_WARN("Retry loading firmware\n"); 1204 } 1205 1206 if (fw_retry_count == 0) { 1207 set_bit(CX18_F_I_FAILED, &cx->i_flags); 1208 return -ENXIO; 1209 } 1210 1211 /* 1212 * The second firmware load requires us to normalize the APU state, 1213 * or the audio for the first analog capture will be badly incorrect. 1214 * 1215 * I can't seem to call APU_RESETAI and have it succeed without the 1216 * APU capturing audio, so we start and stop it here to do the reset 1217 */ 1218 1219 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */ 1220 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0); 1221 cx18_vapi(cx, CX18_APU_RESETAI, 0); 1222 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG); 1223 1224 /* Init the A/V decoder, if it hasn't been already */ 1225 v4l2_subdev_call(cx->sd_av, core, load_fw); 1226 1227 vf.tuner = 0; 1228 vf.type = V4L2_TUNER_ANALOG_TV; 1229 vf.frequency = 6400; /* the tuner 'baseline' frequency */ 1230 1231 /* Set initial frequency. For PAL/SECAM broadcasts no 1232 'default' channel exists AFAIK. */ 1233 if (cx->std == V4L2_STD_NTSC_M_JP) 1234 vf.frequency = 1460; /* ch. 1 91250*16/1000 */ 1235 else if (cx->std & V4L2_STD_NTSC_M) 1236 vf.frequency = 1076; /* ch. 4 67250*16/1000 */ 1237 1238 video_input = cx->active_input; 1239 cx->active_input++; /* Force update of input */ 1240 cx18_s_input(NULL, &fh, video_input); 1241 1242 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code 1243 in one place. */ 1244 cx->std++; /* Force full standard initialization */ 1245 std = (cx->tuner_std == V4L2_STD_ALL) ? V4L2_STD_NTSC_M : cx->tuner_std; 1246 cx18_s_std(NULL, &fh, &std); 1247 cx18_s_frequency(NULL, &fh, &vf); 1248 return 0; 1249 } 1250 1251 static void cx18_cancel_in_work_orders(struct cx18 *cx) 1252 { 1253 int i; 1254 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) 1255 cancel_work_sync(&cx->in_work_order[i].work); 1256 } 1257 1258 static void cx18_cancel_out_work_orders(struct cx18 *cx) 1259 { 1260 int i; 1261 for (i = 0; i < CX18_MAX_STREAMS; i++) 1262 if (&cx->streams[i].video_dev != NULL) 1263 cancel_work_sync(&cx->streams[i].out_work_order); 1264 } 1265 1266 static void cx18_remove(struct pci_dev *pci_dev) 1267 { 1268 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev); 1269 struct cx18 *cx = to_cx18(v4l2_dev); 1270 int i; 1271 1272 CX18_DEBUG_INFO("Removing Card\n"); 1273 1274 flush_request_modules(cx); 1275 1276 /* Stop all captures */ 1277 CX18_DEBUG_INFO("Stopping all streams\n"); 1278 if (atomic_read(&cx->tot_capturing) > 0) 1279 cx18_stop_all_captures(cx); 1280 1281 /* Stop interrupts that cause incoming work to be queued */ 1282 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU); 1283 1284 /* Incoming work can cause outgoing work, so clean up incoming first */ 1285 cx18_cancel_in_work_orders(cx); 1286 cx18_cancel_out_work_orders(cx); 1287 1288 /* Stop ack interrupts that may have been needed for work to finish */ 1289 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK); 1290 1291 cx18_halt_firmware(cx); 1292 1293 destroy_workqueue(cx->in_work_queue); 1294 1295 cx18_streams_cleanup(cx, 1); 1296 1297 exit_cx18_i2c(cx); 1298 1299 free_irq(cx->pci_dev->irq, (void *)cx); 1300 1301 cx18_iounmap(cx); 1302 1303 release_mem_region(cx->base_addr, CX18_MEM_SIZE); 1304 1305 pci_disable_device(cx->pci_dev); 1306 1307 if (cx->vbi.sliced_mpeg_data[0] != NULL) 1308 for (i = 0; i < CX18_VBI_FRAMES; i++) 1309 kfree(cx->vbi.sliced_mpeg_data[i]); 1310 1311 v4l2_ctrl_handler_free(&cx->av_state.hdl); 1312 1313 CX18_INFO("Removed %s\n", cx->card_name); 1314 1315 v4l2_device_unregister(v4l2_dev); 1316 kfree(cx); 1317 } 1318 1319 1320 /* define a pci_driver for card detection */ 1321 static struct pci_driver cx18_pci_driver = { 1322 .name = "cx18", 1323 .id_table = cx18_pci_tbl, 1324 .probe = cx18_probe, 1325 .remove = cx18_remove, 1326 }; 1327 1328 static int __init module_start(void) 1329 { 1330 printk(KERN_INFO "cx18: Start initialization, version %s\n", 1331 CX18_VERSION); 1332 1333 /* Validate parameters */ 1334 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) { 1335 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n", 1336 CX18_MAX_CARDS - 1); 1337 return -1; 1338 } 1339 1340 if (cx18_debug < 0 || cx18_debug > 511) { 1341 cx18_debug = 0; 1342 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n"); 1343 } 1344 1345 if (pci_register_driver(&cx18_pci_driver)) { 1346 printk(KERN_ERR "cx18: Error detecting PCI card\n"); 1347 return -ENODEV; 1348 } 1349 printk(KERN_INFO "cx18: End initialization\n"); 1350 return 0; 1351 } 1352 1353 static void __exit module_cleanup(void) 1354 { 1355 pci_unregister_driver(&cx18_pci_driver); 1356 } 1357 1358 module_init(module_start); 1359 module_exit(module_cleanup); 1360 MODULE_FIRMWARE(XC2028_DEFAULT_FIRMWARE); 1361