tristate "Conexant 2388x (bt878 successor) support"
        depends on VIDEO_DEV && PCI && I2C && RC_CORE
        select I2C_ALGOBIT
-       select VIDEO_BTCX
        select VIDEOBUF2_DMA_SG
        select VIDEO_TUNER
        select VIDEO_TVEEPROM
 
 obj-$(CONFIG_VIDEO_CX88_VP3054) += cx88-vp3054-i2c.o
 
 ccflags-y += -Idrivers/media/i2c
-ccflags-y += -Idrivers/media/common
 ccflags-y += -Idrivers/media/tuners
 ccflags-y += -Idrivers/media/dvb-core
 ccflags-y += -Idrivers/media/dvb-frontends
 
 
 struct cx88_audio_buffer {
        unsigned int               bpl;
-       struct btcx_riscmem        risc;
+       struct cx88_riscmem        risc;
        void                    *vaddr;
        struct scatterlist      *sglist;
        int                     sglen;
 
 static int dsp_buffer_free(snd_cx88_card_t *chip)
 {
+       struct cx88_riscmem *risc = &chip->buf->risc;
+
        BUG_ON(!chip->dma_size);
 
        dprintk(2,"Freeing buffer\n");
        cx88_alsa_dma_unmap(chip);
        cx88_alsa_dma_free(chip->buf);
-       btcx_riscmem_free(chip->pci, &chip->buf->risc);
+       if (risc->cpu)
+               pci_free_consistent(chip->pci, risc->size, risc->cpu, risc->dma);
        kfree(chip->buf);
 
        chip->buf = NULL;
 
        struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+       struct cx88_riscmem *risc = &buf->risc;
 
-       btcx_riscmem_free(dev->pci, &buf->risc);
+       if (risc->cpu)
+               pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+       memset(risc, 0, sizeof(*risc));
 
        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
        return rp;
 }
 
-int cx88_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
+int cx88_risc_buffer(struct pci_dev *pci, struct cx88_riscmem *risc,
                     struct scatterlist *sglist,
                     unsigned int top_offset, unsigned int bottom_offset,
                     unsigned int bpl, unsigned int padding, unsigned int lines)
 {
        u32 instructions,fields;
        __le32 *rp;
-       int rc;
 
        fields = 0;
        if (UNSET != top_offset)
           region may be smaller than PAGE_SIZE */
        instructions  = fields * (1 + ((bpl + padding) * lines) / PAGE_SIZE + lines);
        instructions += 4;
-       if ((rc = btcx_riscmem_alloc(pci,risc,instructions*8)) < 0)
-               return rc;
+       risc->size = instructions * 8;
+       risc->dma = 0;
+       risc->cpu = pci_zalloc_consistent(pci, risc->size, &risc->dma);
+       if (NULL == risc->cpu)
+               return -ENOMEM;
 
        /* write risc instructions */
        rp = risc->cpu;
        return 0;
 }
 
-int cx88_risc_databuffer(struct pci_dev *pci, struct btcx_riscmem *risc,
+int cx88_risc_databuffer(struct pci_dev *pci, struct cx88_riscmem *risc,
                         struct scatterlist *sglist, unsigned int bpl,
                         unsigned int lines, unsigned int lpi)
 {
        u32 instructions;
        __le32 *rp;
-       int rc;
 
        /* estimate risc mem: worst case is one write per page border +
           one write per scan line + syncs + jump (all 2 dwords).  Here
           than PAGE_SIZE */
        instructions  = 1 + (bpl * lines) / PAGE_SIZE + lines;
        instructions += 3;
-       if ((rc = btcx_riscmem_alloc(pci,risc,instructions*8)) < 0)
-               return rc;
+       risc->size = instructions * 8;
+       risc->dma = 0;
+       risc->cpu = pci_zalloc_consistent(pci, risc->size, &risc->dma);
+       if (NULL == risc->cpu)
+               return -ENOMEM;
 
        /* write risc instructions */
        rp = risc->cpu;
 
        struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+       struct cx88_riscmem *risc = &buf->risc;
 
-       btcx_riscmem_free(dev->pci, &buf->risc);
+       if (risc->cpu)
+               pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+       memset(risc, 0, sizeof(*risc));
 
        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
 {
        int size = dev->ts_packet_size * dev->ts_packet_count;
        struct sg_table *sgt = vb2_dma_sg_plane_desc(&buf->vb, 0);
+       struct cx88_riscmem *risc = &buf->risc;
        int rc;
 
        if (vb2_plane_size(&buf->vb, 0) < size)
        if (!rc)
                return -EIO;
 
-       rc = cx88_risc_databuffer(dev->pci, &buf->risc, sgt->sgl,
+       rc = cx88_risc_databuffer(dev->pci, risc, sgt->sgl,
                             dev->ts_packet_size, dev->ts_packet_count, 0);
        if (rc) {
-               btcx_riscmem_free(dev->pci, &buf->risc);
+               if (risc->cpu)
+                       pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+               memset(risc, 0, sizeof(*risc));
                return rc;
        }
        return 0;
 
        struct cx8800_dev *dev = vb->vb2_queue->drv_priv;
        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+       struct cx88_riscmem *risc = &buf->risc;
 
-       btcx_riscmem_free(dev->pci, &buf->risc);
+       if (risc->cpu)
+               pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+       memset(risc, 0, sizeof(*risc));
 
        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
        struct cx8800_dev *dev = vb->vb2_queue->drv_priv;
        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+       struct cx88_riscmem *risc = &buf->risc;
 
-       btcx_riscmem_free(dev->pci, &buf->risc);
+       if (risc->cpu)
+               pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+       memset(risc, 0, sizeof(*risc));
 
        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
 #include <media/ir-kbd-i2c.h>
 #include <media/wm8775.h>
 
-#include "btcx-risc.h"
 #include "cx88-reg.h"
 #include "tuner-xc2028.h"
 
 
 #define BUFFER_TIMEOUT     msecs_to_jiffies(2000)
 
+struct cx88_riscmem {
+       unsigned int   size;
+       __le32         *cpu;
+       __le32         *jmp;
+       dma_addr_t     dma;
+};
+
 /* buffer for one video frame */
 struct cx88_buffer {
        /* common v4l buffer stuff -- must be first */
 
        /* cx88 specific */
        unsigned int           bpl;
-       struct btcx_riscmem    risc;
+       struct cx88_riscmem    risc;
        u32                    count;
 };
 
 extern int cx88_reset(struct cx88_core *core);
 
 extern int
-cx88_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
+cx88_risc_buffer(struct pci_dev *pci, struct cx88_riscmem *risc,
                 struct scatterlist *sglist,
                 unsigned int top_offset, unsigned int bottom_offset,
                 unsigned int bpl, unsigned int padding, unsigned int lines);
 extern int
-cx88_risc_databuffer(struct pci_dev *pci, struct btcx_riscmem *risc,
+cx88_risc_databuffer(struct pci_dev *pci, struct cx88_riscmem *risc,
                     struct scatterlist *sglist, unsigned int bpl,
                     unsigned int lines, unsigned int lpi);
 
 extern void cx88_risc_disasm(struct cx88_core *core,
-                            struct btcx_riscmem *risc);
+                            struct cx88_riscmem *risc);
 extern int cx88_sram_channel_setup(struct cx88_core *core,
                                   const struct sram_channel *ch,
                                   unsigned int bpl, u32 risc);