Lines Matching defs:schan
231 struct sprd_dma_chn *schan = to_sprd_dma_chan(c);
233 return container_of(schan, struct sprd_dma_dev, channels[c->chan_id]);
251 static void sprd_dma_chn_update(struct sprd_dma_chn *schan, u32 reg,
254 u32 orig = readl(schan->chn_base + reg);
258 writel(tmp, schan->chn_base + reg);
290 static void sprd_dma_set_uid(struct sprd_dma_chn *schan)
292 struct sprd_dma_dev *sdev = to_sprd_dma_dev(&schan->vc.chan);
293 u32 dev_id = schan->dev_id;
299 writel(schan->chn_num + 1, sdev->glb_base + uid_offset);
303 static void sprd_dma_unset_uid(struct sprd_dma_chn *schan)
305 struct sprd_dma_dev *sdev = to_sprd_dma_dev(&schan->vc.chan);
306 u32 dev_id = schan->dev_id;
316 static void sprd_dma_clear_int(struct sprd_dma_chn *schan)
318 sprd_dma_chn_update(schan, SPRD_DMA_CHN_INTC,
323 static void sprd_dma_enable_chn(struct sprd_dma_chn *schan)
325 sprd_dma_chn_update(schan, SPRD_DMA_CHN_CFG, SPRD_DMA_CHN_EN,
329 static void sprd_dma_disable_chn(struct sprd_dma_chn *schan)
331 sprd_dma_chn_update(schan, SPRD_DMA_CHN_CFG, SPRD_DMA_CHN_EN, 0);
334 static void sprd_dma_soft_request(struct sprd_dma_chn *schan)
336 sprd_dma_chn_update(schan, SPRD_DMA_CHN_REQ, SPRD_DMA_REQ_EN,
340 static void sprd_dma_pause_resume(struct sprd_dma_chn *schan, bool enable)
342 struct sprd_dma_dev *sdev = to_sprd_dma_dev(&schan->vc.chan);
346 sprd_dma_chn_update(schan, SPRD_DMA_CHN_PAUSE,
350 pause = readl(schan->chn_base + SPRD_DMA_CHN_PAUSE);
361 sprd_dma_chn_update(schan, SPRD_DMA_CHN_PAUSE,
366 static void sprd_dma_stop_and_disable(struct sprd_dma_chn *schan)
368 u32 cfg = readl(schan->chn_base + SPRD_DMA_CHN_CFG);
373 sprd_dma_pause_resume(schan, true);
374 sprd_dma_disable_chn(schan);
377 static unsigned long sprd_dma_get_src_addr(struct sprd_dma_chn *schan)
381 addr = readl(schan->chn_base + SPRD_DMA_CHN_SRC_ADDR);
382 addr_high = readl(schan->chn_base + SPRD_DMA_CHN_WARP_PTR) &
388 static unsigned long sprd_dma_get_dst_addr(struct sprd_dma_chn *schan)
392 addr = readl(schan->chn_base + SPRD_DMA_CHN_DES_ADDR);
393 addr_high = readl(schan->chn_base + SPRD_DMA_CHN_WARP_TO) &
399 static enum sprd_dma_int_type sprd_dma_get_int_type(struct sprd_dma_chn *schan)
401 struct sprd_dma_dev *sdev = to_sprd_dma_dev(&schan->vc.chan);
402 u32 intc_sts = readl(schan->chn_base + SPRD_DMA_CHN_INTC) &
427 static enum sprd_dma_req_mode sprd_dma_get_req_type(struct sprd_dma_chn *schan)
429 u32 frag_reg = readl(schan->chn_base + SPRD_DMA_CHN_FRG_LEN);
434 static int sprd_dma_set_2stage_config(struct sprd_dma_chn *schan)
436 struct sprd_dma_dev *sdev = to_sprd_dma_dev(&schan->vc.chan);
437 u32 val, chn = schan->chn_num + 1;
439 switch (schan->chn_mode) {
442 val |= BIT(schan->trg_mode - 1) << SPRD_DMA_GLB_TRG_OFFSET;
444 if (schan->int_type != SPRD_DMA_NO_INT)
452 val |= BIT(schan->trg_mode - 1) << SPRD_DMA_GLB_TRG_OFFSET;
454 if (schan->int_type != SPRD_DMA_NO_INT)
464 if (schan->int_type != SPRD_DMA_NO_INT)
474 if (schan->int_type != SPRD_DMA_NO_INT)
482 schan->chn_mode);
489 static void sprd_dma_set_pending(struct sprd_dma_chn *schan, bool enable)
491 struct sprd_dma_dev *sdev = to_sprd_dma_dev(&schan->vc.chan);
494 if (schan->dev_id == SPRD_DMA_SOFTWARE_UID)
498 req_id = schan->dev_id - 1;
511 static void sprd_dma_set_chn_config(struct sprd_dma_chn *schan,
516 writel(cfg->pause, schan->chn_base + SPRD_DMA_CHN_PAUSE);
517 writel(cfg->cfg, schan->chn_base + SPRD_DMA_CHN_CFG);
518 writel(cfg->intc, schan->chn_base + SPRD_DMA_CHN_INTC);
519 writel(cfg->src_addr, schan->chn_base + SPRD_DMA_CHN_SRC_ADDR);
520 writel(cfg->des_addr, schan->chn_base + SPRD_DMA_CHN_DES_ADDR);
521 writel(cfg->frg_len, schan->chn_base + SPRD_DMA_CHN_FRG_LEN);
522 writel(cfg->blk_len, schan->chn_base + SPRD_DMA_CHN_BLK_LEN);
523 writel(cfg->trsc_len, schan->chn_base + SPRD_DMA_CHN_TRSC_LEN);
524 writel(cfg->trsf_step, schan->chn_base + SPRD_DMA_CHN_TRSF_STEP);
525 writel(cfg->wrap_ptr, schan->chn_base + SPRD_DMA_CHN_WARP_PTR);
526 writel(cfg->wrap_to, schan->chn_base + SPRD_DMA_CHN_WARP_TO);
527 writel(cfg->llist_ptr, schan->chn_base + SPRD_DMA_CHN_LLIST_PTR);
528 writel(cfg->frg_step, schan->chn_base + SPRD_DMA_CHN_FRAG_STEP);
529 writel(cfg->src_blk_step, schan->chn_base + SPRD_DMA_CHN_SRC_BLK_STEP);
530 writel(cfg->des_blk_step, schan->chn_base + SPRD_DMA_CHN_DES_BLK_STEP);
531 writel(cfg->req, schan->chn_base + SPRD_DMA_CHN_REQ);
534 static void sprd_dma_start(struct sprd_dma_chn *schan)
536 struct virt_dma_desc *vd = vchan_next_desc(&schan->vc);
542 schan->cur_desc = to_sprd_dma_desc(vd);
548 if (schan->chn_mode && sprd_dma_set_2stage_config(schan))
555 sprd_dma_set_chn_config(schan, schan->cur_desc);
556 sprd_dma_set_uid(schan);
557 sprd_dma_set_pending(schan, true);
558 sprd_dma_enable_chn(schan);
560 if (schan->dev_id == SPRD_DMA_SOFTWARE_UID &&
561 schan->chn_mode != SPRD_DMA_DST_CHN0 &&
562 schan->chn_mode != SPRD_DMA_DST_CHN1)
563 sprd_dma_soft_request(schan);
566 static void sprd_dma_stop(struct sprd_dma_chn *schan)
568 sprd_dma_stop_and_disable(schan);
569 sprd_dma_set_pending(schan, false);
570 sprd_dma_unset_uid(schan);
571 sprd_dma_clear_int(schan);
572 schan->cur_desc = NULL;
592 struct sprd_dma_chn *schan;
602 schan = &sdev->channels[i];
604 spin_lock(&schan->vc.lock);
606 sdesc = schan->cur_desc;
608 spin_unlock(&schan->vc.lock);
612 int_type = sprd_dma_get_int_type(schan);
613 req_type = sprd_dma_get_req_type(schan);
614 sprd_dma_clear_int(schan);
617 cyclic = schan->linklist.phy_addr ? true : false;
626 schan->cur_desc = NULL;
627 sprd_dma_start(schan);
630 spin_unlock(&schan->vc.lock);
643 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
647 spin_lock_irqsave(&schan->vc.lock, flags);
648 if (schan->cur_desc)
649 cur_vd = &schan->cur_desc->vd;
651 sprd_dma_stop(schan);
652 spin_unlock_irqrestore(&schan->vc.lock, flags);
657 vchan_free_chan_resources(&schan->vc);
665 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
675 spin_lock_irqsave(&schan->vc.lock, flags);
676 vd = vchan_find_desc(&schan->vc, cookie);
689 } else if (schan->cur_desc && schan->cur_desc->vd.tx.cookie == cookie) {
690 struct sprd_dma_desc *sdesc = schan->cur_desc;
693 pos = sprd_dma_get_dst_addr(schan);
695 pos = sprd_dma_get_src_addr(schan);
699 spin_unlock_irqrestore(&schan->vc.lock, flags);
707 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
710 spin_lock_irqsave(&schan->vc.lock, flags);
711 if (vchan_issue_pending(&schan->vc) && !schan->cur_desc)
712 sprd_dma_start(schan);
713 spin_unlock_irqrestore(&schan->vc.lock, flags);
753 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
754 enum sprd_dma_chn_mode chn_mode = schan->chn_mode;
831 temp |= schan->linklist.wrap_addr ?
844 if (schan->linklist.phy_addr) {
856 llist_ptr = schan->linklist.phy_addr + temp;
861 if (schan->linklist.wrap_addr) {
862 hw->wrap_ptr |= schan->linklist.wrap_addr &
883 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
886 if (!schan->linklist.virt_addr)
889 hw = (struct sprd_dma_chn_hw *)(schan->linklist.virt_addr +
900 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
948 return vchan_tx_prep(&schan->vc, &sdesc->vd, flags);
956 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
957 struct dma_slave_config *slave_cfg = &schan->slave_cfg;
972 schan->linklist.phy_addr = ll_cfg->phy_addr;
973 schan->linklist.virt_addr = ll_cfg->virt_addr;
974 schan->linklist.wrap_addr = ll_cfg->wrap_addr;
976 schan->linklist.phy_addr = 0;
977 schan->linklist.virt_addr = 0;
978 schan->linklist.wrap_addr = 0;
985 schan->chn_mode =
987 schan->trg_mode =
989 schan->int_type = flags & SPRD_DMA_INT_TYPE_MASK;
1036 return vchan_tx_prep(&schan->vc, &sdesc->vd, flags);
1042 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
1043 struct dma_slave_config *slave_cfg = &schan->slave_cfg;
1051 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
1054 spin_lock_irqsave(&schan->vc.lock, flags);
1055 sprd_dma_pause_resume(schan, true);
1056 spin_unlock_irqrestore(&schan->vc.lock, flags);
1063 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
1066 spin_lock_irqsave(&schan->vc.lock, flags);
1067 sprd_dma_pause_resume(schan, false);
1068 spin_unlock_irqrestore(&schan->vc.lock, flags);
1075 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
1080 spin_lock_irqsave(&schan->vc.lock, flags);
1081 if (schan->cur_desc)
1082 cur_vd = &schan->cur_desc->vd;
1084 sprd_dma_stop(schan);
1086 vchan_get_all_descriptors(&schan->vc, &head);
1087 spin_unlock_irqrestore(&schan->vc.lock, flags);
1092 vchan_dma_desc_free_list(&schan->vc, &head);
1105 struct sprd_dma_chn *schan = to_sprd_dma_chan(chan);
1108 schan->dev_id = slave_id;