drivers/media/pci/pt3/pt3_dma.c

   1 /*
   2  * Earthsoft PT3 driver
   3  *
   4  * Copyright (C) 2014 Akihiro Tsukada <tskd08@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation version 2.
   9  *
  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 #include <linux/dma-mapping.h>
  17 #include <linux/kernel.h>
  18 #include <linux/pci.h>
  19
  20 #include "pt3.h"
  21
  22 #define PT3_ACCESS_UNIT (TS_PACKET_SZ * 128)
  23 #define PT3_BUF_CANARY  (0x74)
  24
  25 static u32 get_dma_base(int idx)
  26 {
  27         int i;
  28
  29         i = (idx == 1 || idx == 2) ? 3 - idx : idx;
  30         return REG_DMA_BASE + 0x18 * i;
  31 }
  32
  33 int pt3_stop_dma(struct pt3_adapter *adap)
  34 {
  35         struct pt3_board *pt3 = adap->dvb_adap.priv;
  36         u32 base;
  37         u32 stat;
  38         int retry;
  39
  40         base = get_dma_base(adap->adap_idx);
  41         stat = ioread32(pt3->regs[0] + base + OFST_STATUS);
  42         if (!(stat & 0x01))
  43                 return 0;
  44
  45         iowrite32(0x02, pt3->regs[0] + base + OFST_DMA_CTL);
  46         for (retry = 0; retry < 5; retry++) {
  47                 stat = ioread32(pt3->regs[0] + base + OFST_STATUS);
  48                 if (!(stat & 0x01))
  49                         return 0;
  50                 msleep(50);
  51         }
  52         return -EIO;
  53 }
  54
  55 int pt3_start_dma(struct pt3_adapter *adap)
  56 {
  57         struct pt3_board *pt3 = adap->dvb_adap.priv;
  58         u32 base = get_dma_base(adap->adap_idx);
  59
  60         iowrite32(0x02, pt3->regs[0] + base + OFST_DMA_CTL);
  61         iowrite32(lower_32_bits(adap->desc_buf[0].b_addr),
  62                         pt3->regs[0] + base + OFST_DMA_DESC_L);
  63         iowrite32(upper_32_bits(adap->desc_buf[0].b_addr),
  64                         pt3->regs[0] + base + OFST_DMA_DESC_H);
  65         iowrite32(0x01, pt3->regs[0] + base + OFST_DMA_CTL);
  66         return 0;
  67 }
  68
  69
  70 static u8 *next_unit(struct pt3_adapter *adap, int *idx, int *ofs)
  71 {
  72         *ofs += PT3_ACCESS_UNIT;
  73         if (*ofs >= DATA_BUF_SZ) {
  74                 *ofs -= DATA_BUF_SZ;
  75                 (*idx)++;
  76                 if (*idx == adap->num_bufs)
  77                         *idx = 0;
  78         }
  79         return &adap->buffer[*idx].data[*ofs];
  80 }
  81
  82 int pt3_proc_dma(struct pt3_adapter *adap)
  83 {
  84         int idx, ofs;
  85
  86         idx = adap->buf_idx;
  87         ofs = adap->buf_ofs;
  88
  89         if (adap->buffer[idx].data[ofs] == PT3_BUF_CANARY)
  90                 return 0;
  91
  92         while (*next_unit(adap, &idx, &ofs) != PT3_BUF_CANARY) {
  93                 u8 *p;
  94
  95                 p = &adap->buffer[adap->buf_idx].data[adap->buf_ofs];
  96                 if (adap->num_discard > 0)
  97                         adap->num_discard--;
  98                 else if (adap->buf_ofs + PT3_ACCESS_UNIT > DATA_BUF_SZ) {
  99                         dvb_dmx_swfilter_packets(&adap->demux, p,
 100                                 (DATA_BUF_SZ - adap->buf_ofs) / TS_PACKET_SZ);
 101                         dvb_dmx_swfilter_packets(&adap->demux,
 102                                 adap->buffer[idx].data, ofs / TS_PACKET_SZ);
 103                 } else
 104                         dvb_dmx_swfilter_packets(&adap->demux, p,
 105                                 PT3_ACCESS_UNIT / TS_PACKET_SZ);
 106
 107                 *p = PT3_BUF_CANARY;
 108                 adap->buf_idx = idx;
 109                 adap->buf_ofs = ofs;
 110         }
 111         return 0;
 112 }
 113
 114 void pt3_init_dmabuf(struct pt3_adapter *adap)
 115 {
 116         int idx, ofs;
 117         u8 *p;
 118
 119         idx = 0;
 120         ofs = 0;
 121         p = adap->buffer[0].data;
 122         /* mark the whole buffers as "not written yet" */
 123         while (idx < adap->num_bufs) {
 124                 p[ofs] = PT3_BUF_CANARY;
 125                 ofs += PT3_ACCESS_UNIT;
 126                 if (ofs >= DATA_BUF_SZ) {
 127                         ofs -= DATA_BUF_SZ;
 128                         idx++;
 129                         p = adap->buffer[idx].data;
 130                 }
 131         }
 132         adap->buf_idx = 0;
 133         adap->buf_ofs = 0;
 134 }
 135
 136 void pt3_free_dmabuf(struct pt3_adapter *adap)
 137 {
 138         struct pt3_board *pt3;
 139         int i;
 140
 141         pt3 = adap->dvb_adap.priv;
 142         for (i = 0; i < adap->num_bufs; i++)
 143                 dma_free_coherent(&pt3->pdev->dev, DATA_BUF_SZ,
 144                         adap->buffer[i].data, adap->buffer[i].b_addr);
 145         adap->num_bufs = 0;
 146
 147         for (i = 0; i < adap->num_desc_bufs; i++)
 148                 dma_free_coherent(&pt3->pdev->dev, PAGE_SIZE,
 149                         adap->desc_buf[i].descs, adap->desc_buf[i].b_addr);
 150         adap->num_desc_bufs = 0;
 151 }
 152
 153
 154 int pt3_alloc_dmabuf(struct pt3_adapter *adap)
 155 {
 156         struct pt3_board *pt3;
 157         void *p;
 158         int i, j;
 159         int idx, ofs;
 160         int num_desc_bufs;
 161         dma_addr_t data_addr, desc_addr;
 162         struct xfer_desc *d;
 163
 164         pt3 = adap->dvb_adap.priv;
 165         adap->num_bufs = 0;
 166         adap->num_desc_bufs = 0;
 167         for (i = 0; i < pt3->num_bufs; i++) {
 168                 p = dma_alloc_coherent(&pt3->pdev->dev, DATA_BUF_SZ,
 169                                         &adap->buffer[i].b_addr, GFP_KERNEL);
 170                 if (p == NULL)
 171                         goto failed;
 172                 adap->buffer[i].data = p;
 173                 adap->num_bufs++;
 174         }
 175         pt3_init_dmabuf(adap);
 176
 177         /* build circular-linked pointers (xfer_desc) to the data buffers*/
 178         idx = 0;
 179         ofs = 0;
 180         num_desc_bufs =
 181                 DIV_ROUND_UP(adap->num_bufs * DATA_BUF_XFERS, DESCS_IN_PAGE);
 182         for (i = 0; i < num_desc_bufs; i++) {
 183                 p = dma_alloc_coherent(&pt3->pdev->dev, PAGE_SIZE,
 184                                         &desc_addr, GFP_KERNEL);
 185                 if (p == NULL)
 186                         goto failed;
 187                 adap->num_desc_bufs++;
 188                 adap->desc_buf[i].descs = p;
 189                 adap->desc_buf[i].b_addr = desc_addr;
 190
 191                 if (i > 0) {
 192                         d = &adap->desc_buf[i - 1].descs[DESCS_IN_PAGE - 1];
 193                         d->next_l = lower_32_bits(desc_addr);
 194                         d->next_h = upper_32_bits(desc_addr);
 195                 }
 196                 for (j = 0; j < DESCS_IN_PAGE; j++) {
 197                         data_addr = adap->buffer[idx].b_addr + ofs;
 198                         d = &adap->desc_buf[i].descs[j];
 199                         d->addr_l = lower_32_bits(data_addr);
 200                         d->addr_h = upper_32_bits(data_addr);
 201                         d->size = DATA_XFER_SZ;
 202
 203                         desc_addr += sizeof(struct xfer_desc);
 204                         d->next_l = lower_32_bits(desc_addr);
 205                         d->next_h = upper_32_bits(desc_addr);
 206
 207                         ofs += DATA_XFER_SZ;
 208                         if (ofs >= DATA_BUF_SZ) {
 209                                 ofs -= DATA_BUF_SZ;
 210                                 idx++;
 211                                 if (idx >= adap->num_bufs) {
 212                                         desc_addr = adap->desc_buf[0].b_addr;
 213                                         d->next_l = lower_32_bits(desc_addr);
 214                                         d->next_h = upper_32_bits(desc_addr);
 215                                         return 0;
 216                                 }
 217                         }
 218                 }
 219         }
 220         return 0;
 221
 222 failed:
 223         pt3_free_dmabuf(adap);
 224         return -ENOMEM;
 225 }