1 /* 2 * Driver for the NXP SAA7164 PCIe bridge 3 * 4 * Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include <linux/init.h> 23 #include <linux/list.h> 24 #include <linux/module.h> 25 #include <linux/moduleparam.h> 26 #include <linux/kmod.h> 27 #include <linux/kernel.h> 28 #include <linux/slab.h> 29 #include <linux/interrupt.h> 30 #include <linux/delay.h> 31 #include <asm/div64.h> 32 33 #ifdef CONFIG_PROC_FS 34 #include <linux/proc_fs.h> 35 #endif 36 #include "saa7164.h" 37 38 MODULE_DESCRIPTION("Driver for NXP SAA7164 based TV cards"); 39 MODULE_AUTHOR("Steven Toth <stoth@kernellabs.com>"); 40 MODULE_LICENSE("GPL"); 41 42 /* 43 * 1 Basic 44 * 2 45 * 4 i2c 46 * 8 api 47 * 16 cmd 48 * 32 bus 49 */ 50 51 unsigned int saa_debug; 52 module_param_named(debug, saa_debug, int, 0644); 53 MODULE_PARM_DESC(debug, "enable debug messages"); 54 55 static unsigned int fw_debug; 56 module_param(fw_debug, int, 0644); 57 MODULE_PARM_DESC(fw_debug, "Firmware debug level def:2"); 58 59 unsigned int encoder_buffers = SAA7164_MAX_ENCODER_BUFFERS; 60 module_param(encoder_buffers, int, 0644); 61 MODULE_PARM_DESC(encoder_buffers, "Total buffers in read queue 16-512 def:64"); 62 63 unsigned int vbi_buffers = SAA7164_MAX_VBI_BUFFERS; 64 module_param(vbi_buffers, int, 0644); 65 MODULE_PARM_DESC(vbi_buffers, "Total buffers in read queue 16-512 def:64"); 66 67 unsigned int waitsecs = 10; 68 module_param(waitsecs, int, 0644); 69 MODULE_PARM_DESC(waitsecs, "timeout on firmware messages"); 70 71 static unsigned int card[] = {[0 ... (SAA7164_MAXBOARDS - 1)] = UNSET }; 72 module_param_array(card, int, NULL, 0444); 73 MODULE_PARM_DESC(card, "card type"); 74 75 static unsigned int print_histogram = 64; 76 module_param(print_histogram, int, 0644); 77 MODULE_PARM_DESC(print_histogram, "print histogram values once"); 78 79 unsigned int crc_checking = 1; 80 module_param(crc_checking, int, 0644); 81 MODULE_PARM_DESC(crc_checking, "enable crc sanity checking on buffers"); 82 83 static unsigned int guard_checking = 1; 84 module_param(guard_checking, int, 0644); 85 MODULE_PARM_DESC(guard_checking, 86 "enable dma sanity checking for buffer overruns"); 87 88 static bool enable_msi = true; 89 module_param(enable_msi, bool, 0444); 90 MODULE_PARM_DESC(enable_msi, 91 "enable the use of an msi interrupt if available"); 92 93 static unsigned int saa7164_devcount; 94 95 static DEFINE_MUTEX(devlist); 96 LIST_HEAD(saa7164_devlist); 97 98 #define INT_SIZE 16 99 100 static void saa7164_pack_verifier(struct saa7164_buffer *buf) 101 { 102 u8 *p = (u8 *)buf->cpu; 103 int i; 104 105 for (i = 0; i < buf->actual_size; i += 2048) { 106 107 if ((*(p + i + 0) != 0x00) || (*(p + i + 1) != 0x00) || 108 (*(p + i + 2) != 0x01) || (*(p + i + 3) != 0xBA)) { 109 printk(KERN_ERR "No pack at 0x%x\n", i); 110 #if 0 111 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, 112 p + 1, 32, false); 113 #endif 114 } 115 } 116 } 117 118 #define FIXED_VIDEO_PID 0xf1 119 #define FIXED_AUDIO_PID 0xf2 120 121 static void saa7164_ts_verifier(struct saa7164_buffer *buf) 122 { 123 struct saa7164_port *port = buf->port; 124 u32 i; 125 u8 cc, a; 126 u16 pid; 127 u8 *bufcpu = (u8 *)buf->cpu; 128 129 port->sync_errors = 0; 130 port->v_cc_errors = 0; 131 port->a_cc_errors = 0; 132 133 for (i = 0; i < buf->actual_size; i += 188) { 134 if (*(bufcpu + i) != 0x47) 135 port->sync_errors++; 136 137 /* TODO: Query pid lower 8 bits, ignoring upper bits intensionally */ 138 pid = ((*(bufcpu + i + 1) & 0x1f) << 8) | *(bufcpu + i + 2); 139 cc = *(bufcpu + i + 3) & 0x0f; 140 141 if (pid == FIXED_VIDEO_PID) { 142 a = ((port->last_v_cc + 1) & 0x0f); 143 if (a != cc) { 144 printk(KERN_ERR "video cc last = %x current = %x i = %d\n", 145 port->last_v_cc, cc, i); 146 port->v_cc_errors++; 147 } 148 149 port->last_v_cc = cc; 150 } else 151 if (pid == FIXED_AUDIO_PID) { 152 a = ((port->last_a_cc + 1) & 0x0f); 153 if (a != cc) { 154 printk(KERN_ERR "audio cc last = %x current = %x i = %d\n", 155 port->last_a_cc, cc, i); 156 port->a_cc_errors++; 157 } 158 159 port->last_a_cc = cc; 160 } 161 162 } 163 164 /* Only report errors if we've been through this function atleast 165 * once already and the cached cc values are primed. First time through 166 * always generates errors. 167 */ 168 if (port->v_cc_errors && (port->done_first_interrupt > 1)) 169 printk(KERN_ERR "video pid cc, %d errors\n", port->v_cc_errors); 170 171 if (port->a_cc_errors && (port->done_first_interrupt > 1)) 172 printk(KERN_ERR "audio pid cc, %d errors\n", port->a_cc_errors); 173 174 if (port->sync_errors && (port->done_first_interrupt > 1)) 175 printk(KERN_ERR "sync_errors = %d\n", port->sync_errors); 176 177 if (port->done_first_interrupt == 1) 178 port->done_first_interrupt++; 179 } 180 181 static void saa7164_histogram_reset(struct saa7164_histogram *hg, char *name) 182 { 183 int i; 184 185 memset(hg, 0, sizeof(struct saa7164_histogram)); 186 strcpy(hg->name, name); 187 188 /* First 30ms x 1ms */ 189 for (i = 0; i < 30; i++) 190 hg->counter1[0 + i].val = i; 191 192 /* 30 - 200ms x 10ms */ 193 for (i = 0; i < 18; i++) 194 hg->counter1[30 + i].val = 30 + (i * 10); 195 196 /* 200 - 2000ms x 100ms */ 197 for (i = 0; i < 15; i++) 198 hg->counter1[48 + i].val = 200 + (i * 200); 199 200 /* Catch all massive value (2secs) */ 201 hg->counter1[55].val = 2000; 202 203 /* Catch all massive value (4secs) */ 204 hg->counter1[56].val = 4000; 205 206 /* Catch all massive value (8secs) */ 207 hg->counter1[57].val = 8000; 208 209 /* Catch all massive value (15secs) */ 210 hg->counter1[58].val = 15000; 211 212 /* Catch all massive value (30secs) */ 213 hg->counter1[59].val = 30000; 214 215 /* Catch all massive value (60secs) */ 216 hg->counter1[60].val = 60000; 217 218 /* Catch all massive value (5mins) */ 219 hg->counter1[61].val = 300000; 220 221 /* Catch all massive value (15mins) */ 222 hg->counter1[62].val = 900000; 223 224 /* Catch all massive values (1hr) */ 225 hg->counter1[63].val = 3600000; 226 } 227 228 void saa7164_histogram_update(struct saa7164_histogram *hg, u32 val) 229 { 230 int i; 231 for (i = 0; i < 64; i++) { 232 if (val <= hg->counter1[i].val) { 233 hg->counter1[i].count++; 234 hg->counter1[i].update_time = jiffies; 235 break; 236 } 237 } 238 } 239 240 static void saa7164_histogram_print(struct saa7164_port *port, 241 struct saa7164_histogram *hg) 242 { 243 u32 entries = 0; 244 int i; 245 246 printk(KERN_ERR "Histogram named %s (ms, count, last_update_jiffy)\n", hg->name); 247 for (i = 0; i < 64; i++) { 248 if (hg->counter1[i].count == 0) 249 continue; 250 251 printk(KERN_ERR " %4d %12d %Ld\n", 252 hg->counter1[i].val, 253 hg->counter1[i].count, 254 hg->counter1[i].update_time); 255 256 entries++; 257 } 258 printk(KERN_ERR "Total: %d\n", entries); 259 } 260 261 static void saa7164_work_enchandler_helper(struct saa7164_port *port, int bufnr) 262 { 263 struct saa7164_dev *dev = port->dev; 264 struct saa7164_buffer *buf = NULL; 265 struct saa7164_user_buffer *ubuf = NULL; 266 struct list_head *c, *n; 267 int i = 0; 268 u8 *p; 269 270 mutex_lock(&port->dmaqueue_lock); 271 list_for_each_safe(c, n, &port->dmaqueue.list) { 272 273 buf = list_entry(c, struct saa7164_buffer, list); 274 if (i++ > port->hwcfg.buffercount) { 275 printk(KERN_ERR "%s() illegal i count %d\n", 276 __func__, i); 277 break; 278 } 279 280 if (buf->idx == bufnr) { 281 282 /* Found the buffer, deal with it */ 283 dprintk(DBGLVL_IRQ, "%s() bufnr: %d\n", __func__, bufnr); 284 285 if (crc_checking) { 286 /* Throw a new checksum on the dma buffer */ 287 buf->crc = crc32(0, buf->cpu, buf->actual_size); 288 } 289 290 if (guard_checking) { 291 p = (u8 *)buf->cpu; 292 if ((*(p + buf->actual_size + 0) != 0xff) || 293 (*(p + buf->actual_size + 1) != 0xff) || 294 (*(p + buf->actual_size + 2) != 0xff) || 295 (*(p + buf->actual_size + 3) != 0xff) || 296 (*(p + buf->actual_size + 0x10) != 0xff) || 297 (*(p + buf->actual_size + 0x11) != 0xff) || 298 (*(p + buf->actual_size + 0x12) != 0xff) || 299 (*(p + buf->actual_size + 0x13) != 0xff)) { 300 printk(KERN_ERR "%s() buf %p guard buffer breach\n", 301 __func__, buf); 302 #if 0 303 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, 304 p + buf->actual_size - 32, 64, false); 305 #endif 306 } 307 } 308 309 if ((port->nr != SAA7164_PORT_VBI1) && (port->nr != SAA7164_PORT_VBI2)) { 310 /* Validate the incoming buffer content */ 311 if (port->encoder_params.stream_type == V4L2_MPEG_STREAM_TYPE_MPEG2_TS) 312 saa7164_ts_verifier(buf); 313 else if (port->encoder_params.stream_type == V4L2_MPEG_STREAM_TYPE_MPEG2_PS) 314 saa7164_pack_verifier(buf); 315 } 316 317 /* find a free user buffer and clone to it */ 318 if (!list_empty(&port->list_buf_free.list)) { 319 320 /* Pull the first buffer from the used list */ 321 ubuf = list_first_entry(&port->list_buf_free.list, 322 struct saa7164_user_buffer, list); 323 324 if (buf->actual_size <= ubuf->actual_size) { 325 326 memcpy(ubuf->data, buf->cpu, ubuf->actual_size); 327 328 if (crc_checking) { 329 /* Throw a new checksum on the read buffer */ 330 ubuf->crc = crc32(0, ubuf->data, ubuf->actual_size); 331 } 332 333 /* Requeue the buffer on the free list */ 334 ubuf->pos = 0; 335 336 list_move_tail(&ubuf->list, 337 &port->list_buf_used.list); 338 339 /* Flag any userland waiters */ 340 wake_up_interruptible(&port->wait_read); 341 342 } else { 343 printk(KERN_ERR "buf %p bufsize fails match\n", buf); 344 } 345 346 } else 347 printk(KERN_ERR "encirq no free buffers, increase param encoder_buffers\n"); 348 349 /* Ensure offset into buffer remains 0, fill buffer 350 * with known bad data. We check for this data at a later point 351 * in time. */ 352 saa7164_buffer_zero_offsets(port, bufnr); 353 memset(buf->cpu, 0xff, buf->pci_size); 354 if (crc_checking) { 355 /* Throw yet aanother new checksum on the dma buffer */ 356 buf->crc = crc32(0, buf->cpu, buf->actual_size); 357 } 358 359 break; 360 } 361 } 362 mutex_unlock(&port->dmaqueue_lock); 363 } 364 365 static void saa7164_work_enchandler(struct work_struct *w) 366 { 367 struct saa7164_port *port = 368 container_of(w, struct saa7164_port, workenc); 369 struct saa7164_dev *dev = port->dev; 370 371 u32 wp, mcb, rp, cnt = 0; 372 373 port->last_svc_msecs_diff = port->last_svc_msecs; 374 port->last_svc_msecs = jiffies_to_msecs(jiffies); 375 376 port->last_svc_msecs_diff = port->last_svc_msecs - 377 port->last_svc_msecs_diff; 378 379 saa7164_histogram_update(&port->svc_interval, 380 port->last_svc_msecs_diff); 381 382 port->last_irq_svc_msecs_diff = port->last_svc_msecs - 383 port->last_irq_msecs; 384 385 saa7164_histogram_update(&port->irq_svc_interval, 386 port->last_irq_svc_msecs_diff); 387 388 dprintk(DBGLVL_IRQ, 389 "%s() %Ldms elapsed irq->deferred %Ldms wp: %d rp: %d\n", 390 __func__, 391 port->last_svc_msecs_diff, 392 port->last_irq_svc_msecs_diff, 393 port->last_svc_wp, 394 port->last_svc_rp 395 ); 396 397 /* Current write position */ 398 wp = saa7164_readl(port->bufcounter); 399 if (wp > (port->hwcfg.buffercount - 1)) { 400 printk(KERN_ERR "%s() illegal buf count %d\n", __func__, wp); 401 return; 402 } 403 404 /* Most current complete buffer */ 405 if (wp == 0) 406 mcb = (port->hwcfg.buffercount - 1); 407 else 408 mcb = wp - 1; 409 410 while (1) { 411 if (port->done_first_interrupt == 0) { 412 port->done_first_interrupt++; 413 rp = mcb; 414 } else 415 rp = (port->last_svc_rp + 1) % 8; 416 417 if (rp > (port->hwcfg.buffercount - 1)) { 418 printk(KERN_ERR "%s() illegal rp count %d\n", __func__, rp); 419 break; 420 } 421 422 saa7164_work_enchandler_helper(port, rp); 423 port->last_svc_rp = rp; 424 cnt++; 425 426 if (rp == mcb) 427 break; 428 } 429 430 /* TODO: Convert this into a /proc/saa7164 style readable file */ 431 if (print_histogram == port->nr) { 432 saa7164_histogram_print(port, &port->irq_interval); 433 saa7164_histogram_print(port, &port->svc_interval); 434 saa7164_histogram_print(port, &port->irq_svc_interval); 435 saa7164_histogram_print(port, &port->read_interval); 436 saa7164_histogram_print(port, &port->poll_interval); 437 /* TODO: fix this to preserve any previous state */ 438 print_histogram = 64 + port->nr; 439 } 440 } 441 442 static void saa7164_work_vbihandler(struct work_struct *w) 443 { 444 struct saa7164_port *port = 445 container_of(w, struct saa7164_port, workenc); 446 struct saa7164_dev *dev = port->dev; 447 448 u32 wp, mcb, rp, cnt = 0; 449 450 port->last_svc_msecs_diff = port->last_svc_msecs; 451 port->last_svc_msecs = jiffies_to_msecs(jiffies); 452 port->last_svc_msecs_diff = port->last_svc_msecs - 453 port->last_svc_msecs_diff; 454 455 saa7164_histogram_update(&port->svc_interval, 456 port->last_svc_msecs_diff); 457 458 port->last_irq_svc_msecs_diff = port->last_svc_msecs - 459 port->last_irq_msecs; 460 461 saa7164_histogram_update(&port->irq_svc_interval, 462 port->last_irq_svc_msecs_diff); 463 464 dprintk(DBGLVL_IRQ, 465 "%s() %Ldms elapsed irq->deferred %Ldms wp: %d rp: %d\n", 466 __func__, 467 port->last_svc_msecs_diff, 468 port->last_irq_svc_msecs_diff, 469 port->last_svc_wp, 470 port->last_svc_rp 471 ); 472 473 /* Current write position */ 474 wp = saa7164_readl(port->bufcounter); 475 if (wp > (port->hwcfg.buffercount - 1)) { 476 printk(KERN_ERR "%s() illegal buf count %d\n", __func__, wp); 477 return; 478 } 479 480 /* Most current complete buffer */ 481 if (wp == 0) 482 mcb = (port->hwcfg.buffercount - 1); 483 else 484 mcb = wp - 1; 485 486 while (1) { 487 if (port->done_first_interrupt == 0) { 488 port->done_first_interrupt++; 489 rp = mcb; 490 } else 491 rp = (port->last_svc_rp + 1) % 8; 492 493 if (rp > (port->hwcfg.buffercount - 1)) { 494 printk(KERN_ERR "%s() illegal rp count %d\n", __func__, rp); 495 break; 496 } 497 498 saa7164_work_enchandler_helper(port, rp); 499 port->last_svc_rp = rp; 500 cnt++; 501 502 if (rp == mcb) 503 break; 504 } 505 506 /* TODO: Convert this into a /proc/saa7164 style readable file */ 507 if (print_histogram == port->nr) { 508 saa7164_histogram_print(port, &port->irq_interval); 509 saa7164_histogram_print(port, &port->svc_interval); 510 saa7164_histogram_print(port, &port->irq_svc_interval); 511 saa7164_histogram_print(port, &port->read_interval); 512 saa7164_histogram_print(port, &port->poll_interval); 513 /* TODO: fix this to preserve any previous state */ 514 print_histogram = 64 + port->nr; 515 } 516 } 517 518 static void saa7164_work_cmdhandler(struct work_struct *w) 519 { 520 struct saa7164_dev *dev = container_of(w, struct saa7164_dev, workcmd); 521 522 /* Wake up any complete commands */ 523 saa7164_irq_dequeue(dev); 524 } 525 526 static void saa7164_buffer_deliver(struct saa7164_buffer *buf) 527 { 528 struct saa7164_port *port = buf->port; 529 530 /* Feed the transport payload into the kernel demux */ 531 dvb_dmx_swfilter_packets(&port->dvb.demux, (u8 *)buf->cpu, 532 SAA7164_TS_NUMBER_OF_LINES); 533 534 } 535 536 static irqreturn_t saa7164_irq_vbi(struct saa7164_port *port) 537 { 538 struct saa7164_dev *dev = port->dev; 539 540 /* Store old time */ 541 port->last_irq_msecs_diff = port->last_irq_msecs; 542 543 /* Collect new stats */ 544 port->last_irq_msecs = jiffies_to_msecs(jiffies); 545 546 /* Calculate stats */ 547 port->last_irq_msecs_diff = port->last_irq_msecs - 548 port->last_irq_msecs_diff; 549 550 saa7164_histogram_update(&port->irq_interval, 551 port->last_irq_msecs_diff); 552 553 dprintk(DBGLVL_IRQ, "%s() %Ldms elapsed\n", __func__, 554 port->last_irq_msecs_diff); 555 556 /* Tis calls the vbi irq handler */ 557 schedule_work(&port->workenc); 558 return 0; 559 } 560 561 static irqreturn_t saa7164_irq_encoder(struct saa7164_port *port) 562 { 563 struct saa7164_dev *dev = port->dev; 564 565 /* Store old time */ 566 port->last_irq_msecs_diff = port->last_irq_msecs; 567 568 /* Collect new stats */ 569 port->last_irq_msecs = jiffies_to_msecs(jiffies); 570 571 /* Calculate stats */ 572 port->last_irq_msecs_diff = port->last_irq_msecs - 573 port->last_irq_msecs_diff; 574 575 saa7164_histogram_update(&port->irq_interval, 576 port->last_irq_msecs_diff); 577 578 dprintk(DBGLVL_IRQ, "%s() %Ldms elapsed\n", __func__, 579 port->last_irq_msecs_diff); 580 581 schedule_work(&port->workenc); 582 return 0; 583 } 584 585 static irqreturn_t saa7164_irq_ts(struct saa7164_port *port) 586 { 587 struct saa7164_dev *dev = port->dev; 588 struct saa7164_buffer *buf; 589 struct list_head *c, *n; 590 int wp, i = 0, rp; 591 592 /* Find the current write point from the hardware */ 593 wp = saa7164_readl(port->bufcounter); 594 if (wp > (port->hwcfg.buffercount - 1)) 595 BUG(); 596 597 /* Find the previous buffer to the current write point */ 598 if (wp == 0) 599 rp = (port->hwcfg.buffercount - 1); 600 else 601 rp = wp - 1; 602 603 /* Lookup the WP in the buffer list */ 604 /* TODO: turn this into a worker thread */ 605 list_for_each_safe(c, n, &port->dmaqueue.list) { 606 buf = list_entry(c, struct saa7164_buffer, list); 607 if (i++ > port->hwcfg.buffercount) 608 BUG(); 609 610 if (buf->idx == rp) { 611 /* Found the buffer, deal with it */ 612 dprintk(DBGLVL_IRQ, "%s() wp: %d processing: %d\n", 613 __func__, wp, rp); 614 saa7164_buffer_deliver(buf); 615 break; 616 } 617 618 } 619 return 0; 620 } 621 622 /* Primary IRQ handler and dispatch mechanism */ 623 static irqreturn_t saa7164_irq(int irq, void *dev_id) 624 { 625 struct saa7164_dev *dev = dev_id; 626 struct saa7164_port *porta, *portb, *portc, *portd, *porte, *portf; 627 628 u32 intid, intstat[INT_SIZE/4]; 629 int i, handled = 0, bit; 630 631 if (dev == NULL) { 632 printk(KERN_ERR "%s() No device specified\n", __func__); 633 handled = 0; 634 goto out; 635 } 636 637 porta = &dev->ports[SAA7164_PORT_TS1]; 638 portb = &dev->ports[SAA7164_PORT_TS2]; 639 portc = &dev->ports[SAA7164_PORT_ENC1]; 640 portd = &dev->ports[SAA7164_PORT_ENC2]; 641 porte = &dev->ports[SAA7164_PORT_VBI1]; 642 portf = &dev->ports[SAA7164_PORT_VBI2]; 643 644 /* Check that the hardware is accessible. If the status bytes are 645 * 0xFF then the device is not accessible, the the IRQ belongs 646 * to another driver. 647 * 4 x u32 interrupt registers. 648 */ 649 for (i = 0; i < INT_SIZE/4; i++) { 650 651 /* TODO: Convert into saa7164_readl() */ 652 /* Read the 4 hardware interrupt registers */ 653 intstat[i] = saa7164_readl(dev->int_status + (i * 4)); 654 655 if (intstat[i]) 656 handled = 1; 657 } 658 if (handled == 0) 659 goto out; 660 661 /* For each of the HW interrupt registers */ 662 for (i = 0; i < INT_SIZE/4; i++) { 663 664 if (intstat[i]) { 665 /* Each function of the board has it's own interruptid. 666 * Find the function that triggered then call 667 * it's handler. 668 */ 669 for (bit = 0; bit < 32; bit++) { 670 671 if (((intstat[i] >> bit) & 0x00000001) == 0) 672 continue; 673 674 /* Calculate the interrupt id (0x00 to 0x7f) */ 675 676 intid = (i * 32) + bit; 677 if (intid == dev->intfdesc.bInterruptId) { 678 /* A response to an cmd/api call */ 679 schedule_work(&dev->workcmd); 680 } else if (intid == porta->hwcfg.interruptid) { 681 682 /* Transport path 1 */ 683 saa7164_irq_ts(porta); 684 685 } else if (intid == portb->hwcfg.interruptid) { 686 687 /* Transport path 2 */ 688 saa7164_irq_ts(portb); 689 690 } else if (intid == portc->hwcfg.interruptid) { 691 692 /* Encoder path 1 */ 693 saa7164_irq_encoder(portc); 694 695 } else if (intid == portd->hwcfg.interruptid) { 696 697 /* Encoder path 2 */ 698 saa7164_irq_encoder(portd); 699 700 } else if (intid == porte->hwcfg.interruptid) { 701 702 /* VBI path 1 */ 703 saa7164_irq_vbi(porte); 704 705 } else if (intid == portf->hwcfg.interruptid) { 706 707 /* VBI path 2 */ 708 saa7164_irq_vbi(portf); 709 710 } else { 711 /* Find the function */ 712 dprintk(DBGLVL_IRQ, 713 "%s() unhandled interrupt " 714 "reg 0x%x bit 0x%x " 715 "intid = 0x%x\n", 716 __func__, i, bit, intid); 717 } 718 } 719 720 /* Ack it */ 721 saa7164_writel(dev->int_ack + (i * 4), intstat[i]); 722 723 } 724 } 725 out: 726 return IRQ_RETVAL(handled); 727 } 728 729 void saa7164_getfirmwarestatus(struct saa7164_dev *dev) 730 { 731 struct saa7164_fw_status *s = &dev->fw_status; 732 733 dev->fw_status.status = saa7164_readl(SAA_DEVICE_SYSINIT_STATUS); 734 dev->fw_status.mode = saa7164_readl(SAA_DEVICE_SYSINIT_MODE); 735 dev->fw_status.spec = saa7164_readl(SAA_DEVICE_SYSINIT_SPEC); 736 dev->fw_status.inst = saa7164_readl(SAA_DEVICE_SYSINIT_INST); 737 dev->fw_status.cpuload = saa7164_readl(SAA_DEVICE_SYSINIT_CPULOAD); 738 dev->fw_status.remainheap = 739 saa7164_readl(SAA_DEVICE_SYSINIT_REMAINHEAP); 740 741 dprintk(1, "Firmware status:\n"); 742 dprintk(1, " .status = 0x%08x\n", s->status); 743 dprintk(1, " .mode = 0x%08x\n", s->mode); 744 dprintk(1, " .spec = 0x%08x\n", s->spec); 745 dprintk(1, " .inst = 0x%08x\n", s->inst); 746 dprintk(1, " .cpuload = 0x%08x\n", s->cpuload); 747 dprintk(1, " .remainheap = 0x%08x\n", s->remainheap); 748 } 749 750 u32 saa7164_getcurrentfirmwareversion(struct saa7164_dev *dev) 751 { 752 u32 reg; 753 754 reg = saa7164_readl(SAA_DEVICE_VERSION); 755 dprintk(1, "Device running firmware version %d.%d.%d.%d (0x%x)\n", 756 (reg & 0x0000fc00) >> 10, 757 (reg & 0x000003e0) >> 5, 758 (reg & 0x0000001f), 759 (reg & 0xffff0000) >> 16, 760 reg); 761 762 return reg; 763 } 764 765 /* TODO: Debugging func, remove */ 766 void saa7164_dumpregs(struct saa7164_dev *dev, u32 addr) 767 { 768 int i; 769 770 dprintk(1, "--------------------> " 771 "00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n"); 772 773 for (i = 0; i < 0x100; i += 16) 774 dprintk(1, "region0[0x%08x] = " 775 "%02x %02x %02x %02x %02x %02x %02x %02x" 776 " %02x %02x %02x %02x %02x %02x %02x %02x\n", i, 777 (u8)saa7164_readb(addr + i + 0), 778 (u8)saa7164_readb(addr + i + 1), 779 (u8)saa7164_readb(addr + i + 2), 780 (u8)saa7164_readb(addr + i + 3), 781 (u8)saa7164_readb(addr + i + 4), 782 (u8)saa7164_readb(addr + i + 5), 783 (u8)saa7164_readb(addr + i + 6), 784 (u8)saa7164_readb(addr + i + 7), 785 (u8)saa7164_readb(addr + i + 8), 786 (u8)saa7164_readb(addr + i + 9), 787 (u8)saa7164_readb(addr + i + 10), 788 (u8)saa7164_readb(addr + i + 11), 789 (u8)saa7164_readb(addr + i + 12), 790 (u8)saa7164_readb(addr + i + 13), 791 (u8)saa7164_readb(addr + i + 14), 792 (u8)saa7164_readb(addr + i + 15) 793 ); 794 } 795 796 static void saa7164_dump_hwdesc(struct saa7164_dev *dev) 797 { 798 dprintk(1, "@0x%p hwdesc sizeof(struct tmComResHWDescr) = %d bytes\n", 799 &dev->hwdesc, (u32)sizeof(struct tmComResHWDescr)); 800 801 dprintk(1, " .bLength = 0x%x\n", dev->hwdesc.bLength); 802 dprintk(1, " .bDescriptorType = 0x%x\n", dev->hwdesc.bDescriptorType); 803 dprintk(1, " .bDescriptorSubtype = 0x%x\n", 804 dev->hwdesc.bDescriptorSubtype); 805 806 dprintk(1, " .bcdSpecVersion = 0x%x\n", dev->hwdesc.bcdSpecVersion); 807 dprintk(1, " .dwClockFrequency = 0x%x\n", dev->hwdesc.dwClockFrequency); 808 dprintk(1, " .dwClockUpdateRes = 0x%x\n", dev->hwdesc.dwClockUpdateRes); 809 dprintk(1, " .bCapabilities = 0x%x\n", dev->hwdesc.bCapabilities); 810 dprintk(1, " .dwDeviceRegistersLocation = 0x%x\n", 811 dev->hwdesc.dwDeviceRegistersLocation); 812 813 dprintk(1, " .dwHostMemoryRegion = 0x%x\n", 814 dev->hwdesc.dwHostMemoryRegion); 815 816 dprintk(1, " .dwHostMemoryRegionSize = 0x%x\n", 817 dev->hwdesc.dwHostMemoryRegionSize); 818 819 dprintk(1, " .dwHostHibernatMemRegion = 0x%x\n", 820 dev->hwdesc.dwHostHibernatMemRegion); 821 822 dprintk(1, " .dwHostHibernatMemRegionSize = 0x%x\n", 823 dev->hwdesc.dwHostHibernatMemRegionSize); 824 } 825 826 static void saa7164_dump_intfdesc(struct saa7164_dev *dev) 827 { 828 dprintk(1, "@0x%p intfdesc " 829 "sizeof(struct tmComResInterfaceDescr) = %d bytes\n", 830 &dev->intfdesc, (u32)sizeof(struct tmComResInterfaceDescr)); 831 832 dprintk(1, " .bLength = 0x%x\n", dev->intfdesc.bLength); 833 dprintk(1, " .bDescriptorType = 0x%x\n", dev->intfdesc.bDescriptorType); 834 dprintk(1, " .bDescriptorSubtype = 0x%x\n", 835 dev->intfdesc.bDescriptorSubtype); 836 837 dprintk(1, " .bFlags = 0x%x\n", dev->intfdesc.bFlags); 838 dprintk(1, " .bInterfaceType = 0x%x\n", dev->intfdesc.bInterfaceType); 839 dprintk(1, " .bInterfaceId = 0x%x\n", dev->intfdesc.bInterfaceId); 840 dprintk(1, " .bBaseInterface = 0x%x\n", dev->intfdesc.bBaseInterface); 841 dprintk(1, " .bInterruptId = 0x%x\n", dev->intfdesc.bInterruptId); 842 dprintk(1, " .bDebugInterruptId = 0x%x\n", 843 dev->intfdesc.bDebugInterruptId); 844 845 dprintk(1, " .BARLocation = 0x%x\n", dev->intfdesc.BARLocation); 846 } 847 848 static void saa7164_dump_busdesc(struct saa7164_dev *dev) 849 { 850 dprintk(1, "@0x%p busdesc sizeof(struct tmComResBusDescr) = %d bytes\n", 851 &dev->busdesc, (u32)sizeof(struct tmComResBusDescr)); 852 853 dprintk(1, " .CommandRing = 0x%016Lx\n", dev->busdesc.CommandRing); 854 dprintk(1, " .ResponseRing = 0x%016Lx\n", dev->busdesc.ResponseRing); 855 dprintk(1, " .CommandWrite = 0x%x\n", dev->busdesc.CommandWrite); 856 dprintk(1, " .CommandRead = 0x%x\n", dev->busdesc.CommandRead); 857 dprintk(1, " .ResponseWrite = 0x%x\n", dev->busdesc.ResponseWrite); 858 dprintk(1, " .ResponseRead = 0x%x\n", dev->busdesc.ResponseRead); 859 } 860 861 /* Much of the hardware configuration and PCI registers are configured 862 * dynamically depending on firmware. We have to cache some initial 863 * structures then use these to locate other important structures 864 * from PCI space. 865 */ 866 static void saa7164_get_descriptors(struct saa7164_dev *dev) 867 { 868 memcpy_fromio(&dev->hwdesc, dev->bmmio, sizeof(struct tmComResHWDescr)); 869 memcpy_fromio(&dev->intfdesc, dev->bmmio + sizeof(struct tmComResHWDescr), 870 sizeof(struct tmComResInterfaceDescr)); 871 memcpy_fromio(&dev->busdesc, dev->bmmio + dev->intfdesc.BARLocation, 872 sizeof(struct tmComResBusDescr)); 873 874 if (dev->hwdesc.bLength != sizeof(struct tmComResHWDescr)) { 875 printk(KERN_ERR "Structure struct tmComResHWDescr is mangled\n"); 876 printk(KERN_ERR "Need %x got %d\n", dev->hwdesc.bLength, 877 (u32)sizeof(struct tmComResHWDescr)); 878 } else 879 saa7164_dump_hwdesc(dev); 880 881 if (dev->intfdesc.bLength != sizeof(struct tmComResInterfaceDescr)) { 882 printk(KERN_ERR "struct struct tmComResInterfaceDescr is mangled\n"); 883 printk(KERN_ERR "Need %x got %d\n", dev->intfdesc.bLength, 884 (u32)sizeof(struct tmComResInterfaceDescr)); 885 } else 886 saa7164_dump_intfdesc(dev); 887 888 saa7164_dump_busdesc(dev); 889 } 890 891 static int saa7164_pci_quirks(struct saa7164_dev *dev) 892 { 893 return 0; 894 } 895 896 static int get_resources(struct saa7164_dev *dev) 897 { 898 if (request_mem_region(pci_resource_start(dev->pci, 0), 899 pci_resource_len(dev->pci, 0), dev->name)) { 900 901 if (request_mem_region(pci_resource_start(dev->pci, 2), 902 pci_resource_len(dev->pci, 2), dev->name)) 903 return 0; 904 } 905 906 printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx or 0x%llx\n", 907 dev->name, 908 (u64)pci_resource_start(dev->pci, 0), 909 (u64)pci_resource_start(dev->pci, 2)); 910 911 return -EBUSY; 912 } 913 914 static int saa7164_port_init(struct saa7164_dev *dev, int portnr) 915 { 916 struct saa7164_port *port = NULL; 917 918 if ((portnr < 0) || (portnr >= SAA7164_MAX_PORTS)) 919 BUG(); 920 921 port = &dev->ports[portnr]; 922 923 port->dev = dev; 924 port->nr = portnr; 925 926 if ((portnr == SAA7164_PORT_TS1) || (portnr == SAA7164_PORT_TS2)) 927 port->type = SAA7164_MPEG_DVB; 928 else 929 if ((portnr == SAA7164_PORT_ENC1) || (portnr == SAA7164_PORT_ENC2)) { 930 port->type = SAA7164_MPEG_ENCODER; 931 932 /* We need a deferred interrupt handler for cmd handling */ 933 INIT_WORK(&port->workenc, saa7164_work_enchandler); 934 } else if ((portnr == SAA7164_PORT_VBI1) || (portnr == SAA7164_PORT_VBI2)) { 935 port->type = SAA7164_MPEG_VBI; 936 937 /* We need a deferred interrupt handler for cmd handling */ 938 INIT_WORK(&port->workenc, saa7164_work_vbihandler); 939 } else 940 BUG(); 941 942 /* Init all the critical resources */ 943 mutex_init(&port->dvb.lock); 944 INIT_LIST_HEAD(&port->dmaqueue.list); 945 mutex_init(&port->dmaqueue_lock); 946 947 INIT_LIST_HEAD(&port->list_buf_used.list); 948 INIT_LIST_HEAD(&port->list_buf_free.list); 949 init_waitqueue_head(&port->wait_read); 950 951 952 saa7164_histogram_reset(&port->irq_interval, "irq intervals"); 953 saa7164_histogram_reset(&port->svc_interval, "deferred intervals"); 954 saa7164_histogram_reset(&port->irq_svc_interval, 955 "irq to deferred intervals"); 956 saa7164_histogram_reset(&port->read_interval, 957 "encoder/vbi read() intervals"); 958 saa7164_histogram_reset(&port->poll_interval, 959 "encoder/vbi poll() intervals"); 960 961 return 0; 962 } 963 964 static int saa7164_dev_setup(struct saa7164_dev *dev) 965 { 966 int i; 967 968 mutex_init(&dev->lock); 969 atomic_inc(&dev->refcount); 970 dev->nr = saa7164_devcount++; 971 972 snprintf(dev->name, sizeof(dev->name), "saa7164[%d]", dev->nr); 973 974 mutex_lock(&devlist); 975 list_add_tail(&dev->devlist, &saa7164_devlist); 976 mutex_unlock(&devlist); 977 978 /* board config */ 979 dev->board = UNSET; 980 if (card[dev->nr] < saa7164_bcount) 981 dev->board = card[dev->nr]; 982 983 for (i = 0; UNSET == dev->board && i < saa7164_idcount; i++) 984 if (dev->pci->subsystem_vendor == saa7164_subids[i].subvendor && 985 dev->pci->subsystem_device == 986 saa7164_subids[i].subdevice) 987 dev->board = saa7164_subids[i].card; 988 989 if (UNSET == dev->board) { 990 dev->board = SAA7164_BOARD_UNKNOWN; 991 saa7164_card_list(dev); 992 } 993 994 dev->pci_bus = dev->pci->bus->number; 995 dev->pci_slot = PCI_SLOT(dev->pci->devfn); 996 997 /* I2C Defaults / setup */ 998 dev->i2c_bus[0].dev = dev; 999 dev->i2c_bus[0].nr = 0; 1000 dev->i2c_bus[1].dev = dev; 1001 dev->i2c_bus[1].nr = 1; 1002 dev->i2c_bus[2].dev = dev; 1003 dev->i2c_bus[2].nr = 2; 1004 1005 /* Transport + Encoder ports 1, 2, 3, 4 - Defaults / setup */ 1006 saa7164_port_init(dev, SAA7164_PORT_TS1); 1007 saa7164_port_init(dev, SAA7164_PORT_TS2); 1008 saa7164_port_init(dev, SAA7164_PORT_ENC1); 1009 saa7164_port_init(dev, SAA7164_PORT_ENC2); 1010 saa7164_port_init(dev, SAA7164_PORT_VBI1); 1011 saa7164_port_init(dev, SAA7164_PORT_VBI2); 1012 1013 if (get_resources(dev) < 0) { 1014 printk(KERN_ERR "CORE %s No more PCIe resources for " 1015 "subsystem: %04x:%04x\n", 1016 dev->name, dev->pci->subsystem_vendor, 1017 dev->pci->subsystem_device); 1018 1019 saa7164_devcount--; 1020 return -ENODEV; 1021 } 1022 1023 /* PCI/e allocations */ 1024 dev->lmmio = ioremap(pci_resource_start(dev->pci, 0), 1025 pci_resource_len(dev->pci, 0)); 1026 1027 dev->lmmio2 = ioremap(pci_resource_start(dev->pci, 2), 1028 pci_resource_len(dev->pci, 2)); 1029 1030 dev->bmmio = (u8 __iomem *)dev->lmmio; 1031 dev->bmmio2 = (u8 __iomem *)dev->lmmio2; 1032 1033 /* Inerrupt and ack register locations offset of bmmio */ 1034 dev->int_status = 0x183000 + 0xf80; 1035 dev->int_ack = 0x183000 + 0xf90; 1036 1037 printk(KERN_INFO 1038 "CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n", 1039 dev->name, dev->pci->subsystem_vendor, 1040 dev->pci->subsystem_device, saa7164_boards[dev->board].name, 1041 dev->board, card[dev->nr] == dev->board ? 1042 "insmod option" : "autodetected"); 1043 1044 saa7164_pci_quirks(dev); 1045 1046 return 0; 1047 } 1048 1049 static void saa7164_dev_unregister(struct saa7164_dev *dev) 1050 { 1051 dprintk(1, "%s()\n", __func__); 1052 1053 release_mem_region(pci_resource_start(dev->pci, 0), 1054 pci_resource_len(dev->pci, 0)); 1055 1056 release_mem_region(pci_resource_start(dev->pci, 2), 1057 pci_resource_len(dev->pci, 2)); 1058 1059 if (!atomic_dec_and_test(&dev->refcount)) 1060 return; 1061 1062 iounmap(dev->lmmio); 1063 iounmap(dev->lmmio2); 1064 1065 return; 1066 } 1067 1068 #ifdef CONFIG_PROC_FS 1069 static int saa7164_proc_show(struct seq_file *m, void *v) 1070 { 1071 struct saa7164_dev *dev; 1072 struct tmComResBusInfo *b; 1073 struct list_head *list; 1074 int i, c; 1075 1076 if (saa7164_devcount == 0) 1077 return 0; 1078 1079 list_for_each(list, &saa7164_devlist) { 1080 dev = list_entry(list, struct saa7164_dev, devlist); 1081 seq_printf(m, "%s = %p\n", dev->name, dev); 1082 1083 /* Lock the bus from any other access */ 1084 b = &dev->bus; 1085 mutex_lock(&b->lock); 1086 1087 seq_printf(m, " .m_pdwSetWritePos = 0x%x (0x%08x)\n", 1088 b->m_dwSetReadPos, saa7164_readl(b->m_dwSetReadPos)); 1089 1090 seq_printf(m, " .m_pdwSetReadPos = 0x%x (0x%08x)\n", 1091 b->m_dwSetWritePos, saa7164_readl(b->m_dwSetWritePos)); 1092 1093 seq_printf(m, " .m_pdwGetWritePos = 0x%x (0x%08x)\n", 1094 b->m_dwGetReadPos, saa7164_readl(b->m_dwGetReadPos)); 1095 1096 seq_printf(m, " .m_pdwGetReadPos = 0x%x (0x%08x)\n", 1097 b->m_dwGetWritePos, saa7164_readl(b->m_dwGetWritePos)); 1098 c = 0; 1099 seq_printf(m, "\n Set Ring:\n"); 1100 seq_printf(m, "\n addr 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n"); 1101 for (i = 0; i < b->m_dwSizeSetRing; i++) { 1102 if (c == 0) 1103 seq_printf(m, " %04x:", i); 1104 1105 seq_printf(m, " %02x", readb(b->m_pdwSetRing + i)); 1106 1107 if (++c == 16) { 1108 seq_printf(m, "\n"); 1109 c = 0; 1110 } 1111 } 1112 1113 c = 0; 1114 seq_printf(m, "\n Get Ring:\n"); 1115 seq_printf(m, "\n addr 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n"); 1116 for (i = 0; i < b->m_dwSizeGetRing; i++) { 1117 if (c == 0) 1118 seq_printf(m, " %04x:", i); 1119 1120 seq_printf(m, " %02x", readb(b->m_pdwGetRing + i)); 1121 1122 if (++c == 16) { 1123 seq_printf(m, "\n"); 1124 c = 0; 1125 } 1126 } 1127 1128 mutex_unlock(&b->lock); 1129 1130 } 1131 1132 return 0; 1133 } 1134 1135 static int saa7164_proc_open(struct inode *inode, struct file *filp) 1136 { 1137 return single_open(filp, saa7164_proc_show, NULL); 1138 } 1139 1140 static const struct file_operations saa7164_proc_fops = { 1141 .open = saa7164_proc_open, 1142 .read = seq_read, 1143 .llseek = seq_lseek, 1144 .release = single_release, 1145 }; 1146 1147 static int saa7164_proc_create(void) 1148 { 1149 struct proc_dir_entry *pe; 1150 1151 pe = proc_create("saa7164", S_IRUGO, NULL, &saa7164_proc_fops); 1152 if (!pe) 1153 return -ENOMEM; 1154 1155 return 0; 1156 } 1157 #endif 1158 1159 static int saa7164_thread_function(void *data) 1160 { 1161 struct saa7164_dev *dev = data; 1162 struct tmFwInfoStruct fwinfo; 1163 u64 last_poll_time = 0; 1164 1165 dprintk(DBGLVL_THR, "thread started\n"); 1166 1167 set_freezable(); 1168 1169 while (1) { 1170 msleep_interruptible(100); 1171 if (kthread_should_stop()) 1172 break; 1173 try_to_freeze(); 1174 1175 dprintk(DBGLVL_THR, "thread running\n"); 1176 1177 /* Dump the firmware debug message to console */ 1178 /* Polling this costs us 1-2% of the arm CPU */ 1179 /* convert this into a respnde to interrupt 0x7a */ 1180 saa7164_api_collect_debug(dev); 1181 1182 /* Monitor CPU load every 1 second */ 1183 if ((last_poll_time + 1000 /* ms */) < jiffies_to_msecs(jiffies)) { 1184 saa7164_api_get_load_info(dev, &fwinfo); 1185 last_poll_time = jiffies_to_msecs(jiffies); 1186 } 1187 1188 } 1189 1190 dprintk(DBGLVL_THR, "thread exiting\n"); 1191 return 0; 1192 } 1193 1194 static bool saa7164_enable_msi(struct pci_dev *pci_dev, struct saa7164_dev *dev) 1195 { 1196 int err; 1197 1198 if (!enable_msi) { 1199 printk(KERN_WARNING "%s() MSI disabled by module parameter 'enable_msi'" 1200 , __func__); 1201 return false; 1202 } 1203 1204 err = pci_enable_msi(pci_dev); 1205 1206 if (err) { 1207 printk(KERN_ERR "%s() Failed to enable MSI interrupt." 1208 " Falling back to a shared IRQ\n", __func__); 1209 return false; 1210 } 1211 1212 /* no error - so request an msi interrupt */ 1213 err = request_irq(pci_dev->irq, saa7164_irq, 0, 1214 dev->name, dev); 1215 1216 if (err) { 1217 /* fall back to legacy interrupt */ 1218 printk(KERN_ERR "%s() Failed to get an MSI interrupt." 1219 " Falling back to a shared IRQ\n", __func__); 1220 pci_disable_msi(pci_dev); 1221 return false; 1222 } 1223 1224 return true; 1225 } 1226 1227 static int saa7164_initdev(struct pci_dev *pci_dev, 1228 const struct pci_device_id *pci_id) 1229 { 1230 struct saa7164_dev *dev; 1231 int err, i; 1232 u32 version; 1233 1234 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1235 if (NULL == dev) 1236 return -ENOMEM; 1237 1238 err = v4l2_device_register(&pci_dev->dev, &dev->v4l2_dev); 1239 if (err < 0) { 1240 dev_err(&pci_dev->dev, "v4l2_device_register failed\n"); 1241 goto fail_free; 1242 } 1243 1244 /* pci init */ 1245 dev->pci = pci_dev; 1246 if (pci_enable_device(pci_dev)) { 1247 err = -EIO; 1248 goto fail_free; 1249 } 1250 1251 if (saa7164_dev_setup(dev) < 0) { 1252 err = -EINVAL; 1253 goto fail_free; 1254 } 1255 1256 /* print pci info */ 1257 dev->pci_rev = pci_dev->revision; 1258 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &dev->pci_lat); 1259 printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, " 1260 "latency: %d, mmio: 0x%llx\n", dev->name, 1261 pci_name(pci_dev), dev->pci_rev, pci_dev->irq, 1262 dev->pci_lat, 1263 (unsigned long long)pci_resource_start(pci_dev, 0)); 1264 1265 pci_set_master(pci_dev); 1266 /* TODO */ 1267 err = pci_set_dma_mask(pci_dev, 0xffffffff); 1268 if (err) { 1269 printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name); 1270 goto fail_irq; 1271 } 1272 1273 /* irq bit */ 1274 if (saa7164_enable_msi(pci_dev, dev)) { 1275 dev->msi = true; 1276 } else { 1277 /* if we have an error (i.e. we don't have an interrupt) 1278 or msi is not enabled - fallback to shared interrupt */ 1279 1280 err = request_irq(pci_dev->irq, saa7164_irq, 1281 IRQF_SHARED, dev->name, dev); 1282 1283 if (err < 0) { 1284 printk(KERN_ERR "%s: can't get IRQ %d\n", dev->name, 1285 pci_dev->irq); 1286 err = -EIO; 1287 goto fail_irq; 1288 } 1289 } 1290 1291 pci_set_drvdata(pci_dev, dev); 1292 1293 /* Init the internal command list */ 1294 for (i = 0; i < SAA_CMD_MAX_MSG_UNITS; i++) { 1295 dev->cmds[i].seqno = i; 1296 dev->cmds[i].inuse = 0; 1297 mutex_init(&dev->cmds[i].lock); 1298 init_waitqueue_head(&dev->cmds[i].wait); 1299 } 1300 1301 /* We need a deferred interrupt handler for cmd handling */ 1302 INIT_WORK(&dev->workcmd, saa7164_work_cmdhandler); 1303 1304 /* Only load the firmware if we know the board */ 1305 if (dev->board != SAA7164_BOARD_UNKNOWN) { 1306 1307 err = saa7164_downloadfirmware(dev); 1308 if (err < 0) { 1309 printk(KERN_ERR 1310 "Failed to boot firmware, no features " 1311 "registered\n"); 1312 goto fail_fw; 1313 } 1314 1315 saa7164_get_descriptors(dev); 1316 saa7164_dumpregs(dev, 0); 1317 saa7164_getcurrentfirmwareversion(dev); 1318 saa7164_getfirmwarestatus(dev); 1319 err = saa7164_bus_setup(dev); 1320 if (err < 0) 1321 printk(KERN_ERR 1322 "Failed to setup the bus, will continue\n"); 1323 saa7164_bus_dump(dev); 1324 1325 /* Ping the running firmware via the command bus and get the 1326 * firmware version, this checks the bus is running OK. 1327 */ 1328 version = 0; 1329 if (saa7164_api_get_fw_version(dev, &version) == SAA_OK) 1330 dprintk(1, "Bus is operating correctly using " 1331 "version %d.%d.%d.%d (0x%x)\n", 1332 (version & 0x0000fc00) >> 10, 1333 (version & 0x000003e0) >> 5, 1334 (version & 0x0000001f), 1335 (version & 0xffff0000) >> 16, 1336 version); 1337 else 1338 printk(KERN_ERR 1339 "Failed to communicate with the firmware\n"); 1340 1341 /* Bring up the I2C buses */ 1342 saa7164_i2c_register(&dev->i2c_bus[0]); 1343 saa7164_i2c_register(&dev->i2c_bus[1]); 1344 saa7164_i2c_register(&dev->i2c_bus[2]); 1345 saa7164_gpio_setup(dev); 1346 saa7164_card_setup(dev); 1347 1348 /* Parse the dynamic device configuration, find various 1349 * media endpoints (MPEG, WMV, PS, TS) and cache their 1350 * configuration details into the driver, so we can 1351 * reference them later during simething_register() func, 1352 * interrupt handlers, deferred work handlers etc. 1353 */ 1354 saa7164_api_enum_subdevs(dev); 1355 1356 /* Begin to create the video sub-systems and register funcs */ 1357 if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB) { 1358 if (saa7164_dvb_register(&dev->ports[SAA7164_PORT_TS1]) < 0) { 1359 printk(KERN_ERR "%s() Failed to register " 1360 "dvb adapters on porta\n", 1361 __func__); 1362 } 1363 } 1364 1365 if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB) { 1366 if (saa7164_dvb_register(&dev->ports[SAA7164_PORT_TS2]) < 0) { 1367 printk(KERN_ERR"%s() Failed to register " 1368 "dvb adapters on portb\n", 1369 __func__); 1370 } 1371 } 1372 1373 if (saa7164_boards[dev->board].portc == SAA7164_MPEG_ENCODER) { 1374 if (saa7164_encoder_register(&dev->ports[SAA7164_PORT_ENC1]) < 0) { 1375 printk(KERN_ERR"%s() Failed to register " 1376 "mpeg encoder\n", __func__); 1377 } 1378 } 1379 1380 if (saa7164_boards[dev->board].portd == SAA7164_MPEG_ENCODER) { 1381 if (saa7164_encoder_register(&dev->ports[SAA7164_PORT_ENC2]) < 0) { 1382 printk(KERN_ERR"%s() Failed to register " 1383 "mpeg encoder\n", __func__); 1384 } 1385 } 1386 1387 if (saa7164_boards[dev->board].porte == SAA7164_MPEG_VBI) { 1388 if (saa7164_vbi_register(&dev->ports[SAA7164_PORT_VBI1]) < 0) { 1389 printk(KERN_ERR"%s() Failed to register " 1390 "vbi device\n", __func__); 1391 } 1392 } 1393 1394 if (saa7164_boards[dev->board].portf == SAA7164_MPEG_VBI) { 1395 if (saa7164_vbi_register(&dev->ports[SAA7164_PORT_VBI2]) < 0) { 1396 printk(KERN_ERR"%s() Failed to register " 1397 "vbi device\n", __func__); 1398 } 1399 } 1400 saa7164_api_set_debug(dev, fw_debug); 1401 1402 if (fw_debug) { 1403 dev->kthread = kthread_run(saa7164_thread_function, dev, 1404 "saa7164 debug"); 1405 if (IS_ERR(dev->kthread)) { 1406 dev->kthread = NULL; 1407 printk(KERN_ERR "%s() Failed to create " 1408 "debug kernel thread\n", __func__); 1409 } 1410 } 1411 1412 } /* != BOARD_UNKNOWN */ 1413 else 1414 printk(KERN_ERR "%s() Unsupported board detected, " 1415 "registering without firmware\n", __func__); 1416 1417 dprintk(1, "%s() parameter debug = %d\n", __func__, saa_debug); 1418 dprintk(1, "%s() parameter waitsecs = %d\n", __func__, waitsecs); 1419 1420 fail_fw: 1421 return 0; 1422 1423 fail_irq: 1424 saa7164_dev_unregister(dev); 1425 fail_free: 1426 v4l2_device_unregister(&dev->v4l2_dev); 1427 kfree(dev); 1428 return err; 1429 } 1430 1431 static void saa7164_shutdown(struct saa7164_dev *dev) 1432 { 1433 dprintk(1, "%s()\n", __func__); 1434 } 1435 1436 static void saa7164_finidev(struct pci_dev *pci_dev) 1437 { 1438 struct saa7164_dev *dev = pci_get_drvdata(pci_dev); 1439 1440 if (dev->board != SAA7164_BOARD_UNKNOWN) { 1441 if (fw_debug && dev->kthread) { 1442 kthread_stop(dev->kthread); 1443 dev->kthread = NULL; 1444 } 1445 if (dev->firmwareloaded) 1446 saa7164_api_set_debug(dev, 0x00); 1447 } 1448 1449 saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], 1450 &dev->ports[SAA7164_PORT_ENC1].irq_interval); 1451 saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], 1452 &dev->ports[SAA7164_PORT_ENC1].svc_interval); 1453 saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], 1454 &dev->ports[SAA7164_PORT_ENC1].irq_svc_interval); 1455 saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], 1456 &dev->ports[SAA7164_PORT_ENC1].read_interval); 1457 saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1], 1458 &dev->ports[SAA7164_PORT_ENC1].poll_interval); 1459 saa7164_histogram_print(&dev->ports[SAA7164_PORT_VBI1], 1460 &dev->ports[SAA7164_PORT_VBI1].read_interval); 1461 saa7164_histogram_print(&dev->ports[SAA7164_PORT_VBI2], 1462 &dev->ports[SAA7164_PORT_VBI2].poll_interval); 1463 1464 saa7164_shutdown(dev); 1465 1466 if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB) 1467 saa7164_dvb_unregister(&dev->ports[SAA7164_PORT_TS1]); 1468 1469 if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB) 1470 saa7164_dvb_unregister(&dev->ports[SAA7164_PORT_TS2]); 1471 1472 if (saa7164_boards[dev->board].portc == SAA7164_MPEG_ENCODER) 1473 saa7164_encoder_unregister(&dev->ports[SAA7164_PORT_ENC1]); 1474 1475 if (saa7164_boards[dev->board].portd == SAA7164_MPEG_ENCODER) 1476 saa7164_encoder_unregister(&dev->ports[SAA7164_PORT_ENC2]); 1477 1478 if (saa7164_boards[dev->board].porte == SAA7164_MPEG_VBI) 1479 saa7164_vbi_unregister(&dev->ports[SAA7164_PORT_VBI1]); 1480 1481 if (saa7164_boards[dev->board].portf == SAA7164_MPEG_VBI) 1482 saa7164_vbi_unregister(&dev->ports[SAA7164_PORT_VBI2]); 1483 1484 saa7164_i2c_unregister(&dev->i2c_bus[0]); 1485 saa7164_i2c_unregister(&dev->i2c_bus[1]); 1486 saa7164_i2c_unregister(&dev->i2c_bus[2]); 1487 1488 /* unregister stuff */ 1489 free_irq(pci_dev->irq, dev); 1490 1491 if (dev->msi) { 1492 pci_disable_msi(pci_dev); 1493 dev->msi = false; 1494 } 1495 1496 pci_disable_device(pci_dev); 1497 1498 mutex_lock(&devlist); 1499 list_del(&dev->devlist); 1500 mutex_unlock(&devlist); 1501 1502 saa7164_dev_unregister(dev); 1503 v4l2_device_unregister(&dev->v4l2_dev); 1504 kfree(dev); 1505 } 1506 1507 static struct pci_device_id saa7164_pci_tbl[] = { 1508 { 1509 /* SAA7164 */ 1510 .vendor = 0x1131, 1511 .device = 0x7164, 1512 .subvendor = PCI_ANY_ID, 1513 .subdevice = PCI_ANY_ID, 1514 }, { 1515 /* --- end of list --- */ 1516 } 1517 }; 1518 MODULE_DEVICE_TABLE(pci, saa7164_pci_tbl); 1519 1520 static struct pci_driver saa7164_pci_driver = { 1521 .name = "saa7164", 1522 .id_table = saa7164_pci_tbl, 1523 .probe = saa7164_initdev, 1524 .remove = saa7164_finidev, 1525 /* TODO */ 1526 .suspend = NULL, 1527 .resume = NULL, 1528 }; 1529 1530 static int __init saa7164_init(void) 1531 { 1532 printk(KERN_INFO "saa7164 driver loaded\n"); 1533 1534 #ifdef CONFIG_PROC_FS 1535 saa7164_proc_create(); 1536 #endif 1537 return pci_register_driver(&saa7164_pci_driver); 1538 } 1539 1540 static void __exit saa7164_fini(void) 1541 { 1542 #ifdef CONFIG_PROC_FS 1543 remove_proc_entry("saa7164", NULL); 1544 #endif 1545 pci_unregister_driver(&saa7164_pci_driver); 1546 } 1547 1548 module_init(saa7164_init); 1549 module_exit(saa7164_fini); 1550 1551