drivers/media/pci/bt8xx/bt878.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * bt878.c: part of the driver for the Pinnacle PCTV Sat DVB PCI card
   4  *
   5  * Copyright (C) 2002 Peter Hettkamp <peter.hettkamp@htp-tel.de>
   6  *
   7  * large parts based on the bttv driver
   8  * Copyright (C) 1996,97,98 Ralph  Metzler (rjkm@metzlerbros.de)
   9  *                        & Marcus Metzler (mocm@metzlerbros.de)
  10  * (c) 1999,2000 Gerd Knorr <kraxel@goldbach.in-berlin.de>
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/pci.h>
  16 #include <linux/pgtable.h>
  17 #include <asm/io.h>
  18 #include <linux/ioport.h>
  19 #include <asm/page.h>
  20 #include <linux/types.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/kmod.h>
  23 #include <linux/vmalloc.h>
  24 #include <linux/init.h>
  25
  26 #include <media/dmxdev.h>
  27 #include <media/dvbdev.h>
  28 #include "bt878.h"
  29 #include "dst_priv.h"
  30
  31
  32 /**************************************/
  33 /* Miscellaneous utility  definitions */
  34 /**************************************/
  35
  36 static unsigned int bt878_verbose = 1;
  37 static unsigned int bt878_debug;
  38
  39 module_param_named(verbose, bt878_verbose, int, 0444);
  40 MODULE_PARM_DESC(verbose,
  41                  "verbose startup messages, default is 1 (yes)");
  42 module_param_named(debug, bt878_debug, int, 0644);
  43 MODULE_PARM_DESC(debug, "Turn on/off debugging, default is 0 (off).");
  44
  45 int bt878_num;
  46 struct bt878 bt878[BT878_MAX];
  47
  48 EXPORT_SYMBOL(bt878_num);
  49 EXPORT_SYMBOL(bt878);
  50
  51 #define btwrite(dat,adr)    bmtwrite((dat), (bt->bt878_mem+(adr)))
  52 #define btread(adr)         bmtread(bt->bt878_mem+(adr))
  53
  54 #define btand(dat,adr)      btwrite((dat) & btread(adr), adr)
  55 #define btor(dat,adr)       btwrite((dat) | btread(adr), adr)
  56 #define btaor(dat,mask,adr) btwrite((dat) | ((mask) & btread(adr)), adr)
  57
  58 #if defined(dprintk)
  59 #undef dprintk
  60 #endif
  61 #define dprintk(fmt, arg...) \
  62         do { \
  63                 if (bt878_debug) \
  64                         printk(KERN_DEBUG fmt, ##arg); \
  65         } while (0)
  66
  67 static void bt878_mem_free(struct bt878 *bt)
  68 {
  69         if (bt->buf_cpu) {
  70                 dma_free_coherent(&bt->dev->dev, bt->buf_size, bt->buf_cpu,
  71                                   bt->buf_dma);
  72                 bt->buf_cpu = NULL;
  73         }
  74
  75         if (bt->risc_cpu) {
  76                 dma_free_coherent(&bt->dev->dev, bt->risc_size, bt->risc_cpu,
  77                                   bt->risc_dma);
  78                 bt->risc_cpu = NULL;
  79         }
  80 }
  81
  82 static int bt878_mem_alloc(struct bt878 *bt)
  83 {
  84         if (!bt->buf_cpu) {
  85                 bt->buf_size = 128 * 1024;
  86
  87                 bt->buf_cpu = dma_alloc_coherent(&bt->dev->dev, bt->buf_size,
  88                                                  &bt->buf_dma, GFP_KERNEL);
  89                 if (!bt->buf_cpu)
  90                         return -ENOMEM;
  91         }
  92
  93         if (!bt->risc_cpu) {
  94                 bt->risc_size = PAGE_SIZE;
  95                 bt->risc_cpu = dma_alloc_coherent(&bt->dev->dev, bt->risc_size,
  96                                                   &bt->risc_dma, GFP_KERNEL);
  97                 if (!bt->risc_cpu) {
  98                         bt878_mem_free(bt);
  99                         return -ENOMEM;
 100                 }
 101         }
 102
 103         return 0;
 104 }
 105
 106 /* RISC instructions */
 107 #define RISC_WRITE              (0x01 << 28)
 108 #define RISC_JUMP               (0x07 << 28)
 109 #define RISC_SYNC               (0x08 << 28)
 110
 111 /* RISC bits */
 112 #define RISC_WR_SOL             (1 << 27)
 113 #define RISC_WR_EOL             (1 << 26)
 114 #define RISC_IRQ                (1 << 24)
 115 #define RISC_STATUS(status)     ((((~status) & 0x0F) << 20) | ((status & 0x0F) << 16))
 116 #define RISC_SYNC_RESYNC        (1 << 15)
 117 #define RISC_SYNC_FM1           0x06
 118 #define RISC_SYNC_VRO           0x0C
 119
 120 #define RISC_FLUSH()            bt->risc_pos = 0
 121 #define RISC_INSTR(instr)       bt->risc_cpu[bt->risc_pos++] = cpu_to_le32(instr)
 122
 123 static int bt878_make_risc(struct bt878 *bt)
 124 {
 125         bt->block_bytes = bt->buf_size >> 4;
 126         bt->block_count = 1 << 4;
 127         bt->line_bytes = bt->block_bytes;
 128         bt->line_count = bt->block_count;
 129
 130         while (bt->line_bytes > 4095) {
 131                 bt->line_bytes >>= 1;
 132                 bt->line_count <<= 1;
 133         }
 134
 135         if (bt->line_count > 255) {
 136                 printk(KERN_ERR "bt878: buffer size error!\n");
 137                 return -EINVAL;
 138         }
 139         return 0;
 140 }
 141
 142
 143 static void bt878_risc_program(struct bt878 *bt, u32 op_sync_orin)
 144 {
 145         u32 buf_pos = 0;
 146         u32 line;
 147
 148         RISC_FLUSH();
 149         RISC_INSTR(RISC_SYNC | RISC_SYNC_FM1 | op_sync_orin);
 150         RISC_INSTR(0);
 151
 152         dprintk("bt878: risc len lines %u, bytes per line %u\n",
 153                         bt->line_count, bt->line_bytes);
 154         for (line = 0; line < bt->line_count; line++) {
 155                 // At the beginning of every block we issue an IRQ with previous (finished) block number set
 156                 if (!(buf_pos % bt->block_bytes))
 157                         RISC_INSTR(RISC_WRITE | RISC_WR_SOL | RISC_WR_EOL |
 158                                    RISC_IRQ |
 159                                    RISC_STATUS(((buf_pos /
 160                                                  bt->block_bytes) +
 161                                                 (bt->block_count -
 162                                                  1)) %
 163                                                bt->block_count) | bt->
 164                                    line_bytes);
 165                 else
 166                         RISC_INSTR(RISC_WRITE | RISC_WR_SOL | RISC_WR_EOL |
 167                                    bt->line_bytes);
 168                 RISC_INSTR(bt->buf_dma + buf_pos);
 169                 buf_pos += bt->line_bytes;
 170         }
 171
 172         RISC_INSTR(RISC_SYNC | op_sync_orin | RISC_SYNC_VRO);
 173         RISC_INSTR(0);
 174
 175         RISC_INSTR(RISC_JUMP);
 176         RISC_INSTR(bt->risc_dma);
 177
 178         btwrite((bt->line_count << 16) | bt->line_bytes, BT878_APACK_LEN);
 179 }
 180
 181 /*****************************/
 182 /* Start/Stop grabbing funcs */
 183 /*****************************/
 184
 185 void bt878_start(struct bt878 *bt, u32 controlreg, u32 op_sync_orin,
 186                 u32 irq_err_ignore)
 187 {
 188         u32 int_mask;
 189
 190         dprintk("bt878 debug: bt878_start (ctl=%8.8x)\n", controlreg);
 191         /* complete the writing of the risc dma program now we have
 192          * the card specifics
 193          */
 194         bt878_risc_program(bt, op_sync_orin);
 195         controlreg &= ~0x1f;
 196         controlreg |= 0x1b;
 197
 198         btwrite(bt->risc_dma, BT878_ARISC_START);
 199
 200         /* original int mask had :
 201          *    6    2    8    4    0
 202          * 1111 1111 1000 0000 0000
 203          * SCERR|OCERR|PABORT|RIPERR|FDSR|FTRGT|FBUS|RISCI
 204          * Hacked for DST to:
 205          * SCERR | OCERR | FDSR | FTRGT | FBUS | RISCI
 206          */
 207         int_mask = BT878_ASCERR | BT878_AOCERR | BT878_APABORT |
 208                 BT878_ARIPERR | BT878_APPERR | BT878_AFDSR | BT878_AFTRGT |
 209                 BT878_AFBUS | BT878_ARISCI;
 210
 211
 212         /* ignore pesky bits */
 213         int_mask &= ~irq_err_ignore;
 214
 215         btwrite(int_mask, BT878_AINT_MASK);
 216         btwrite(controlreg, BT878_AGPIO_DMA_CTL);
 217 }
 218
 219 void bt878_stop(struct bt878 *bt)
 220 {
 221         u32 stat;
 222         int i = 0;
 223
 224         dprintk("bt878 debug: bt878_stop\n");
 225
 226         btwrite(0, BT878_AINT_MASK);
 227         btand(~0x13, BT878_AGPIO_DMA_CTL);
 228
 229         do {
 230                 stat = btread(BT878_AINT_STAT);
 231                 if (!(stat & BT878_ARISC_EN))
 232                         break;
 233                 i++;
 234         } while (i < 500);
 235
 236         dprintk("bt878(%d) debug: bt878_stop, i=%d, stat=0x%8.8x\n",
 237                 bt->nr, i, stat);
 238 }
 239
 240 EXPORT_SYMBOL(bt878_start);
 241 EXPORT_SYMBOL(bt878_stop);
 242
 243 /*****************************/
 244 /* Interrupt service routine */
 245 /*****************************/
 246
 247 static irqreturn_t bt878_irq(int irq, void *dev_id)
 248 {
 249         u32 stat, astat, mask;
 250         int count;
 251         struct bt878 *bt;
 252
 253         bt = (struct bt878 *) dev_id;
 254
 255         count = 0;
 256         while (1) {
 257                 stat = btread(BT878_AINT_STAT);
 258                 mask = btread(BT878_AINT_MASK);
 259                 if (!(astat = (stat & mask)))
 260                         return IRQ_NONE;        /* this interrupt is not for me */
 261 /*              dprintk("bt878(%d) debug: irq count %d, stat 0x%8.8x, mask 0x%8.8x\n",bt->nr,count,stat,mask); */
 262                 btwrite(astat, BT878_AINT_STAT);        /* try to clear interrupt condition */
 263
 264
 265                 if (astat & (BT878_ASCERR | BT878_AOCERR)) {
 266                         if (bt878_verbose) {
 267                                 printk(KERN_INFO
 268                                        "bt878(%d): irq%s%s risc_pc=%08x\n",
 269                                        bt->nr,
 270                                        (astat & BT878_ASCERR) ? " SCERR" :
 271                                        "",
 272                                        (astat & BT878_AOCERR) ? " OCERR" :
 273                                        "", btread(BT878_ARISC_PC));
 274                         }
 275                 }
 276                 if (astat & (BT878_APABORT | BT878_ARIPERR | BT878_APPERR)) {
 277                         if (bt878_verbose) {
 278                                 printk(KERN_INFO
 279                                      "bt878(%d): irq%s%s%s risc_pc=%08x\n",
 280                                      bt->nr,
 281                                      (astat & BT878_APABORT) ? " PABORT" :
 282                                      "",
 283                                      (astat & BT878_ARIPERR) ? " RIPERR" :
 284                                      "",
 285                                      (astat & BT878_APPERR) ? " PPERR" :
 286                                      "", btread(BT878_ARISC_PC));
 287                         }
 288                 }
 289                 if (astat & (BT878_AFDSR | BT878_AFTRGT | BT878_AFBUS)) {
 290                         if (bt878_verbose) {
 291                                 printk(KERN_INFO
 292                                      "bt878(%d): irq%s%s%s risc_pc=%08x\n",
 293                                      bt->nr,
 294                                      (astat & BT878_AFDSR) ? " FDSR" : "",
 295                                      (astat & BT878_AFTRGT) ? " FTRGT" :
 296                                      "",
 297                                      (astat & BT878_AFBUS) ? " FBUS" : "",
 298                                      btread(BT878_ARISC_PC));
 299                         }
 300                 }
 301                 if (astat & BT878_ARISCI) {
 302                         bt->finished_block = (stat & BT878_ARISCS) >> 28;
 303                         tasklet_schedule(&bt->tasklet);
 304                         break;
 305                 }
 306                 count++;
 307                 if (count > 20) {
 308                         btwrite(0, BT878_AINT_MASK);
 309                         printk(KERN_ERR
 310                                "bt878(%d): IRQ lockup, cleared int mask\n",
 311                                bt->nr);
 312                         break;
 313                 }
 314         }
 315         return IRQ_HANDLED;
 316 }
 317
 318 int
 319 bt878_device_control(struct bt878 *bt, unsigned int cmd, union dst_gpio_packet *mp)
 320 {
 321         int retval;
 322
 323         retval = 0;
 324         if (mutex_lock_interruptible(&bt->gpio_lock))
 325                 return -ERESTARTSYS;
 326         /* special gpio signal */
 327         switch (cmd) {
 328             case DST_IG_ENABLE:
 329                 // dprintk("dvb_bt8xx: dst enable mask 0x%02x enb 0x%02x \n", mp->dstg.enb.mask, mp->dstg.enb.enable);
 330                 retval = bttv_gpio_enable(bt->bttv_nr,
 331                                 mp->enb.mask,
 332                                 mp->enb.enable);
 333                 break;
 334             case DST_IG_WRITE:
 335                 // dprintk("dvb_bt8xx: dst write gpio mask 0x%02x out 0x%02x\n", mp->dstg.outp.mask, mp->dstg.outp.highvals);
 336                 retval = bttv_write_gpio(bt->bttv_nr,
 337                                 mp->outp.mask,
 338                                 mp->outp.highvals);
 339
 340                 break;
 341             case DST_IG_READ:
 342                 /* read */
 343                 retval =  bttv_read_gpio(bt->bttv_nr, &mp->rd.value);
 344                 // dprintk("dvb_bt8xx: dst read gpio 0x%02x\n", (unsigned)mp->dstg.rd.value);
 345                 break;
 346             case DST_IG_TS:
 347                 /* Set packet size */
 348                 bt->TS_Size = mp->psize;
 349                 break;
 350
 351             default:
 352                 retval = -EINVAL;
 353                 break;
 354         }
 355         mutex_unlock(&bt->gpio_lock);
 356         return retval;
 357 }
 358
 359 EXPORT_SYMBOL(bt878_device_control);
 360
 361 #define BROOKTREE_878_DEVICE(vend, dev, name) \
 362         { \
 363                 .vendor = PCI_VENDOR_ID_BROOKTREE, \
 364                 .device = PCI_DEVICE_ID_BROOKTREE_878, \
 365                 .subvendor = (vend), .subdevice = (dev), \
 366                 .driver_data = (unsigned long) name \
 367         }
 368
 369 static const struct pci_device_id bt878_pci_tbl[] = {
 370         BROOKTREE_878_DEVICE(0x0071, 0x0101, "Nebula Electronics DigiTV"),
 371         BROOKTREE_878_DEVICE(0x1461, 0x0761, "AverMedia AverTV DVB-T 761"),
 372         BROOKTREE_878_DEVICE(0x11bd, 0x001c, "Pinnacle PCTV Sat"),
 373         BROOKTREE_878_DEVICE(0x11bd, 0x0026, "Pinnacle PCTV SAT CI"),
 374         BROOKTREE_878_DEVICE(0x1822, 0x0001, "Twinhan VisionPlus DVB"),
 375         BROOKTREE_878_DEVICE(0x270f, 0xfc00,
 376                                 "ChainTech digitop DST-1000 DVB-S"),
 377         BROOKTREE_878_DEVICE(0x1461, 0x0771, "AVermedia AverTV DVB-T 771"),
 378         BROOKTREE_878_DEVICE(0x18ac, 0xdb10, "DViCO FusionHDTV DVB-T Lite"),
 379         BROOKTREE_878_DEVICE(0x18ac, 0xdb11, "Ultraview DVB-T Lite"),
 380         BROOKTREE_878_DEVICE(0x18ac, 0xd500, "DViCO FusionHDTV 5 Lite"),
 381         BROOKTREE_878_DEVICE(0x7063, 0x2000, "pcHDTV HD-2000 TV"),
 382         BROOKTREE_878_DEVICE(0x1822, 0x0026, "DNTV Live! Mini"),
 383         { }
 384 };
 385
 386 MODULE_DEVICE_TABLE(pci, bt878_pci_tbl);
 387
 388 static const char * card_name(const struct pci_device_id *id)
 389 {
 390         return id->driver_data ? (const char *)id->driver_data : "Unknown";
 391 }
 392
 393 /***********************/
 394 /* PCI device handling */
 395 /***********************/
 396
 397 static int bt878_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
 398 {
 399         int result = 0;
 400         unsigned char lat;
 401         struct bt878 *bt;
 402         unsigned int cardid;
 403
 404         printk(KERN_INFO "bt878: Bt878 AUDIO function found (%d).\n",
 405                bt878_num);
 406         if (bt878_num >= BT878_MAX) {
 407                 printk(KERN_ERR "bt878: Too many devices inserted\n");
 408                 return -ENOMEM;
 409         }
 410         if (pci_enable_device(dev))
 411                 return -EIO;
 412
 413         cardid = dev->subsystem_device << 16;
 414         cardid |= dev->subsystem_vendor;
 415
 416         printk(KERN_INFO "%s: card id=[0x%x],[ %s ] has DVB functions.\n",
 417                                 __func__, cardid, card_name(pci_id));
 418
 419         bt = &bt878[bt878_num];
 420         bt->dev = dev;
 421         bt->nr = bt878_num;
 422         bt->shutdown = 0;
 423
 424         bt->id = dev->device;
 425         bt->irq = dev->irq;
 426         bt->bt878_adr = pci_resource_start(dev, 0);
 427         if (!request_mem_region(pci_resource_start(dev, 0),
 428                                 pci_resource_len(dev, 0), "bt878")) {
 429                 result = -EBUSY;
 430                 goto fail0;
 431         }
 432
 433         bt->revision = dev->revision;
 434         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
 435
 436
 437         printk(KERN_INFO "bt878(%d): Bt%x (rev %d) at %02x:%02x.%x, ",
 438                bt878_num, bt->id, bt->revision, dev->bus->number,
 439                PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
 440         printk("irq: %d, latency: %d, memory: 0x%lx\n",
 441                bt->irq, lat, bt->bt878_adr);
 442
 443 #ifdef __sparc__
 444         bt->bt878_mem = (unsigned char *) bt->bt878_adr;
 445 #else
 446         bt->bt878_mem = ioremap(bt->bt878_adr, 0x1000);
 447 #endif
 448
 449         /* clear interrupt mask */
 450         btwrite(0, BT848_INT_MASK);
 451
 452         result = request_irq(bt->irq, bt878_irq,
 453                              IRQF_SHARED, "bt878", (void *) bt);
 454         if (result == -EINVAL) {
 455                 printk(KERN_ERR "bt878(%d): Bad irq number or handler\n",
 456                        bt878_num);
 457                 goto fail1;
 458         }
 459         if (result == -EBUSY) {
 460                 printk(KERN_ERR
 461                        "bt878(%d): IRQ %d busy, change your PnP config in BIOS\n",
 462                        bt878_num, bt->irq);
 463                 goto fail1;
 464         }
 465         if (result < 0)
 466                 goto fail1;
 467
 468         pci_set_master(dev);
 469         pci_set_drvdata(dev, bt);
 470
 471         if ((result = bt878_mem_alloc(bt))) {
 472                 printk(KERN_ERR "bt878: failed to allocate memory!\n");
 473                 goto fail2;
 474         }
 475
 476         bt878_make_risc(bt);
 477         btwrite(0, BT878_AINT_MASK);
 478         bt878_num++;
 479
 480         return 0;
 481
 482       fail2:
 483         free_irq(bt->irq, bt);
 484       fail1:
 485         release_mem_region(pci_resource_start(bt->dev, 0),
 486                            pci_resource_len(bt->dev, 0));
 487       fail0:
 488         pci_disable_device(dev);
 489         return result;
 490 }
 491
 492 static void bt878_remove(struct pci_dev *pci_dev)
 493 {
 494         u8 command;
 495         struct bt878 *bt = pci_get_drvdata(pci_dev);
 496
 497         if (bt878_verbose)
 498                 printk(KERN_INFO "bt878(%d): unloading\n", bt->nr);
 499
 500         /* turn off all capturing, DMA and IRQs */
 501         btand(~0x13, BT878_AGPIO_DMA_CTL);
 502
 503         /* first disable interrupts before unmapping the memory! */
 504         btwrite(0, BT878_AINT_MASK);
 505         btwrite(~0U, BT878_AINT_STAT);
 506
 507         /* disable PCI bus-mastering */
 508         pci_read_config_byte(bt->dev, PCI_COMMAND, &command);
 509         /* Should this be &=~ ?? */
 510         command &= ~PCI_COMMAND_MASTER;
 511         pci_write_config_byte(bt->dev, PCI_COMMAND, command);
 512
 513         free_irq(bt->irq, bt);
 514         printk(KERN_DEBUG "bt878_mem: 0x%p.\n", bt->bt878_mem);
 515         if (bt->bt878_mem)
 516                 iounmap(bt->bt878_mem);
 517
 518         release_mem_region(pci_resource_start(bt->dev, 0),
 519                            pci_resource_len(bt->dev, 0));
 520         /* wake up any waiting processes
 521            because shutdown flag is set, no new processes (in this queue)
 522            are expected
 523          */
 524         bt->shutdown = 1;
 525         bt878_mem_free(bt);
 526
 527         pci_disable_device(pci_dev);
 528         return;
 529 }
 530
 531 static struct pci_driver bt878_pci_driver = {
 532       .name     = "bt878",
 533       .id_table = bt878_pci_tbl,
 534       .probe    = bt878_probe,
 535       .remove   = bt878_remove,
 536 };
 537
 538 /*******************************/
 539 /* Module management functions */
 540 /*******************************/
 541
 542 static int __init bt878_init_module(void)
 543 {
 544         bt878_num = 0;
 545
 546         printk(KERN_INFO "bt878: AUDIO driver version %d.%d.%d loaded\n",
 547                (BT878_VERSION_CODE >> 16) & 0xff,
 548                (BT878_VERSION_CODE >> 8) & 0xff,
 549                BT878_VERSION_CODE & 0xff);
 550
 551         return pci_register_driver(&bt878_pci_driver);
 552 }
 553
 554 static void __exit bt878_cleanup_module(void)
 555 {
 556         pci_unregister_driver(&bt878_pci_driver);
 557 }
 558
 559 module_init(bt878_init_module);
 560 module_exit(bt878_cleanup_module);
 561
 562 MODULE_LICENSE("GPL");