root/drivers/media/pci/tw5864/tw5864-core.c

DEFINITIONS

1. tw5864_irqmask_apply
2. tw5864_interrupts_disable
3. tw5864_isr
4. tw5864_h264_isr
5. tw5864_input_deadline_update
6. tw5864_timer_isr
7. tw5864_initdev
8. tw5864_finidev

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  TW5864 driver - core functions
   4  *
   5  *  Copyright (C) 2016 Bluecherry, LLC <maintainers@bluecherrydvr.com>
   6  */
   7 
   8 #include <linux/init.h>
   9 #include <linux/list.h>
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/slab.h>
  13 #include <linux/kmod.h>
  14 #include <linux/sound.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/delay.h>
  17 #include <linux/dma-mapping.h>
  18 #include <linux/pm.h>
  19 #include <linux/pci_ids.h>
  20 #include <linux/jiffies.h>
  21 #include <asm/dma.h>
  22 #include <media/v4l2-dev.h>
  23 
  24 #include "tw5864.h"
  25 #include "tw5864-reg.h"
  26 
  27 MODULE_DESCRIPTION("V4L2 driver module for tw5864-based multimedia capture & encoding devices");
  28 MODULE_AUTHOR("Bluecherry Maintainers <maintainers@bluecherrydvr.com>");
  29 MODULE_AUTHOR("Andrey Utkin <andrey.utkin@corp.bluecherry.net>");
  30 MODULE_LICENSE("GPL");
  31 
  32 /*
  33  * BEWARE OF KNOWN ISSUES WITH VIDEO QUALITY
  34  *
  35  * This driver was developed by Bluecherry LLC by deducing behaviour of
  36  * original manufacturer's driver, from both source code and execution traces.
  37  * It is known that there are some artifacts on output video with this driver:
  38  *  - on all known hardware samples: random pixels of wrong color (mostly
  39  *    white, red or blue) appearing and disappearing on sequences of P-frames;
  40  *  - on some hardware samples (known with H.264 core version e006:2800):
  41  *    total madness on P-frames: blocks of wrong luminance; blocks of wrong
  42  *    colors "creeping" across the picture.
  43  * There is a workaround for both issues: avoid P-frames by setting GOP size
  44  * to 1. To do that, run this command on device files created by this driver:
  45  *
  46  * v4l2-ctl --device /dev/videoX --set-ctrl=video_gop_size=1
  47  *
  48  * These issues are not decoding errors; all produced H.264 streams are decoded
  49  * properly. Streams without P-frames don't have these artifacts so it's not
  50  * analog-to-digital conversion issues nor internal memory errors; we conclude
  51  * it's internal H.264 encoder issues.
  52  * We cannot even check the original driver's behaviour because it has never
  53  * worked properly at all in our development environment. So these issues may
  54  * be actually related to firmware or hardware. However it may be that there's
  55  * just some more register settings missing in the driver which would please
  56  * the hardware.
  57  * Manufacturer didn't help much on our inquiries, but feel free to disturb
  58  * again the support of Intersil (owner of former Techwell).
  59  */
  60 
  61 /* take first free /dev/videoX indexes by default */
  62 static unsigned int video_nr[] = {[0 ... (TW5864_INPUTS - 1)] = -1 };
  63 
  64 module_param_array(video_nr, int, NULL, 0444);
  65 MODULE_PARM_DESC(video_nr, "video devices numbers array");
  66 
  67 /*
  68  * Please add any new PCI IDs to: http://pci-ids.ucw.cz.  This keeps
  69  * the PCI ID database up to date.  Note that the entries must be
  70  * added under vendor 0x1797 (Techwell Inc.) as subsystem IDs.
  71  */
  72 static const struct pci_device_id tw5864_pci_tbl[] = {
  73         {PCI_DEVICE(PCI_VENDOR_ID_TECHWELL, PCI_DEVICE_ID_TECHWELL_5864)},
  74         {0,}
  75 };
  76 
  77 void tw5864_irqmask_apply(struct tw5864_dev *dev)
  78 {
  79         tw_writel(TW5864_INTR_ENABLE_L, dev->irqmask & 0xffff);
  80         tw_writel(TW5864_INTR_ENABLE_H, (dev->irqmask >> 16));
  81 }
  82 
  83 static void tw5864_interrupts_disable(struct tw5864_dev *dev)
  84 {
  85         unsigned long flags;
  86 
  87         spin_lock_irqsave(&dev->slock, flags);
  88         dev->irqmask = 0;
  89         tw5864_irqmask_apply(dev);
  90         spin_unlock_irqrestore(&dev->slock, flags);
  91 }
  92 
  93 static void tw5864_timer_isr(struct tw5864_dev *dev);
  94 static void tw5864_h264_isr(struct tw5864_dev *dev);
  95 
  96 static irqreturn_t tw5864_isr(int irq, void *dev_id)
  97 {
  98         struct tw5864_dev *dev = dev_id;
  99         u32 status;
 100 
 101         status = tw_readl(TW5864_INTR_STATUS_L) |
 102                 tw_readl(TW5864_INTR_STATUS_H) << 16;
 103         if (!status)
 104                 return IRQ_NONE;
 105 
 106         tw_writel(TW5864_INTR_CLR_L, 0xffff);
 107         tw_writel(TW5864_INTR_CLR_H, 0xffff);
 108 
 109         if (status & TW5864_INTR_VLC_DONE)
 110                 tw5864_h264_isr(dev);
 111 
 112         if (status & TW5864_INTR_TIMER)
 113                 tw5864_timer_isr(dev);
 114 
 115         if (!(status & (TW5864_INTR_TIMER | TW5864_INTR_VLC_DONE))) {
 116                 dev_dbg(&dev->pci->dev, "Unknown interrupt, status 0x%08X\n",
 117                         status);
 118         }
 119 
 120         return IRQ_HANDLED;
 121 }
 122 
 123 static void tw5864_h264_isr(struct tw5864_dev *dev)
 124 {
 125         int channel = tw_readl(TW5864_DSP) & TW5864_DSP_ENC_CHN;
 126         struct tw5864_input *input = &dev->inputs[channel];
 127         int cur_frame_index, next_frame_index;
 128         struct tw5864_h264_frame *cur_frame, *next_frame;
 129         unsigned long flags;
 130 
 131         spin_lock_irqsave(&dev->slock, flags);
 132 
 133         cur_frame_index = dev->h264_buf_w_index;
 134         next_frame_index = (cur_frame_index + 1) % H264_BUF_CNT;
 135         cur_frame = &dev->h264_buf[cur_frame_index];
 136         next_frame = &dev->h264_buf[next_frame_index];
 137 
 138         if (next_frame_index != dev->h264_buf_r_index) {
 139                 cur_frame->vlc_len = tw_readl(TW5864_VLC_LENGTH) << 2;
 140                 cur_frame->checksum = tw_readl(TW5864_VLC_CRC_REG);
 141                 cur_frame->input = input;
 142                 cur_frame->timestamp = ktime_get_ns();
 143                 cur_frame->seqno = input->frame_seqno;
 144                 cur_frame->gop_seqno = input->frame_gop_seqno;
 145 
 146                 dev->h264_buf_w_index = next_frame_index;
 147                 tasklet_schedule(&dev->tasklet);
 148 
 149                 cur_frame = next_frame;
 150 
 151                 spin_lock(&input->slock);
 152                 input->frame_seqno++;
 153                 input->frame_gop_seqno++;
 154                 if (input->frame_gop_seqno >= input->gop)
 155                         input->frame_gop_seqno = 0;
 156                 spin_unlock(&input->slock);
 157         } else {
 158                 dev_err(&dev->pci->dev,
 159                         "Skipped frame on input %d because all buffers busy\n",
 160                         channel);
 161         }
 162 
 163         dev->encoder_busy = 0;
 164 
 165         spin_unlock_irqrestore(&dev->slock, flags);
 166 
 167         tw_writel(TW5864_VLC_STREAM_BASE_ADDR, cur_frame->vlc.dma_addr);
 168         tw_writel(TW5864_MV_STREAM_BASE_ADDR, cur_frame->mv.dma_addr);
 169 
 170         /* Additional ack for this interrupt */
 171         tw_writel(TW5864_VLC_DSP_INTR, 0x00000001);
 172         tw_writel(TW5864_PCI_INTR_STATUS, TW5864_VLC_DONE_INTR);
 173 }
 174 
 175 static void tw5864_input_deadline_update(struct tw5864_input *input)
 176 {
 177         input->new_frame_deadline = jiffies + msecs_to_jiffies(1000);
 178 }
 179 
 180 static void tw5864_timer_isr(struct tw5864_dev *dev)
 181 {
 182         unsigned long flags;
 183         int i;
 184         int encoder_busy;
 185 
 186         /* Additional ack for this interrupt */
 187         tw_writel(TW5864_PCI_INTR_STATUS, TW5864_TIMER_INTR);
 188 
 189         spin_lock_irqsave(&dev->slock, flags);
 190         encoder_busy = dev->encoder_busy;
 191         spin_unlock_irqrestore(&dev->slock, flags);
 192 
 193         if (encoder_busy)
 194                 return;
 195 
 196         /*
 197          * Traversing inputs in round-robin fashion, starting from next to the
 198          * last processed one
 199          */
 200         for (i = 0; i < TW5864_INPUTS; i++) {
 201                 int next_input = (i + dev->next_input) % TW5864_INPUTS;
 202                 struct tw5864_input *input = &dev->inputs[next_input];
 203                 int raw_buf_id; /* id of internal buf with last raw frame */
 204 
 205                 spin_lock_irqsave(&input->slock, flags);
 206                 if (!input->enabled)
 207                         goto next;
 208 
 209                 /* Check if new raw frame is available */
 210                 raw_buf_id = tw_mask_shift_readl(TW5864_SENIF_ORG_FRM_PTR1, 0x3,
 211                                                  2 * input->nr);
 212 
 213                 if (input->buf_id != raw_buf_id) {
 214                         input->buf_id = raw_buf_id;
 215                         tw5864_input_deadline_update(input);
 216                         spin_unlock_irqrestore(&input->slock, flags);
 217 
 218                         spin_lock_irqsave(&dev->slock, flags);
 219                         dev->encoder_busy = 1;
 220                         dev->next_input = (next_input + 1) % TW5864_INPUTS;
 221                         spin_unlock_irqrestore(&dev->slock, flags);
 222 
 223                         tw5864_request_encoded_frame(input);
 224                         break;
 225                 }
 226 
 227                 /* No new raw frame; check if channel is stuck */
 228                 if (time_is_after_jiffies(input->new_frame_deadline)) {
 229                         /* If stuck, request new raw frames again */
 230                         tw_mask_shift_writel(TW5864_ENC_BUF_PTR_REC1, 0x3,
 231                                              2 * input->nr, input->buf_id + 3);
 232                         tw5864_input_deadline_update(input);
 233                 }
 234 next:
 235                 spin_unlock_irqrestore(&input->slock, flags);
 236         }
 237 }
 238 
 239 static int tw5864_initdev(struct pci_dev *pci_dev,
 240                           const struct pci_device_id *pci_id)
 241 {
 242         struct tw5864_dev *dev;
 243         int err;
 244 
 245         dev = devm_kzalloc(&pci_dev->dev, sizeof(*dev), GFP_KERNEL);
 246         if (!dev)
 247                 return -ENOMEM;
 248 
 249         snprintf(dev->name, sizeof(dev->name), "tw5864:%s", pci_name(pci_dev));
 250 
 251         err = v4l2_device_register(&pci_dev->dev, &dev->v4l2_dev);
 252         if (err)
 253                 return err;
 254 
 255         /* pci init */
 256         dev->pci = pci_dev;
 257         err = pci_enable_device(pci_dev);
 258         if (err) {
 259                 dev_err(&dev->pci->dev, "pci_enable_device() failed\n");
 260                 goto unreg_v4l2;
 261         }
 262 
 263         pci_set_master(pci_dev);
 264 
 265         err = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32));
 266         if (err) {
 267                 dev_err(&dev->pci->dev, "32 bit PCI DMA is not supported\n");
 268                 goto disable_pci;
 269         }
 270 
 271         /* get mmio */
 272         err = pci_request_regions(pci_dev, dev->name);
 273         if (err) {
 274                 dev_err(&dev->pci->dev, "Cannot request regions for MMIO\n");
 275                 goto disable_pci;
 276         }
 277         dev->mmio = pci_ioremap_bar(pci_dev, 0);
 278         if (!dev->mmio) {
 279                 err = -EIO;
 280                 dev_err(&dev->pci->dev, "can't ioremap() MMIO memory\n");
 281                 goto release_mmio;
 282         }
 283 
 284         spin_lock_init(&dev->slock);
 285 
 286         dev_info(&pci_dev->dev, "TW5864 hardware version: %04x\n",
 287                  tw_readl(TW5864_HW_VERSION));
 288         dev_info(&pci_dev->dev, "TW5864 H.264 core version: %04x:%04x\n",
 289                  tw_readl(TW5864_H264REV),
 290                  tw_readl(TW5864_UNDECLARED_H264REV_PART2));
 291 
 292         err = tw5864_video_init(dev, video_nr);
 293         if (err)
 294                 goto unmap_mmio;
 295 
 296         /* get irq */
 297         err = devm_request_irq(&pci_dev->dev, pci_dev->irq, tw5864_isr,
 298                                IRQF_SHARED, "tw5864", dev);
 299         if (err < 0) {
 300                 dev_err(&dev->pci->dev, "can't get IRQ %d\n", pci_dev->irq);
 301                 goto fini_video;
 302         }
 303 
 304         dev_info(&pci_dev->dev, "Note: there are known video quality issues. For details\n");
 305         dev_info(&pci_dev->dev, "see the comment in drivers/media/pci/tw5864/tw5864-core.c.\n");
 306 
 307         return 0;
 308 
 309 fini_video:
 310         tw5864_video_fini(dev);
 311 unmap_mmio:
 312         iounmap(dev->mmio);
 313 release_mmio:
 314         pci_release_regions(pci_dev);
 315 disable_pci:
 316         pci_disable_device(pci_dev);
 317 unreg_v4l2:
 318         v4l2_device_unregister(&dev->v4l2_dev);
 319         return err;
 320 }
 321 
 322 static void tw5864_finidev(struct pci_dev *pci_dev)
 323 {
 324         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
 325         struct tw5864_dev *dev =
 326                 container_of(v4l2_dev, struct tw5864_dev, v4l2_dev);
 327 
 328         /* shutdown subsystems */
 329         tw5864_interrupts_disable(dev);
 330 
 331         /* unregister */
 332         tw5864_video_fini(dev);
 333 
 334         /* release resources */
 335         iounmap(dev->mmio);
 336         release_mem_region(pci_resource_start(pci_dev, 0),
 337                            pci_resource_len(pci_dev, 0));
 338 
 339         v4l2_device_unregister(&dev->v4l2_dev);
 340         devm_kfree(&pci_dev->dev, dev);
 341 }
 342 
 343 static struct pci_driver tw5864_pci_driver = {
 344         .name = "tw5864",
 345         .id_table = tw5864_pci_tbl,
 346         .probe = tw5864_initdev,
 347         .remove = tw5864_finidev,
 348 };
 349 
 350 module_pci_driver(tw5864_pci_driver);