drivers/dma/st_fdma.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * DMA driver for STMicroelectronics STi FDMA controller
   4  *
   5  * Copyright (C) 2014 STMicroelectronics
   6  *
   7  * Author: Ludovic Barre <Ludovic.barre@st.com>
   8  *         Peter Griffin <peter.griffin@linaro.org>
   9  */
  10
  11 #include <linux/init.h>
  12 #include <linux/module.h>
  13 #include <linux/of_device.h>
  14 #include <linux/of_dma.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/remoteproc.h>
  18 #include <linux/slab.h>
  19
  20 #include "st_fdma.h"
  21
  22 static inline struct st_fdma_chan *to_st_fdma_chan(struct dma_chan *c)
  23 {
  24         return container_of(c, struct st_fdma_chan, vchan.chan);
  25 }
  26
  27 static struct st_fdma_desc *to_st_fdma_desc(struct virt_dma_desc *vd)
  28 {
  29         return container_of(vd, struct st_fdma_desc, vdesc);
  30 }
  31
  32 static int st_fdma_dreq_get(struct st_fdma_chan *fchan)
  33 {
  34         struct st_fdma_dev *fdev = fchan->fdev;
  35         u32 req_line_cfg = fchan->cfg.req_line;
  36         u32 dreq_line;
  37         int try = 0;
  38
  39         /*
  40          * dreq_mask is shared for n channels of fdma, so all accesses must be
  41          * atomic. if the dreq_mask is changed between ffz and set_bit,
  42          * we retry
  43          */
  44         do {
  45                 if (fdev->dreq_mask == ~0L) {
  46                         dev_err(fdev->dev, "No req lines available\n");
  47                         return -EINVAL;
  48                 }
  49
  50                 if (try || req_line_cfg >= ST_FDMA_NR_DREQS) {
  51                         dev_err(fdev->dev, "Invalid or used req line\n");
  52                         return -EINVAL;
  53                 } else {
  54                         dreq_line = req_line_cfg;
  55                 }
  56
  57                 try++;
  58         } while (test_and_set_bit(dreq_line, &fdev->dreq_mask));
  59
  60         dev_dbg(fdev->dev, "get dreq_line:%d mask:%#lx\n",
  61                 dreq_line, fdev->dreq_mask);
  62
  63         return dreq_line;
  64 }
  65
  66 static void st_fdma_dreq_put(struct st_fdma_chan *fchan)
  67 {
  68         struct st_fdma_dev *fdev = fchan->fdev;
  69
  70         dev_dbg(fdev->dev, "put dreq_line:%#x\n", fchan->dreq_line);
  71         clear_bit(fchan->dreq_line, &fdev->dreq_mask);
  72 }
  73
  74 static void st_fdma_xfer_desc(struct st_fdma_chan *fchan)
  75 {
  76         struct virt_dma_desc *vdesc;
  77         unsigned long nbytes, ch_cmd, cmd;
  78
  79         vdesc = vchan_next_desc(&fchan->vchan);
  80         if (!vdesc)
  81                 return;
  82
  83         fchan->fdesc = to_st_fdma_desc(vdesc);
  84         nbytes = fchan->fdesc->node[0].desc->nbytes;
  85         cmd = FDMA_CMD_START(fchan->vchan.chan.chan_id);
  86         ch_cmd = fchan->fdesc->node[0].pdesc | FDMA_CH_CMD_STA_START;
  87
  88         /* start the channel for the descriptor */
  89         fnode_write(fchan, nbytes, FDMA_CNTN_OFST);
  90         fchan_write(fchan, ch_cmd, FDMA_CH_CMD_OFST);
  91         writel(cmd,
  92                 fchan->fdev->slim_rproc->peri + FDMA_CMD_SET_OFST);
  93
  94         dev_dbg(fchan->fdev->dev, "start chan:%d\n", fchan->vchan.chan.chan_id);
  95 }
  96
  97 static void st_fdma_ch_sta_update(struct st_fdma_chan *fchan,
  98                                   unsigned long int_sta)
  99 {
 100         unsigned long ch_sta, ch_err;
 101         int ch_id = fchan->vchan.chan.chan_id;
 102         struct st_fdma_dev *fdev = fchan->fdev;
 103
 104         ch_sta = fchan_read(fchan, FDMA_CH_CMD_OFST);
 105         ch_err = ch_sta & FDMA_CH_CMD_ERR_MASK;
 106         ch_sta &= FDMA_CH_CMD_STA_MASK;
 107
 108         if (int_sta & FDMA_INT_STA_ERR) {
 109                 dev_warn(fdev->dev, "chan:%d, error:%ld\n", ch_id, ch_err);
 110                 fchan->status = DMA_ERROR;
 111                 return;
 112         }
 113
 114         switch (ch_sta) {
 115         case FDMA_CH_CMD_STA_PAUSED:
 116                 fchan->status = DMA_PAUSED;
 117                 break;
 118
 119         case FDMA_CH_CMD_STA_RUNNING:
 120                 fchan->status = DMA_IN_PROGRESS;
 121                 break;
 122         }
 123 }
 124
 125 static irqreturn_t st_fdma_irq_handler(int irq, void *dev_id)
 126 {
 127         struct st_fdma_dev *fdev = dev_id;
 128         irqreturn_t ret = IRQ_NONE;
 129         struct st_fdma_chan *fchan = &fdev->chans[0];
 130         unsigned long int_sta, clr;
 131
 132         int_sta = fdma_read(fdev, FDMA_INT_STA_OFST);
 133         clr = int_sta;
 134
 135         for (; int_sta != 0 ; int_sta >>= 2, fchan++) {
 136                 if (!(int_sta & (FDMA_INT_STA_CH | FDMA_INT_STA_ERR)))
 137                         continue;
 138
 139                 spin_lock(&fchan->vchan.lock);
 140                 st_fdma_ch_sta_update(fchan, int_sta);
 141
 142                 if (fchan->fdesc) {
 143                         if (!fchan->fdesc->iscyclic) {
 144                                 list_del(&fchan->fdesc->vdesc.node);
 145                                 vchan_cookie_complete(&fchan->fdesc->vdesc);
 146                                 fchan->fdesc = NULL;
 147                                 fchan->status = DMA_COMPLETE;
 148                         } else {
 149                                 vchan_cyclic_callback(&fchan->fdesc->vdesc);
 150                         }
 151
 152                         /* Start the next descriptor (if available) */
 153                         if (!fchan->fdesc)
 154                                 st_fdma_xfer_desc(fchan);
 155                 }
 156
 157                 spin_unlock(&fchan->vchan.lock);
 158                 ret = IRQ_HANDLED;
 159         }
 160
 161         fdma_write(fdev, clr, FDMA_INT_CLR_OFST);
 162
 163         return ret;
 164 }
 165
 166 static struct dma_chan *st_fdma_of_xlate(struct of_phandle_args *dma_spec,
 167                                          struct of_dma *ofdma)
 168 {
 169         struct st_fdma_dev *fdev = ofdma->of_dma_data;
 170         struct dma_chan *chan;
 171         struct st_fdma_chan *fchan;
 172         int ret;
 173
 174         if (dma_spec->args_count < 1)
 175                 return ERR_PTR(-EINVAL);
 176
 177         if (fdev->dma_device.dev->of_node != dma_spec->np)
 178                 return ERR_PTR(-EINVAL);
 179
 180         ret = rproc_boot(fdev->slim_rproc->rproc);
 181         if (ret == -ENOENT)
 182                 return ERR_PTR(-EPROBE_DEFER);
 183         else if (ret)
 184                 return ERR_PTR(ret);
 185
 186         chan = dma_get_any_slave_channel(&fdev->dma_device);
 187         if (!chan)
 188                 goto err_chan;
 189
 190         fchan = to_st_fdma_chan(chan);
 191
 192         fchan->cfg.of_node = dma_spec->np;
 193         fchan->cfg.req_line = dma_spec->args[0];
 194         fchan->cfg.req_ctrl = 0;
 195         fchan->cfg.type = ST_FDMA_TYPE_FREE_RUN;
 196
 197         if (dma_spec->args_count > 1)
 198                 fchan->cfg.req_ctrl = dma_spec->args[1]
 199                         & FDMA_REQ_CTRL_CFG_MASK;
 200
 201         if (dma_spec->args_count > 2)
 202                 fchan->cfg.type = dma_spec->args[2];
 203
 204         if (fchan->cfg.type == ST_FDMA_TYPE_FREE_RUN) {
 205                 fchan->dreq_line = 0;
 206         } else {
 207                 fchan->dreq_line = st_fdma_dreq_get(fchan);
 208                 if (IS_ERR_VALUE(fchan->dreq_line)) {
 209                         chan = ERR_PTR(fchan->dreq_line);
 210                         goto err_chan;
 211                 }
 212         }
 213
 214         dev_dbg(fdev->dev, "xlate req_line:%d type:%d req_ctrl:%#lx\n",
 215                 fchan->cfg.req_line, fchan->cfg.type, fchan->cfg.req_ctrl);
 216
 217         return chan;
 218
 219 err_chan:
 220         rproc_shutdown(fdev->slim_rproc->rproc);
 221         return chan;
 222
 223 }
 224
 225 static void st_fdma_free_desc(struct virt_dma_desc *vdesc)
 226 {
 227         struct st_fdma_desc *fdesc;
 228         int i;
 229
 230         fdesc = to_st_fdma_desc(vdesc);
 231         for (i = 0; i < fdesc->n_nodes; i++)
 232                 dma_pool_free(fdesc->fchan->node_pool, fdesc->node[i].desc,
 233                               fdesc->node[i].pdesc);
 234         kfree(fdesc);
 235 }
 236
 237 static struct st_fdma_desc *st_fdma_alloc_desc(struct st_fdma_chan *fchan,
 238                                                int sg_len)
 239 {
 240         struct st_fdma_desc *fdesc;
 241         int i;
 242
 243         fdesc = kzalloc(struct_size(fdesc, node, sg_len), GFP_NOWAIT);
 244         if (!fdesc)
 245                 return NULL;
 246
 247         fdesc->fchan = fchan;
 248         fdesc->n_nodes = sg_len;
 249         for (i = 0; i < sg_len; i++) {
 250                 fdesc->node[i].desc = dma_pool_alloc(fchan->node_pool,
 251                                 GFP_NOWAIT, &fdesc->node[i].pdesc);
 252                 if (!fdesc->node[i].desc)
 253                         goto err;
 254         }
 255         return fdesc;
 256
 257 err:
 258         while (--i >= 0)
 259                 dma_pool_free(fchan->node_pool, fdesc->node[i].desc,
 260                               fdesc->node[i].pdesc);
 261         kfree(fdesc);
 262         return NULL;
 263 }
 264
 265 static int st_fdma_alloc_chan_res(struct dma_chan *chan)
 266 {
 267         struct st_fdma_chan *fchan = to_st_fdma_chan(chan);
 268
 269         /* Create the dma pool for descriptor allocation */
 270         fchan->node_pool = dma_pool_create(dev_name(&chan->dev->device),
 271                                             fchan->fdev->dev,
 272                                             sizeof(struct st_fdma_hw_node),
 273                                             __alignof__(struct st_fdma_hw_node),
 274                                             0);
 275
 276         if (!fchan->node_pool) {
 277                 dev_err(fchan->fdev->dev, "unable to allocate desc pool\n");
 278                 return -ENOMEM;
 279         }
 280
 281         dev_dbg(fchan->fdev->dev, "alloc ch_id:%d type:%d\n",
 282                 fchan->vchan.chan.chan_id, fchan->cfg.type);
 283
 284         return 0;
 285 }
 286
 287 static void st_fdma_free_chan_res(struct dma_chan *chan)
 288 {
 289         struct st_fdma_chan *fchan = to_st_fdma_chan(chan);
 290         struct rproc *rproc = fchan->fdev->slim_rproc->rproc;
 291         unsigned long flags;
 292
 293         dev_dbg(fchan->fdev->dev, "%s: freeing chan:%d\n",
 294                 __func__, fchan->vchan.chan.chan_id);
 295
 296         if (fchan->cfg.type != ST_FDMA_TYPE_FREE_RUN)
 297                 st_fdma_dreq_put(fchan);
 298
 299         spin_lock_irqsave(&fchan->vchan.lock, flags);
 300         fchan->fdesc = NULL;
 301         spin_unlock_irqrestore(&fchan->vchan.lock, flags);
 302
 303         dma_pool_destroy(fchan->node_pool);
 304         fchan->node_pool = NULL;
 305         memset(&fchan->cfg, 0, sizeof(struct st_fdma_cfg));
 306
 307         rproc_shutdown(rproc);
 308 }
 309
 310 static struct dma_async_tx_descriptor *st_fdma_prep_dma_memcpy(
 311         struct dma_chan *chan,  dma_addr_t dst, dma_addr_t src,
 312         size_t len, unsigned long flags)
 313 {
 314         struct st_fdma_chan *fchan;
 315         struct st_fdma_desc *fdesc;
 316         struct st_fdma_hw_node *hw_node;
 317
 318         if (!len)
 319                 return NULL;
 320
 321         fchan = to_st_fdma_chan(chan);
 322
 323         /* We only require a single descriptor */
 324         fdesc = st_fdma_alloc_desc(fchan, 1);
 325         if (!fdesc) {
 326                 dev_err(fchan->fdev->dev, "no memory for desc\n");
 327                 return NULL;
 328         }
 329
 330         hw_node = fdesc->node[0].desc;
 331         hw_node->next = 0;
 332         hw_node->control = FDMA_NODE_CTRL_REQ_MAP_FREE_RUN;
 333         hw_node->control |= FDMA_NODE_CTRL_SRC_INCR;
 334         hw_node->control |= FDMA_NODE_CTRL_DST_INCR;
 335         hw_node->control |= FDMA_NODE_CTRL_INT_EON;
 336         hw_node->nbytes = len;
 337         hw_node->saddr = src;
 338         hw_node->daddr = dst;
 339         hw_node->generic.length = len;
 340         hw_node->generic.sstride = 0;
 341         hw_node->generic.dstride = 0;
 342
 343         return vchan_tx_prep(&fchan->vchan, &fdesc->vdesc, flags);
 344 }
 345
 346 static int config_reqctrl(struct st_fdma_chan *fchan,
 347                           enum dma_transfer_direction direction)
 348 {
 349         u32 maxburst = 0, addr = 0;
 350         enum dma_slave_buswidth width;
 351         int ch_id = fchan->vchan.chan.chan_id;
 352         struct st_fdma_dev *fdev = fchan->fdev;
 353
 354         switch (direction) {
 355
 356         case DMA_DEV_TO_MEM:
 357                 fchan->cfg.req_ctrl &= ~FDMA_REQ_CTRL_WNR;
 358                 maxburst = fchan->scfg.src_maxburst;
 359                 width = fchan->scfg.src_addr_width;
 360                 addr = fchan->scfg.src_addr;
 361                 break;
 362
 363         case DMA_MEM_TO_DEV:
 364                 fchan->cfg.req_ctrl |= FDMA_REQ_CTRL_WNR;
 365                 maxburst = fchan->scfg.dst_maxburst;
 366                 width = fchan->scfg.dst_addr_width;
 367                 addr = fchan->scfg.dst_addr;
 368                 break;
 369
 370         default:
 371                 return -EINVAL;
 372         }
 373
 374         fchan->cfg.req_ctrl &= ~FDMA_REQ_CTRL_OPCODE_MASK;
 375
 376         switch (width) {
 377
 378         case DMA_SLAVE_BUSWIDTH_1_BYTE:
 379                 fchan->cfg.req_ctrl |= FDMA_REQ_CTRL_OPCODE_LD_ST1;
 380                 break;
 381
 382         case DMA_SLAVE_BUSWIDTH_2_BYTES:
 383                 fchan->cfg.req_ctrl |= FDMA_REQ_CTRL_OPCODE_LD_ST2;
 384                 break;
 385
 386         case DMA_SLAVE_BUSWIDTH_4_BYTES:
 387                 fchan->cfg.req_ctrl |= FDMA_REQ_CTRL_OPCODE_LD_ST4;
 388                 break;
 389
 390         case DMA_SLAVE_BUSWIDTH_8_BYTES:
 391                 fchan->cfg.req_ctrl |= FDMA_REQ_CTRL_OPCODE_LD_ST8;
 392                 break;
 393
 394         default:
 395                 return -EINVAL;
 396         }
 397
 398         fchan->cfg.req_ctrl &= ~FDMA_REQ_CTRL_NUM_OPS_MASK;
 399         fchan->cfg.req_ctrl |= FDMA_REQ_CTRL_NUM_OPS(maxburst-1);
 400         dreq_write(fchan, fchan->cfg.req_ctrl, FDMA_REQ_CTRL_OFST);
 401
 402         fchan->cfg.dev_addr = addr;
 403         fchan->cfg.dir = direction;
 404
 405         dev_dbg(fdev->dev, "chan:%d config_reqctrl:%#x req_ctrl:%#lx\n",
 406                 ch_id, addr, fchan->cfg.req_ctrl);
 407
 408         return 0;
 409 }
 410
 411 static void fill_hw_node(struct st_fdma_hw_node *hw_node,
 412                         struct st_fdma_chan *fchan,
 413                         enum dma_transfer_direction direction)
 414 {
 415         if (direction == DMA_MEM_TO_DEV) {
 416                 hw_node->control |= FDMA_NODE_CTRL_SRC_INCR;
 417                 hw_node->control |= FDMA_NODE_CTRL_DST_STATIC;
 418                 hw_node->daddr = fchan->cfg.dev_addr;
 419         } else {
 420                 hw_node->control |= FDMA_NODE_CTRL_SRC_STATIC;
 421                 hw_node->control |= FDMA_NODE_CTRL_DST_INCR;
 422                 hw_node->saddr = fchan->cfg.dev_addr;
 423         }
 424
 425         hw_node->generic.sstride = 0;
 426         hw_node->generic.dstride = 0;
 427 }
 428
 429 static inline struct st_fdma_chan *st_fdma_prep_common(struct dma_chan *chan,
 430                 size_t len, enum dma_transfer_direction direction)
 431 {
 432         struct st_fdma_chan *fchan;
 433
 434         if (!chan || !len)
 435                 return NULL;
 436
 437         fchan = to_st_fdma_chan(chan);
 438
 439         if (!is_slave_direction(direction)) {
 440                 dev_err(fchan->fdev->dev, "bad direction?\n");
 441                 return NULL;
 442         }
 443
 444         return fchan;
 445 }
 446
 447 static struct dma_async_tx_descriptor *st_fdma_prep_dma_cyclic(
 448                 struct dma_chan *chan, dma_addr_t buf_addr, size_t len,
 449                 size_t period_len, enum dma_transfer_direction direction,
 450                 unsigned long flags)
 451 {
 452         struct st_fdma_chan *fchan;
 453         struct st_fdma_desc *fdesc;
 454         int sg_len, i;
 455
 456         fchan = st_fdma_prep_common(chan, len, direction);
 457         if (!fchan)
 458                 return NULL;
 459
 460         if (!period_len)
 461                 return NULL;
 462
 463         if (config_reqctrl(fchan, direction)) {
 464                 dev_err(fchan->fdev->dev, "bad width or direction\n");
 465                 return NULL;
 466         }
 467
 468         /* the buffer length must be a multiple of period_len */
 469         if (len % period_len != 0) {
 470                 dev_err(fchan->fdev->dev, "len is not multiple of period\n");
 471                 return NULL;
 472         }
 473
 474         sg_len = len / period_len;
 475         fdesc = st_fdma_alloc_desc(fchan, sg_len);
 476         if (!fdesc) {
 477                 dev_err(fchan->fdev->dev, "no memory for desc\n");
 478                 return NULL;
 479         }
 480
 481         fdesc->iscyclic = true;
 482
 483         for (i = 0; i < sg_len; i++) {
 484                 struct st_fdma_hw_node *hw_node = fdesc->node[i].desc;
 485
 486                 hw_node->next = fdesc->node[(i + 1) % sg_len].pdesc;
 487
 488                 hw_node->control =
 489                         FDMA_NODE_CTRL_REQ_MAP_DREQ(fchan->dreq_line);
 490                 hw_node->control |= FDMA_NODE_CTRL_INT_EON;
 491
 492                 fill_hw_node(hw_node, fchan, direction);
 493
 494                 if (direction == DMA_MEM_TO_DEV)
 495                         hw_node->saddr = buf_addr + (i * period_len);
 496                 else
 497                         hw_node->daddr = buf_addr + (i * period_len);
 498
 499                 hw_node->nbytes = period_len;
 500                 hw_node->generic.length = period_len;
 501         }
 502
 503         return vchan_tx_prep(&fchan->vchan, &fdesc->vdesc, flags);
 504 }
 505
 506 static struct dma_async_tx_descriptor *st_fdma_prep_slave_sg(
 507                 struct dma_chan *chan, struct scatterlist *sgl,
 508                 unsigned int sg_len, enum dma_transfer_direction direction,
 509                 unsigned long flags, void *context)
 510 {
 511         struct st_fdma_chan *fchan;
 512         struct st_fdma_desc *fdesc;
 513         struct st_fdma_hw_node *hw_node;
 514         struct scatterlist *sg;
 515         int i;
 516
 517         fchan = st_fdma_prep_common(chan, sg_len, direction);
 518         if (!fchan)
 519                 return NULL;
 520
 521         if (!sgl)
 522                 return NULL;
 523
 524         fdesc = st_fdma_alloc_desc(fchan, sg_len);
 525         if (!fdesc) {
 526                 dev_err(fchan->fdev->dev, "no memory for desc\n");
 527                 return NULL;
 528         }
 529
 530         fdesc->iscyclic = false;
 531
 532         for_each_sg(sgl, sg, sg_len, i) {
 533                 hw_node = fdesc->node[i].desc;
 534
 535                 hw_node->next = fdesc->node[(i + 1) % sg_len].pdesc;
 536                 hw_node->control = FDMA_NODE_CTRL_REQ_MAP_DREQ(fchan->dreq_line);
 537
 538                 fill_hw_node(hw_node, fchan, direction);
 539
 540                 if (direction == DMA_MEM_TO_DEV)
 541                         hw_node->saddr = sg_dma_address(sg);
 542                 else
 543                         hw_node->daddr = sg_dma_address(sg);
 544
 545                 hw_node->nbytes = sg_dma_len(sg);
 546                 hw_node->generic.length = sg_dma_len(sg);
 547         }
 548
 549         /* interrupt at end of last node */
 550         hw_node->control |= FDMA_NODE_CTRL_INT_EON;
 551
 552         return vchan_tx_prep(&fchan->vchan, &fdesc->vdesc, flags);
 553 }
 554
 555 static size_t st_fdma_desc_residue(struct st_fdma_chan *fchan,
 556                                    struct virt_dma_desc *vdesc,
 557                                    bool in_progress)
 558 {
 559         struct st_fdma_desc *fdesc = fchan->fdesc;
 560         size_t residue = 0;
 561         dma_addr_t cur_addr = 0;
 562         int i;
 563
 564         if (in_progress) {
 565                 cur_addr = fchan_read(fchan, FDMA_CH_CMD_OFST);
 566                 cur_addr &= FDMA_CH_CMD_DATA_MASK;
 567         }
 568
 569         for (i = fchan->fdesc->n_nodes - 1 ; i >= 0; i--) {
 570                 if (cur_addr == fdesc->node[i].pdesc) {
 571                         residue += fnode_read(fchan, FDMA_CNTN_OFST);
 572                         break;
 573                 }
 574                 residue += fdesc->node[i].desc->nbytes;
 575         }
 576
 577         return residue;
 578 }
 579
 580 static enum dma_status st_fdma_tx_status(struct dma_chan *chan,
 581                                          dma_cookie_t cookie,
 582                                          struct dma_tx_state *txstate)
 583 {
 584         struct st_fdma_chan *fchan = to_st_fdma_chan(chan);
 585         struct virt_dma_desc *vd;
 586         enum dma_status ret;
 587         unsigned long flags;
 588
 589         ret = dma_cookie_status(chan, cookie, txstate);
 590         if (ret == DMA_COMPLETE || !txstate)
 591                 return ret;
 592
 593         spin_lock_irqsave(&fchan->vchan.lock, flags);
 594         vd = vchan_find_desc(&fchan->vchan, cookie);
 595         if (fchan->fdesc && cookie == fchan->fdesc->vdesc.tx.cookie)
 596                 txstate->residue = st_fdma_desc_residue(fchan, vd, true);
 597         else if (vd)
 598                 txstate->residue = st_fdma_desc_residue(fchan, vd, false);
 599         else
 600                 txstate->residue = 0;
 601
 602         spin_unlock_irqrestore(&fchan->vchan.lock, flags);
 603
 604         return ret;
 605 }
 606
 607 static void st_fdma_issue_pending(struct dma_chan *chan)
 608 {
 609         struct st_fdma_chan *fchan = to_st_fdma_chan(chan);
 610         unsigned long flags;
 611
 612         spin_lock_irqsave(&fchan->vchan.lock, flags);
 613
 614         if (vchan_issue_pending(&fchan->vchan) && !fchan->fdesc)
 615                 st_fdma_xfer_desc(fchan);
 616
 617         spin_unlock_irqrestore(&fchan->vchan.lock, flags);
 618 }
 619
 620 static int st_fdma_pause(struct dma_chan *chan)
 621 {
 622         unsigned long flags;
 623         struct st_fdma_chan *fchan = to_st_fdma_chan(chan);
 624         int ch_id = fchan->vchan.chan.chan_id;
 625         unsigned long cmd = FDMA_CMD_PAUSE(ch_id);
 626
 627         dev_dbg(fchan->fdev->dev, "pause chan:%d\n", ch_id);
 628
 629         spin_lock_irqsave(&fchan->vchan.lock, flags);
 630         if (fchan->fdesc)
 631                 fdma_write(fchan->fdev, cmd, FDMA_CMD_SET_OFST);
 632         spin_unlock_irqrestore(&fchan->vchan.lock, flags);
 633
 634         return 0;
 635 }
 636
 637 static int st_fdma_resume(struct dma_chan *chan)
 638 {
 639         unsigned long flags;
 640         unsigned long val;
 641         struct st_fdma_chan *fchan = to_st_fdma_chan(chan);
 642         int ch_id = fchan->vchan.chan.chan_id;
 643
 644         dev_dbg(fchan->fdev->dev, "resume chan:%d\n", ch_id);
 645
 646         spin_lock_irqsave(&fchan->vchan.lock, flags);
 647         if (fchan->fdesc) {
 648                 val = fchan_read(fchan, FDMA_CH_CMD_OFST);
 649                 val &= FDMA_CH_CMD_DATA_MASK;
 650                 fchan_write(fchan, val, FDMA_CH_CMD_OFST);
 651         }
 652         spin_unlock_irqrestore(&fchan->vchan.lock, flags);
 653
 654         return 0;
 655 }
 656
 657 static int st_fdma_terminate_all(struct dma_chan *chan)
 658 {
 659         unsigned long flags;
 660         LIST_HEAD(head);
 661         struct st_fdma_chan *fchan = to_st_fdma_chan(chan);
 662         int ch_id = fchan->vchan.chan.chan_id;
 663         unsigned long cmd = FDMA_CMD_PAUSE(ch_id);
 664
 665         dev_dbg(fchan->fdev->dev, "terminate chan:%d\n", ch_id);
 666
 667         spin_lock_irqsave(&fchan->vchan.lock, flags);
 668         fdma_write(fchan->fdev, cmd, FDMA_CMD_SET_OFST);
 669         fchan->fdesc = NULL;
 670         vchan_get_all_descriptors(&fchan->vchan, &head);
 671         spin_unlock_irqrestore(&fchan->vchan.lock, flags);
 672         vchan_dma_desc_free_list(&fchan->vchan, &head);
 673
 674         return 0;
 675 }
 676
 677 static int st_fdma_slave_config(struct dma_chan *chan,
 678                                 struct dma_slave_config *slave_cfg)
 679 {
 680         struct st_fdma_chan *fchan = to_st_fdma_chan(chan);
 681
 682         memcpy(&fchan->scfg, slave_cfg, sizeof(fchan->scfg));
 683         return 0;
 684 }
 685
 686 static const struct st_fdma_driverdata fdma_mpe31_stih407_11 = {
 687         .name = "STiH407",
 688         .id = 0,
 689 };
 690
 691 static const struct st_fdma_driverdata fdma_mpe31_stih407_12 = {
 692         .name = "STiH407",
 693         .id = 1,
 694 };
 695
 696 static const struct st_fdma_driverdata fdma_mpe31_stih407_13 = {
 697         .name = "STiH407",
 698         .id = 2,
 699 };
 700
 701 static const struct of_device_id st_fdma_match[] = {
 702         { .compatible = "st,stih407-fdma-mpe31-11"
 703           , .data = &fdma_mpe31_stih407_11 },
 704         { .compatible = "st,stih407-fdma-mpe31-12"
 705           , .data = &fdma_mpe31_stih407_12 },
 706         { .compatible = "st,stih407-fdma-mpe31-13"
 707           , .data = &fdma_mpe31_stih407_13 },
 708         {},
 709 };
 710 MODULE_DEVICE_TABLE(of, st_fdma_match);
 711
 712 static int st_fdma_parse_dt(struct platform_device *pdev,
 713                         const struct st_fdma_driverdata *drvdata,
 714                         struct st_fdma_dev *fdev)
 715 {
 716         snprintf(fdev->fw_name, FW_NAME_SIZE, "fdma_%s_%d.elf",
 717                 drvdata->name, drvdata->id);
 718
 719         return of_property_read_u32(pdev->dev.of_node, "dma-channels",
 720                                     &fdev->nr_channels);
 721 }
 722 #define FDMA_DMA_BUSWIDTHS      (BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) | \
 723                                  BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) | \
 724                                  BIT(DMA_SLAVE_BUSWIDTH_3_BYTES) | \
 725                                  BIT(DMA_SLAVE_BUSWIDTH_4_BYTES))
 726
 727 static void st_fdma_free(struct st_fdma_dev *fdev)
 728 {
 729         struct st_fdma_chan *fchan;
 730         int i;
 731
 732         for (i = 0; i < fdev->nr_channels; i++) {
 733                 fchan = &fdev->chans[i];
 734                 list_del(&fchan->vchan.chan.device_node);
 735                 tasklet_kill(&fchan->vchan.task);
 736         }
 737 }
 738
 739 static int st_fdma_probe(struct platform_device *pdev)
 740 {
 741         struct st_fdma_dev *fdev;
 742         const struct of_device_id *match;
 743         struct device_node *np = pdev->dev.of_node;
 744         const struct st_fdma_driverdata *drvdata;
 745         int ret, i;
 746
 747         match = of_match_device((st_fdma_match), &pdev->dev);
 748         if (!match || !match->data) {
 749                 dev_err(&pdev->dev, "No device match found\n");
 750                 return -ENODEV;
 751         }
 752
 753         drvdata = match->data;
 754
 755         fdev = devm_kzalloc(&pdev->dev, sizeof(*fdev), GFP_KERNEL);
 756         if (!fdev)
 757                 return -ENOMEM;
 758
 759         ret = st_fdma_parse_dt(pdev, drvdata, fdev);
 760         if (ret) {
 761                 dev_err(&pdev->dev, "unable to find platform data\n");
 762                 goto err;
 763         }
 764
 765         fdev->chans = devm_kcalloc(&pdev->dev, fdev->nr_channels,
 766                                    sizeof(struct st_fdma_chan), GFP_KERNEL);
 767         if (!fdev->chans)
 768                 return -ENOMEM;
 769
 770         fdev->dev = &pdev->dev;
 771         fdev->drvdata = drvdata;
 772         platform_set_drvdata(pdev, fdev);
 773
 774         fdev->irq = platform_get_irq(pdev, 0);
 775         if (fdev->irq < 0)
 776                 return -EINVAL;
 777
 778         ret = devm_request_irq(&pdev->dev, fdev->irq, st_fdma_irq_handler, 0,
 779                                dev_name(&pdev->dev), fdev);
 780         if (ret) {
 781                 dev_err(&pdev->dev, "Failed to request irq (%d)\n", ret);
 782                 goto err;
 783         }
 784
 785         fdev->slim_rproc = st_slim_rproc_alloc(pdev, fdev->fw_name);
 786         if (IS_ERR(fdev->slim_rproc)) {
 787                 ret = PTR_ERR(fdev->slim_rproc);
 788                 dev_err(&pdev->dev, "slim_rproc_alloc failed (%d)\n", ret);
 789                 goto err;
 790         }
 791
 792         /* Initialise list of FDMA channels */
 793         INIT_LIST_HEAD(&fdev->dma_device.channels);
 794         for (i = 0; i < fdev->nr_channels; i++) {
 795                 struct st_fdma_chan *fchan = &fdev->chans[i];
 796
 797                 fchan->fdev = fdev;
 798                 fchan->vchan.desc_free = st_fdma_free_desc;
 799                 vchan_init(&fchan->vchan, &fdev->dma_device);
 800         }
 801
 802         /* Initialise the FDMA dreq (reserve 0 & 31 for FDMA use) */
 803         fdev->dreq_mask = BIT(0) | BIT(31);
 804
 805         dma_cap_set(DMA_SLAVE, fdev->dma_device.cap_mask);
 806         dma_cap_set(DMA_CYCLIC, fdev->dma_device.cap_mask);
 807         dma_cap_set(DMA_MEMCPY, fdev->dma_device.cap_mask);
 808
 809         fdev->dma_device.dev = &pdev->dev;
 810         fdev->dma_device.device_alloc_chan_resources = st_fdma_alloc_chan_res;
 811         fdev->dma_device.device_free_chan_resources = st_fdma_free_chan_res;
 812         fdev->dma_device.device_prep_dma_cyclic = st_fdma_prep_dma_cyclic;
 813         fdev->dma_device.device_prep_slave_sg = st_fdma_prep_slave_sg;
 814         fdev->dma_device.device_prep_dma_memcpy = st_fdma_prep_dma_memcpy;
 815         fdev->dma_device.device_tx_status = st_fdma_tx_status;
 816         fdev->dma_device.device_issue_pending = st_fdma_issue_pending;
 817         fdev->dma_device.device_terminate_all = st_fdma_terminate_all;
 818         fdev->dma_device.device_config = st_fdma_slave_config;
 819         fdev->dma_device.device_pause = st_fdma_pause;
 820         fdev->dma_device.device_resume = st_fdma_resume;
 821
 822         fdev->dma_device.src_addr_widths = FDMA_DMA_BUSWIDTHS;
 823         fdev->dma_device.dst_addr_widths = FDMA_DMA_BUSWIDTHS;
 824         fdev->dma_device.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
 825         fdev->dma_device.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
 826
 827         ret = dmaenginem_async_device_register(&fdev->dma_device);
 828         if (ret) {
 829                 dev_err(&pdev->dev,
 830                         "Failed to register DMA device (%d)\n", ret);
 831                 goto err_rproc;
 832         }
 833
 834         ret = of_dma_controller_register(np, st_fdma_of_xlate, fdev);
 835         if (ret) {
 836                 dev_err(&pdev->dev,
 837                         "Failed to register controller (%d)\n", ret);
 838                 goto err_rproc;
 839         }
 840
 841         dev_info(&pdev->dev, "ST FDMA engine driver, irq:%d\n", fdev->irq);
 842
 843         return 0;
 844
 845 err_rproc:
 846         st_fdma_free(fdev);
 847         st_slim_rproc_put(fdev->slim_rproc);
 848 err:
 849         return ret;
 850 }
 851
 852 static int st_fdma_remove(struct platform_device *pdev)
 853 {
 854         struct st_fdma_dev *fdev = platform_get_drvdata(pdev);
 855
 856         devm_free_irq(&pdev->dev, fdev->irq, fdev);
 857         st_slim_rproc_put(fdev->slim_rproc);
 858         of_dma_controller_free(pdev->dev.of_node);
 859
 860         return 0;
 861 }
 862
 863 static struct platform_driver st_fdma_platform_driver = {
 864         .driver = {
 865                 .name = DRIVER_NAME,
 866                 .of_match_table = st_fdma_match,
 867         },
 868         .probe = st_fdma_probe,
 869         .remove = st_fdma_remove,
 870 };
 871 module_platform_driver(st_fdma_platform_driver);
 872
 873 MODULE_LICENSE("GPL v2");
 874 MODULE_DESCRIPTION("STMicroelectronics FDMA engine driver");
 875 MODULE_AUTHOR("Ludovic.barre <Ludovic.barre@st.com>");
 876 MODULE_AUTHOR("Peter Griffin <peter.griffin@linaro.org>");
 877 MODULE_ALIAS("platform: " DRIVER_NAME);