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