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