drivers/media/pci/saa7164/saa7164-core.c

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