drivers/media/pci/mantis/mantis_dma.c

   1 /*
   2         Mantis PCI bridge driver
   3
   4         Copyright (C) Manu Abraham (abraham.manu@gmail.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         You should have received a copy of the GNU General Public License
  17         along with this program; if not, write to the Free Software
  18         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include <linux/kernel.h>
  22 #include <asm/page.h>
  23 #include <linux/vmalloc.h>
  24 #include <linux/pci.h>
  25
  26 #include <asm/irq.h>
  27 #include <linux/signal.h>
  28 #include <linux/sched.h>
  29 #include <linux/interrupt.h>
  30
  31 #include <media/dmxdev.h>
  32 #include <media/dvbdev.h>
  33 #include <media/dvb_demux.h>
  34 #include <media/dvb_frontend.h>
  35 #include <media/dvb_net.h>
  36
  37 #include "mantis_common.h"
  38 #include "mantis_reg.h"
  39 #include "mantis_dma.h"
  40
  41 #define RISC_WRITE              (0x01 << 28)
  42 #define RISC_JUMP               (0x07 << 28)
  43 #define RISC_IRQ                (0x01 << 24)
  44
  45 #define RISC_STATUS(status)     ((((~status) & 0x0f) << 20) | ((status & 0x0f) << 16))
  46 #define RISC_FLUSH(risc_pos)            (risc_pos = 0)
  47 #define RISC_INSTR(risc_pos, opcode)    (mantis->risc_cpu[risc_pos++] = cpu_to_le32(opcode))
  48
  49 #define MANTIS_BUF_SIZE         (64 * 1024)
  50 #define MANTIS_BLOCK_BYTES      (MANTIS_BUF_SIZE / 4)
  51 #define MANTIS_DMA_TR_BYTES     (2 * 1024) /* upper limit: 4095 bytes. */
  52 #define MANTIS_BLOCK_COUNT      (MANTIS_BUF_SIZE / MANTIS_BLOCK_BYTES)
  53
  54 #define MANTIS_DMA_TR_UNITS     (MANTIS_BLOCK_BYTES / MANTIS_DMA_TR_BYTES)
  55 /* MANTIS_BUF_SIZE / MANTIS_DMA_TR_UNITS must not exceed MANTIS_RISC_SIZE (4k RISC cmd buffer) */
  56 #define MANTIS_RISC_SIZE        PAGE_SIZE /* RISC program must fit here. */
  57
  58 int mantis_dma_exit(struct mantis_pci *mantis)
  59 {
  60         if (mantis->buf_cpu) {
  61                 dprintk(MANTIS_ERROR, 1,
  62                         "DMA=0x%lx cpu=0x%p size=%d",
  63                         (unsigned long) mantis->buf_dma,
  64                          mantis->buf_cpu,
  65                          MANTIS_BUF_SIZE);
  66
  67                 pci_free_consistent(mantis->pdev, MANTIS_BUF_SIZE,
  68                                     mantis->buf_cpu, mantis->buf_dma);
  69
  70                 mantis->buf_cpu = NULL;
  71         }
  72         if (mantis->risc_cpu) {
  73                 dprintk(MANTIS_ERROR, 1,
  74                         "RISC=0x%lx cpu=0x%p size=%lx",
  75                         (unsigned long) mantis->risc_dma,
  76                         mantis->risc_cpu,
  77                         MANTIS_RISC_SIZE);
  78
  79                 pci_free_consistent(mantis->pdev, MANTIS_RISC_SIZE,
  80                                     mantis->risc_cpu, mantis->risc_dma);
  81
  82                 mantis->risc_cpu = NULL;
  83         }
  84
  85         return 0;
  86 }
  87 EXPORT_SYMBOL_GPL(mantis_dma_exit);
  88
  89 static inline int mantis_alloc_buffers(struct mantis_pci *mantis)
  90 {
  91         if (!mantis->buf_cpu) {
  92                 mantis->buf_cpu = pci_alloc_consistent(mantis->pdev,
  93                                                        MANTIS_BUF_SIZE,
  94                                                        &mantis->buf_dma);
  95                 if (!mantis->buf_cpu) {
  96                         dprintk(MANTIS_ERROR, 1,
  97                                 "DMA buffer allocation failed");
  98
  99                         goto err;
 100                 }
 101                 dprintk(MANTIS_ERROR, 1,
 102                         "DMA=0x%lx cpu=0x%p size=%d",
 103                         (unsigned long) mantis->buf_dma,
 104                         mantis->buf_cpu, MANTIS_BUF_SIZE);
 105         }
 106         if (!mantis->risc_cpu) {
 107                 mantis->risc_cpu = pci_alloc_consistent(mantis->pdev,
 108                                                         MANTIS_RISC_SIZE,
 109                                                         &mantis->risc_dma);
 110
 111                 if (!mantis->risc_cpu) {
 112                         dprintk(MANTIS_ERROR, 1,
 113                                 "RISC program allocation failed");
 114
 115                         mantis_dma_exit(mantis);
 116
 117                         goto err;
 118                 }
 119                 dprintk(MANTIS_ERROR, 1,
 120                         "RISC=0x%lx cpu=0x%p size=%lx",
 121                         (unsigned long) mantis->risc_dma,
 122                         mantis->risc_cpu, MANTIS_RISC_SIZE);
 123         }
 124
 125         return 0;
 126 err:
 127         dprintk(MANTIS_ERROR, 1, "Out of memory (?) .....");
 128         return -ENOMEM;
 129 }
 130
 131 int mantis_dma_init(struct mantis_pci *mantis)
 132 {
 133         int err;
 134
 135         dprintk(MANTIS_DEBUG, 1, "Mantis DMA init");
 136         err = mantis_alloc_buffers(mantis);
 137         if (err < 0) {
 138                 dprintk(MANTIS_ERROR, 1, "Error allocating DMA buffer");
 139
 140                 /* Stop RISC Engine */
 141                 mmwrite(0, MANTIS_DMA_CTL);
 142
 143                 return err;
 144         }
 145
 146         return 0;
 147 }
 148 EXPORT_SYMBOL_GPL(mantis_dma_init);
 149
 150 static inline void mantis_risc_program(struct mantis_pci *mantis)
 151 {
 152         u32 buf_pos = 0;
 153         u32 line, step;
 154         u32 risc_pos;
 155
 156         dprintk(MANTIS_DEBUG, 1, "Mantis create RISC program");
 157         RISC_FLUSH(risc_pos);
 158
 159         dprintk(MANTIS_DEBUG, 1, "risc len lines %u, bytes per line %u, bytes per DMA tr %u",
 160                 MANTIS_BLOCK_COUNT, MANTIS_BLOCK_BYTES, MANTIS_DMA_TR_BYTES);
 161
 162         for (line = 0; line < MANTIS_BLOCK_COUNT; line++) {
 163                 for (step = 0; step < MANTIS_DMA_TR_UNITS; step++) {
 164                         dprintk(MANTIS_DEBUG, 1, "RISC PROG line=[%d], step=[%d]", line, step);
 165                         if (step == 0) {
 166                                 RISC_INSTR(risc_pos, RISC_WRITE |
 167                                            RISC_IRQ     |
 168                                            RISC_STATUS(line) |
 169                                            MANTIS_DMA_TR_BYTES);
 170                         } else {
 171                                 RISC_INSTR(risc_pos, RISC_WRITE | MANTIS_DMA_TR_BYTES);
 172                         }
 173                         RISC_INSTR(risc_pos, mantis->buf_dma + buf_pos);
 174                         buf_pos += MANTIS_DMA_TR_BYTES;
 175                   }
 176         }
 177         RISC_INSTR(risc_pos, RISC_JUMP);
 178         RISC_INSTR(risc_pos, mantis->risc_dma);
 179 }
 180
 181 void mantis_dma_start(struct mantis_pci *mantis)
 182 {
 183         dprintk(MANTIS_DEBUG, 1, "Mantis Start DMA engine");
 184
 185         mantis_risc_program(mantis);
 186         mmwrite(mantis->risc_dma, MANTIS_RISC_START);
 187         mmwrite(mmread(MANTIS_GPIF_ADDR) | MANTIS_GPIF_HIFRDWRN, MANTIS_GPIF_ADDR);
 188
 189         mmwrite(0, MANTIS_DMA_CTL);
 190         mantis->last_block = mantis->busy_block = 0;
 191
 192         mantis_unmask_ints(mantis, MANTIS_INT_RISCI);
 193
 194         mmwrite(MANTIS_FIFO_EN | MANTIS_DCAP_EN
 195                                | MANTIS_RISC_EN, MANTIS_DMA_CTL);
 196
 197 }
 198
 199 void mantis_dma_stop(struct mantis_pci *mantis)
 200 {
 201         dprintk(MANTIS_DEBUG, 1, "Mantis Stop DMA engine");
 202
 203         mmwrite((mmread(MANTIS_GPIF_ADDR) & (~(MANTIS_GPIF_HIFRDWRN))), MANTIS_GPIF_ADDR);
 204
 205         mmwrite((mmread(MANTIS_DMA_CTL) & ~(MANTIS_FIFO_EN |
 206                                             MANTIS_DCAP_EN |
 207                                             MANTIS_RISC_EN)), MANTIS_DMA_CTL);
 208
 209         mmwrite(mmread(MANTIS_INT_STAT), MANTIS_INT_STAT);
 210
 211         mantis_mask_ints(mantis, MANTIS_INT_RISCI | MANTIS_INT_RISCEN);
 212 }
 213
 214
 215 void mantis_dma_xfer(unsigned long data)
 216 {
 217         struct mantis_pci *mantis = (struct mantis_pci *) data;
 218         struct mantis_hwconfig *config = mantis->hwconfig;
 219
 220         while (mantis->last_block != mantis->busy_block) {
 221                 dprintk(MANTIS_DEBUG, 1, "last block=[%d] finished block=[%d]",
 222                         mantis->last_block, mantis->busy_block);
 223
 224                 (config->ts_size ? dvb_dmx_swfilter_204 : dvb_dmx_swfilter)
 225                 (&mantis->demux, &mantis->buf_cpu[mantis->last_block * MANTIS_BLOCK_BYTES], MANTIS_BLOCK_BYTES);
 226                 mantis->last_block = (mantis->last_block + 1) % MANTIS_BLOCK_COUNT;
 227         }
 228 }