History

dmaengine: remove s3c24xx driver

The s3c24xx platform was removed and this driver is no longer needed.

Arnd Bergmann committed 4 years ago

Commit a7ddf741 parent 1fa774f4 files · +0 −1489Browse files

Unified · Split

4 files
  1. drivers/dma/Kconfig +0 −12
  2. drivers/dma/Makefile +0 −1
  3. drivers/dma/s3c24xx-dma.c +0 −1428
  4. include/linux/platform_data/dma-s3c24xx.h +0 −48
drivers/dma/Kconfig+0−12
@@ -610,18 +610,6 @@ config SPRD_DMA · 609 unmodified lines
610610 help
611611 Enable support for the on-chip DMA controller on Spreadtrum platform.
612612
613−config S3C24XX_DMAC
614− bool "Samsung S3C24XX DMA support"
615− depends on ARCH_S3C24XX || COMPILE_TEST
616− select DMA_ENGINE
617− select DMA_VIRTUAL_CHANNELS
618− help
619− Support for the Samsung S3C24XX DMA controller driver. The
620− DMA controller is having multiple DMA channels which can be
621− configured for different peripherals like audio, UART, SPI.
622− The DMA controller can transfer data from memory to peripheral,
623− periphal to memory, periphal to periphal and memory to memory.
624−
625613 config TXX9_DMAC
626614 tristate "Toshiba TXx9 SoC DMA support"
627615 depends on MACH_TX49XX
drivers/dma/Makefile+0−1
@@ -70,7 +70,6 @@ obj-$(CONFIG_STM32_DMA) += stm32-dma.o · 69 unmodified lines
7070 obj-$(CONFIG_STM32_DMAMUX) += stm32-dmamux.o
7171 obj-$(CONFIG_STM32_MDMA) += stm32-mdma.o
7272 obj-$(CONFIG_SPRD_DMA) += sprd-dma.o
73−obj-$(CONFIG_S3C24XX_DMAC) += s3c24xx-dma.o
7473 obj-$(CONFIG_TXX9_DMAC) += txx9dmac.o
7574 obj-$(CONFIG_TEGRA186_GPC_DMA) += tegra186-gpc-dma.o
7675 obj-$(CONFIG_TEGRA20_APB_DMA) += tegra20-apb-dma.o
drivers/dma/s3c24xx-dma.c+0−1428
@@ -1,1428 +0,0 @@
1−// SPDX-License-Identifier: GPL-2.0-or-later
2−/*
3− * S3C24XX DMA handling
4− *
5− * Copyright (c) 2013 Heiko Stuebner <heiko@sntech.de>
6− *
7− * based on amba-pl08x.c
8− *
9− * Copyright (c) 2006 ARM Ltd.
10− * Copyright (c) 2010 ST-Ericsson SA
11− *
12− * Author: Peter Pearse <peter.pearse@arm.com>
13− * Author: Linus Walleij <linus.walleij@stericsson.com>
14− *
15− * The DMA controllers in S3C24XX SoCs have a varying number of DMA signals
16− * that can be routed to any of the 4 to 8 hardware-channels.
17− *
18− * Therefore on these DMA controllers the number of channels
19− * and the number of incoming DMA signals are two totally different things.
20− * It is usually not possible to theoretically handle all physical signals,
21− * so a multiplexing scheme with possible denial of use is necessary.
22− *
23− * Open items:
24− * - bursts
25− */
26−
27−#include <linux/platform_device.h>
28−#include <linux/types.h>
29−#include <linux/dmaengine.h>
30−#include <linux/dma-mapping.h>
31−#include <linux/interrupt.h>
32−#include <linux/clk.h>
33−#include <linux/module.h>
34−#include <linux/mod_devicetable.h>
35−#include <linux/slab.h>
36−#include <linux/platform_data/dma-s3c24xx.h>
37−
38−#include "dmaengine.h"
39−#include "virt-dma.h"
40−
41−#define MAX_DMA_CHANNELS 8
42−
43−#define S3C24XX_DISRC 0x00
44−#define S3C24XX_DISRCC 0x04
45−#define S3C24XX_DISRCC_INC_INCREMENT 0
46−#define S3C24XX_DISRCC_INC_FIXED BIT(0)
47−#define S3C24XX_DISRCC_LOC_AHB 0
48−#define S3C24XX_DISRCC_LOC_APB BIT(1)
49−
50−#define S3C24XX_DIDST 0x08
51−#define S3C24XX_DIDSTC 0x0c
52−#define S3C24XX_DIDSTC_INC_INCREMENT 0
53−#define S3C24XX_DIDSTC_INC_FIXED BIT(0)
54−#define S3C24XX_DIDSTC_LOC_AHB 0
55−#define S3C24XX_DIDSTC_LOC_APB BIT(1)
56−#define S3C24XX_DIDSTC_INT_TC0 0
57−#define S3C24XX_DIDSTC_INT_RELOAD BIT(2)
58−
59−#define S3C24XX_DCON 0x10
60−
61−#define S3C24XX_DCON_TC_MASK 0xfffff
62−#define S3C24XX_DCON_DSZ_BYTE (0 << 20)
63−#define S3C24XX_DCON_DSZ_HALFWORD (1 << 20)
64−#define S3C24XX_DCON_DSZ_WORD (2 << 20)
65−#define S3C24XX_DCON_DSZ_MASK (3 << 20)
66−#define S3C24XX_DCON_DSZ_SHIFT 20
67−#define S3C24XX_DCON_AUTORELOAD 0
68−#define S3C24XX_DCON_NORELOAD BIT(22)
69−#define S3C24XX_DCON_HWTRIG BIT(23)
70−#define S3C24XX_DCON_HWSRC_SHIFT 24
71−#define S3C24XX_DCON_SERV_SINGLE 0
72−#define S3C24XX_DCON_SERV_WHOLE BIT(27)
73−#define S3C24XX_DCON_TSZ_UNIT 0
74−#define S3C24XX_DCON_TSZ_BURST4 BIT(28)
75−#define S3C24XX_DCON_INT BIT(29)
76−#define S3C24XX_DCON_SYNC_PCLK 0
77−#define S3C24XX_DCON_SYNC_HCLK BIT(30)
78−#define S3C24XX_DCON_DEMAND 0
79−#define S3C24XX_DCON_HANDSHAKE BIT(31)
80−
81−#define S3C24XX_DSTAT 0x14
82−#define S3C24XX_DSTAT_STAT_BUSY BIT(20)
83−#define S3C24XX_DSTAT_CURRTC_MASK 0xfffff
84−
85−#define S3C24XX_DMASKTRIG 0x20
86−#define S3C24XX_DMASKTRIG_SWTRIG BIT(0)
87−#define S3C24XX_DMASKTRIG_ON BIT(1)
88−#define S3C24XX_DMASKTRIG_STOP BIT(2)
89−
90−#define S3C24XX_DMAREQSEL 0x24
91−#define S3C24XX_DMAREQSEL_HW BIT(0)
92−
93−/*
94− * S3C2410, S3C2440 and S3C2442 SoCs cannot select any physical channel
95− * for a DMA source. Instead only specific channels are valid.
96− * All of these SoCs have 4 physical channels and the number of request
97− * source bits is 3. Additionally we also need 1 bit to mark the channel
98− * as valid.
99− * Therefore we separate the chansel element of the channel data into 4
100− * parts of 4 bits each, to hold the information if the channel is valid
101− * and the hw request source to use.
102− *
103− * Example:
104− * SDI is valid on channels 0, 2 and 3 - with varying hw request sources.
105− * For it the chansel field would look like
106− *
107− * ((BIT(3) | 1) << 3 * 4) | // channel 3, with request source 1
108− * ((BIT(3) | 2) << 2 * 4) | // channel 2, with request source 2
109− * ((BIT(3) | 2) << 0 * 4) // channel 0, with request source 2
110− */
111−#define S3C24XX_CHANSEL_WIDTH 4
112−#define S3C24XX_CHANSEL_VALID BIT(3)
113−#define S3C24XX_CHANSEL_REQ_MASK 7
114−
115−/*
116− * struct soc_data - vendor-specific config parameters for individual SoCs
117− * @stride: spacing between the registers of each channel
118− * @has_reqsel: does the controller use the newer requestselection mechanism
119− * @has_clocks: are controllable dma-clocks present
120− */
121−struct soc_data {
122− int stride;
123− bool has_reqsel;
124− bool has_clocks;
125−};
126−
127−/*
128− * enum s3c24xx_dma_chan_state - holds the virtual channel states
129− * @S3C24XX_DMA_CHAN_IDLE: the channel is idle
130− * @S3C24XX_DMA_CHAN_RUNNING: the channel has allocated a physical transport
131− * channel and is running a transfer on it
132− * @S3C24XX_DMA_CHAN_WAITING: the channel is waiting for a physical transport
133− * channel to become available (only pertains to memcpy channels)
134− */
135−enum s3c24xx_dma_chan_state {
136− S3C24XX_DMA_CHAN_IDLE,
137− S3C24XX_DMA_CHAN_RUNNING,
138− S3C24XX_DMA_CHAN_WAITING,
139−};
140−
141−/*
142− * struct s3c24xx_sg - structure containing data per sg
143− * @src_addr: src address of sg
144− * @dst_addr: dst address of sg
145− * @len: transfer len in bytes
146− * @node: node for txd's dsg_list
147− */
148−struct s3c24xx_sg {
149− dma_addr_t src_addr;
150− dma_addr_t dst_addr;
151− size_t len;
152− struct list_head node;
153−};
154−
155−/*
156− * struct s3c24xx_txd - wrapper for struct dma_async_tx_descriptor
157− * @vd: virtual DMA descriptor
158− * @dsg_list: list of children sg's
159− * @at: sg currently being transfered
160− * @width: transfer width
161− * @disrcc: value for source control register
162− * @didstc: value for destination control register
163− * @dcon: base value for dcon register
164− * @cyclic: indicate cyclic transfer
165− */
166−struct s3c24xx_txd {
167− struct virt_dma_desc vd;
168− struct list_head dsg_list;
169− struct list_head *at;
170− u8 width;
171− u32 disrcc;
172− u32 didstc;
173− u32 dcon;
174− bool cyclic;
175−};
176−
177−struct s3c24xx_dma_chan;
178−
179−/*
180− * struct s3c24xx_dma_phy - holder for the physical channels
181− * @id: physical index to this channel
182− * @valid: does the channel have all required elements
183− * @base: virtual memory base (remapped) for the this channel
184− * @irq: interrupt for this channel
185− * @clk: clock for this channel
186− * @lock: a lock to use when altering an instance of this struct
187− * @serving: virtual channel currently being served by this physicalchannel
188− * @host: a pointer to the host (internal use)
189− */
190−struct s3c24xx_dma_phy {
191− unsigned int id;
192− bool valid;
193− void __iomem *base;
194− int irq;
195− struct clk *clk;
196− spinlock_t lock;
197− struct s3c24xx_dma_chan *serving;
198− struct s3c24xx_dma_engine *host;
199−};
200−
201−/*
202− * struct s3c24xx_dma_chan - this structure wraps a DMA ENGINE channel
203− * @id: the id of the channel
204− * @name: name of the channel
205− * @vc: wrapped virtual channel
206− * @phy: the physical channel utilized by this channel, if there is one
207− * @runtime_addr: address for RX/TX according to the runtime config
208− * @at: active transaction on this channel
209− * @lock: a lock for this channel data
210− * @host: a pointer to the host (internal use)
211− * @state: whether the channel is idle, running etc
212− * @slave: whether this channel is a device (slave) or for memcpy
213− */
214−struct s3c24xx_dma_chan {
215− int id;
216− const char *name;
217− struct virt_dma_chan vc;
218− struct s3c24xx_dma_phy *phy;
219− struct dma_slave_config cfg;
220− struct s3c24xx_txd *at;
221− struct s3c24xx_dma_engine *host;
222− enum s3c24xx_dma_chan_state state;
223− bool slave;
224−};
225−
226−/*
227− * struct s3c24xx_dma_engine - the local state holder for the S3C24XX
228− * @pdev: the corresponding platform device
229− * @pdata: platform data passed in from the platform/machine
230− * @base: virtual memory base (remapped)
231− * @slave: slave engine for this instance
232− * @memcpy: memcpy engine for this instance
233− * @phy_chans: array of data for the physical channels
234− */
235−struct s3c24xx_dma_engine {
236− struct platform_device *pdev;
237− const struct s3c24xx_dma_platdata *pdata;
238− struct soc_data *sdata;
239− void __iomem *base;
240− struct dma_device slave;
241− struct dma_device memcpy;
242− struct s3c24xx_dma_phy *phy_chans;
243−};
244−
245−/*
246− * Physical channel handling
247− */
248−
249−/*
250− * Check whether a certain channel is busy or not.
251− */
252−static int s3c24xx_dma_phy_busy(struct s3c24xx_dma_phy *phy)
253−{
254− unsigned int val = readl(phy->base + S3C24XX_DSTAT);
255− return val & S3C24XX_DSTAT_STAT_BUSY;
256−}
257−
258−static bool s3c24xx_dma_phy_valid(struct s3c24xx_dma_chan *s3cchan,
259− struct s3c24xx_dma_phy *phy)
260−{
261− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
262− const struct s3c24xx_dma_platdata *pdata = s3cdma->pdata;
263− struct s3c24xx_dma_channel *cdata = &pdata->channels[s3cchan->id];
264− int phyvalid;
265−
266− /* every phy is valid for memcopy channels */
267− if (!s3cchan->slave)
268− return true;
269−
270− /* On newer variants all phys can be used for all virtual channels */
271− if (s3cdma->sdata->has_reqsel)
272− return true;
273−
274− phyvalid = (cdata->chansel >> (phy->id * S3C24XX_CHANSEL_WIDTH));
275− return (phyvalid & S3C24XX_CHANSEL_VALID) ? true : false;
276−}
277−
278−/*
279− * Allocate a physical channel for a virtual channel
280− *
281− * Try to locate a physical channel to be used for this transfer. If all
282− * are taken return NULL and the requester will have to cope by using
283− * some fallback PIO mode or retrying later.
284− */
285−static
286−struct s3c24xx_dma_phy *s3c24xx_dma_get_phy(struct s3c24xx_dma_chan *s3cchan)
287−{
288− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
289− struct s3c24xx_dma_phy *phy = NULL;
290− unsigned long flags;
291− int i;
292− int ret;
293−
294− for (i = 0; i < s3cdma->pdata->num_phy_channels; i++) {
295− phy = &s3cdma->phy_chans[i];
296−
297− if (!phy->valid)
298− continue;
299−
300− if (!s3c24xx_dma_phy_valid(s3cchan, phy))
301− continue;
302−
303− spin_lock_irqsave(&phy->lock, flags);
304−
305− if (!phy->serving) {
306− phy->serving = s3cchan;
307− spin_unlock_irqrestore(&phy->lock, flags);
308− break;
309− }
310−
311− spin_unlock_irqrestore(&phy->lock, flags);
312− }
313−
314− /* No physical channel available, cope with it */
315− if (i == s3cdma->pdata->num_phy_channels) {
316− dev_warn(&s3cdma->pdev->dev, "no phy channel available\n");
317− return NULL;
318− }
319−
320− /* start the phy clock */
321− if (s3cdma->sdata->has_clocks) {
322− ret = clk_enable(phy->clk);
323− if (ret) {
324− dev_err(&s3cdma->pdev->dev, "could not enable clock for channel %d, err %d\n",
325− phy->id, ret);
326− phy->serving = NULL;
327− return NULL;
328− }
329− }
330−
331− return phy;
332−}
333−
334−/*
335− * Mark the physical channel as free.
336− *
337− * This drops the link between the physical and virtual channel.
338− */
339−static inline void s3c24xx_dma_put_phy(struct s3c24xx_dma_phy *phy)
340−{
341− struct s3c24xx_dma_engine *s3cdma = phy->host;
342−
343− if (s3cdma->sdata->has_clocks)
344− clk_disable(phy->clk);
345−
346− phy->serving = NULL;
347−}
348−
349−/*
350− * Stops the channel by writing the stop bit.
351− * This should not be used for an on-going transfer, but as a method of
352− * shutting down a channel (eg, when it's no longer used) or terminating a
353− * transfer.
354− */
355−static void s3c24xx_dma_terminate_phy(struct s3c24xx_dma_phy *phy)
356−{
357− writel(S3C24XX_DMASKTRIG_STOP, phy->base + S3C24XX_DMASKTRIG);
358−}
359−
360−/*
361− * Virtual channel handling
362− */
363−
364−static inline
365−struct s3c24xx_dma_chan *to_s3c24xx_dma_chan(struct dma_chan *chan)
366−{
367− return container_of(chan, struct s3c24xx_dma_chan, vc.chan);
368−}
369−
370−static u32 s3c24xx_dma_getbytes_chan(struct s3c24xx_dma_chan *s3cchan)
371−{
372− struct s3c24xx_dma_phy *phy = s3cchan->phy;
373− struct s3c24xx_txd *txd = s3cchan->at;
374− u32 tc = readl(phy->base + S3C24XX_DSTAT) & S3C24XX_DSTAT_CURRTC_MASK;
375−
376− return tc * txd->width;
377−}
378−
379−static int s3c24xx_dma_set_runtime_config(struct dma_chan *chan,
380− struct dma_slave_config *config)
381−{
382− struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
383− unsigned long flags;
384− int ret = 0;
385−
386− /* Reject definitely invalid configurations */
387− if (config->src_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES ||
388− config->dst_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES)
389− return -EINVAL;
390−
391− spin_lock_irqsave(&s3cchan->vc.lock, flags);
392−
393− if (!s3cchan->slave) {
394− ret = -EINVAL;
395− goto out;
396− }
397−
398− s3cchan->cfg = *config;
399−
400−out:
401− spin_unlock_irqrestore(&s3cchan->vc.lock, flags);
402− return ret;
403−}
404−
405−/*
406− * Transfer handling
407− */
408−
409−static inline
410−struct s3c24xx_txd *to_s3c24xx_txd(struct dma_async_tx_descriptor *tx)
411−{
412− return container_of(tx, struct s3c24xx_txd, vd.tx);
413−}
414−
415−static struct s3c24xx_txd *s3c24xx_dma_get_txd(void)
416−{
417− struct s3c24xx_txd *txd = kzalloc(sizeof(*txd), GFP_NOWAIT);
418−
419− if (txd) {
420− INIT_LIST_HEAD(&txd->dsg_list);
421− txd->dcon = S3C24XX_DCON_INT | S3C24XX_DCON_NORELOAD;
422− }
423−
424− return txd;
425−}
426−
427−static void s3c24xx_dma_free_txd(struct s3c24xx_txd *txd)
428−{
429− struct s3c24xx_sg *dsg, *_dsg;
430−
431− list_for_each_entry_safe(dsg, _dsg, &txd->dsg_list, node) {
432− list_del(&dsg->node);
433− kfree(dsg);
434− }
435−
436− kfree(txd);
437−}
438−
439−static void s3c24xx_dma_start_next_sg(struct s3c24xx_dma_chan *s3cchan,
440− struct s3c24xx_txd *txd)
441−{
442− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
443− struct s3c24xx_dma_phy *phy = s3cchan->phy;
444− const struct s3c24xx_dma_platdata *pdata = s3cdma->pdata;
445− struct s3c24xx_sg *dsg = list_entry(txd->at, struct s3c24xx_sg, node);
446− u32 dcon = txd->dcon;
447− u32 val;
448−
449− /* transfer-size and -count from len and width */
450− switch (txd->width) {
451− case 1:
452− dcon |= S3C24XX_DCON_DSZ_BYTE | dsg->len;
453− break;
454− case 2:
455− dcon |= S3C24XX_DCON_DSZ_HALFWORD | (dsg->len / 2);
456− break;
457− case 4:
458− dcon |= S3C24XX_DCON_DSZ_WORD | (dsg->len / 4);
459− break;
460− }
461−
462− if (s3cchan->slave) {
463− struct s3c24xx_dma_channel *cdata =
464− &pdata->channels[s3cchan->id];
465−
466− if (s3cdma->sdata->has_reqsel) {
467− writel_relaxed((cdata->chansel << 1) |
468− S3C24XX_DMAREQSEL_HW,
469− phy->base + S3C24XX_DMAREQSEL);
470− } else {
471− int csel = cdata->chansel >> (phy->id *
472− S3C24XX_CHANSEL_WIDTH);
473−
474− csel &= S3C24XX_CHANSEL_REQ_MASK;
475− dcon |= csel << S3C24XX_DCON_HWSRC_SHIFT;
476− dcon |= S3C24XX_DCON_HWTRIG;
477− }
478− } else {
479− if (s3cdma->sdata->has_reqsel)
480− writel_relaxed(0, phy->base + S3C24XX_DMAREQSEL);
481− }
482−
483− writel_relaxed(dsg->src_addr, phy->base + S3C24XX_DISRC);
484− writel_relaxed(txd->disrcc, phy->base + S3C24XX_DISRCC);
485− writel_relaxed(dsg->dst_addr, phy->base + S3C24XX_DIDST);
486− writel_relaxed(txd->didstc, phy->base + S3C24XX_DIDSTC);
487− writel_relaxed(dcon, phy->base + S3C24XX_DCON);
488−
489− val = readl_relaxed(phy->base + S3C24XX_DMASKTRIG);
490− val &= ~S3C24XX_DMASKTRIG_STOP;
491− val |= S3C24XX_DMASKTRIG_ON;
492−
493− /* trigger the dma operation for memcpy transfers */
494− if (!s3cchan->slave)
495− val |= S3C24XX_DMASKTRIG_SWTRIG;
496−
497− writel(val, phy->base + S3C24XX_DMASKTRIG);
498−}
499−
500−/*
501− * Set the initial DMA register values and start first sg.
502− */
503−static void s3c24xx_dma_start_next_txd(struct s3c24xx_dma_chan *s3cchan)
504−{
505− struct s3c24xx_dma_phy *phy = s3cchan->phy;
506− struct virt_dma_desc *vd = vchan_next_desc(&s3cchan->vc);
507− struct s3c24xx_txd *txd = to_s3c24xx_txd(&vd->tx);
508−
509− list_del(&txd->vd.node);
510−
511− s3cchan->at = txd;
512−
513− /* Wait for channel inactive */
514− while (s3c24xx_dma_phy_busy(phy))
515− cpu_relax();
516−
517− /* point to the first element of the sg list */
518− txd->at = txd->dsg_list.next;
519− s3c24xx_dma_start_next_sg(s3cchan, txd);
520−}
521−
522−/*
523− * Try to allocate a physical channel. When successful, assign it to
524− * this virtual channel, and initiate the next descriptor. The
525− * virtual channel lock must be held at this point.
526− */
527−static void s3c24xx_dma_phy_alloc_and_start(struct s3c24xx_dma_chan *s3cchan)
528−{
529− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
530− struct s3c24xx_dma_phy *phy;
531−
532− phy = s3c24xx_dma_get_phy(s3cchan);
533− if (!phy) {
534− dev_dbg(&s3cdma->pdev->dev, "no physical channel available for xfer on %s\n",
535− s3cchan->name);
536− s3cchan->state = S3C24XX_DMA_CHAN_WAITING;
537− return;
538− }
539−
540− dev_dbg(&s3cdma->pdev->dev, "allocated physical channel %d for xfer on %s\n",
541− phy->id, s3cchan->name);
542−
543− s3cchan->phy = phy;
544− s3cchan->state = S3C24XX_DMA_CHAN_RUNNING;
545−
546− s3c24xx_dma_start_next_txd(s3cchan);
547−}
548−
549−static void s3c24xx_dma_phy_reassign_start(struct s3c24xx_dma_phy *phy,
550− struct s3c24xx_dma_chan *s3cchan)
551−{
552− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
553−
554− dev_dbg(&s3cdma->pdev->dev, "reassigned physical channel %d for xfer on %s\n",
555− phy->id, s3cchan->name);
556−
557− /*
558− * We do this without taking the lock; we're really only concerned
559− * about whether this pointer is NULL or not, and we're guaranteed
560− * that this will only be called when it _already_ is non-NULL.
561− */
562− phy->serving = s3cchan;
563− s3cchan->phy = phy;
564− s3cchan->state = S3C24XX_DMA_CHAN_RUNNING;
565− s3c24xx_dma_start_next_txd(s3cchan);
566−}
567−
568−/*
569− * Free a physical DMA channel, potentially reallocating it to another
570− * virtual channel if we have any pending.
571− */
572−static void s3c24xx_dma_phy_free(struct s3c24xx_dma_chan *s3cchan)
573−{
574− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
575− struct s3c24xx_dma_chan *p, *next;
576−
577−retry:
578− next = NULL;
579−
580− /* Find a waiting virtual channel for the next transfer. */
581− list_for_each_entry(p, &s3cdma->memcpy.channels, vc.chan.device_node)
582− if (p->state == S3C24XX_DMA_CHAN_WAITING) {
583− next = p;
584− break;
585− }
586−
587− if (!next) {
588− list_for_each_entry(p, &s3cdma->slave.channels,
589− vc.chan.device_node)
590− if (p->state == S3C24XX_DMA_CHAN_WAITING &&
591− s3c24xx_dma_phy_valid(p, s3cchan->phy)) {
592− next = p;
593− break;
594− }
595− }
596−
597− /* Ensure that the physical channel is stopped */
598− s3c24xx_dma_terminate_phy(s3cchan->phy);
599−
600− if (next) {
601− bool success;
602−
603− /*
604− * Eww. We know this isn't going to deadlock
605− * but lockdep probably doesn't.
606− */
607− spin_lock(&next->vc.lock);
608− /* Re-check the state now that we have the lock */
609− success = next->state == S3C24XX_DMA_CHAN_WAITING;
610− if (success)
611− s3c24xx_dma_phy_reassign_start(s3cchan->phy, next);
612− spin_unlock(&next->vc.lock);
613−
614− /* If the state changed, try to find another channel */
615− if (!success)
616− goto retry;
617− } else {
618− /* No more jobs, so free up the physical channel */
619− s3c24xx_dma_put_phy(s3cchan->phy);
620− }
621−
622− s3cchan->phy = NULL;
623− s3cchan->state = S3C24XX_DMA_CHAN_IDLE;
624−}
625−
626−static void s3c24xx_dma_desc_free(struct virt_dma_desc *vd)
627−{
628− struct s3c24xx_txd *txd = to_s3c24xx_txd(&vd->tx);
629− struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(vd->tx.chan);
630−
631− if (!s3cchan->slave)
632− dma_descriptor_unmap(&vd->tx);
633−
634− s3c24xx_dma_free_txd(txd);
635−}
636−
637−static irqreturn_t s3c24xx_dma_irq(int irq, void *data)
638−{
639− struct s3c24xx_dma_phy *phy = data;
640− struct s3c24xx_dma_chan *s3cchan = phy->serving;
641− struct s3c24xx_txd *txd;
642−
643− dev_dbg(&phy->host->pdev->dev, "interrupt on channel %d\n", phy->id);
644−
645− /*
646− * Interrupts happen to notify the completion of a transfer and the
647− * channel should have moved into its stop state already on its own.
648− * Therefore interrupts on channels not bound to a virtual channel
649− * should never happen. Nevertheless send a terminate command to the
650− * channel if the unlikely case happens.
651− */
652− if (unlikely(!s3cchan)) {
653− dev_err(&phy->host->pdev->dev, "interrupt on unused channel %d\n",
654− phy->id);
655−
656− s3c24xx_dma_terminate_phy(phy);
657−
658− return IRQ_HANDLED;
659− }
660−
661− spin_lock(&s3cchan->vc.lock);
662− txd = s3cchan->at;
663− if (txd) {
664− /* when more sg's are in this txd, start the next one */
665− if (!list_is_last(txd->at, &txd->dsg_list)) {
666− txd->at = txd->at->next;
667− if (txd->cyclic)
668− vchan_cyclic_callback(&txd->vd);
669− s3c24xx_dma_start_next_sg(s3cchan, txd);
670− } else if (!txd->cyclic) {
671− s3cchan->at = NULL;
672− vchan_cookie_complete(&txd->vd);
673−
674− /*
675− * And start the next descriptor (if any),
676− * otherwise free this channel.
677− */
678− if (vchan_next_desc(&s3cchan->vc))
679− s3c24xx_dma_start_next_txd(s3cchan);
680− else
681− s3c24xx_dma_phy_free(s3cchan);
682− } else {
683− vchan_cyclic_callback(&txd->vd);
684−
685− /* Cyclic: reset at beginning */
686− txd->at = txd->dsg_list.next;
687− s3c24xx_dma_start_next_sg(s3cchan, txd);
688− }
689− }
690− spin_unlock(&s3cchan->vc.lock);
691−
692− return IRQ_HANDLED;
693−}
694−
695−/*
696− * The DMA ENGINE API
697− */
698−
699−static int s3c24xx_dma_terminate_all(struct dma_chan *chan)
700−{
701− struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
702− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
703− LIST_HEAD(head);
704− unsigned long flags;
705− int ret;
706−
707− spin_lock_irqsave(&s3cchan->vc.lock, flags);
708−
709− if (!s3cchan->phy && !s3cchan->at) {
710− dev_err(&s3cdma->pdev->dev, "trying to terminate already stopped channel %d\n",
711− s3cchan->id);
712− ret = -EINVAL;
713− goto unlock;
714− }
715−
716− s3cchan->state = S3C24XX_DMA_CHAN_IDLE;
717−
718− /* Mark physical channel as free */
719− if (s3cchan->phy)
720− s3c24xx_dma_phy_free(s3cchan);
721−
722− /* Dequeue current job */
723− if (s3cchan->at) {
724− vchan_terminate_vdesc(&s3cchan->at->vd);
725− s3cchan->at = NULL;
726− }
727−
728− /* Dequeue jobs not yet fired as well */
729−
730− vchan_get_all_descriptors(&s3cchan->vc, &head);
731−
732− spin_unlock_irqrestore(&s3cchan->vc.lock, flags);
733−
734− vchan_dma_desc_free_list(&s3cchan->vc, &head);
735−
736− return 0;
737−
738−unlock:
739− spin_unlock_irqrestore(&s3cchan->vc.lock, flags);
740−
741− return ret;
742−}
743−
744−static void s3c24xx_dma_synchronize(struct dma_chan *chan)
745−{
746− struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
747−
748− vchan_synchronize(&s3cchan->vc);
749−}
750−
751−static void s3c24xx_dma_free_chan_resources(struct dma_chan *chan)
752−{
753− /* Ensure all queued descriptors are freed */
754− vchan_free_chan_resources(to_virt_chan(chan));
755−}
756−
757−static enum dma_status s3c24xx_dma_tx_status(struct dma_chan *chan,
758− dma_cookie_t cookie, struct dma_tx_state *txstate)
759−{
760− struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
761− struct s3c24xx_txd *txd;
762− struct s3c24xx_sg *dsg;
763− struct virt_dma_desc *vd;
764− unsigned long flags;
765− enum dma_status ret;
766− size_t bytes = 0;
767−
768− spin_lock_irqsave(&s3cchan->vc.lock, flags);
769− ret = dma_cookie_status(chan, cookie, txstate);
770−
771− /*
772− * There's no point calculating the residue if there's
773− * no txstate to store the value.
774− */
775− if (ret == DMA_COMPLETE || !txstate) {
776− spin_unlock_irqrestore(&s3cchan->vc.lock, flags);
777− return ret;
778− }
779−
780− vd = vchan_find_desc(&s3cchan->vc, cookie);
781− if (vd) {
782− /* On the issued list, so hasn't been processed yet */
783− txd = to_s3c24xx_txd(&vd->tx);
784−
785− list_for_each_entry(dsg, &txd->dsg_list, node)
786− bytes += dsg->len;
787− } else {
788− /*
789− * Currently running, so sum over the pending sg's and
790− * the currently active one.
791− */
792− txd = s3cchan->at;
793−
794− dsg = list_entry(txd->at, struct s3c24xx_sg, node);
795− list_for_each_entry_from(dsg, &txd->dsg_list, node)
796− bytes += dsg->len;
797−
798− bytes += s3c24xx_dma_getbytes_chan(s3cchan);
799− }
800− spin_unlock_irqrestore(&s3cchan->vc.lock, flags);
801−
802− /*
803− * This cookie not complete yet
804− * Get number of bytes left in the active transactions and queue
805− */
806− dma_set_residue(txstate, bytes);
807−
808− /* Whether waiting or running, we're in progress */
809− return ret;
810−}
811−
812−/*
813− * Initialize a descriptor to be used by memcpy submit
814− */
815−static struct dma_async_tx_descriptor *s3c24xx_dma_prep_memcpy(
816− struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
817− size_t len, unsigned long flags)
818−{
819− struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
820− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
821− struct s3c24xx_txd *txd;
822− struct s3c24xx_sg *dsg;
823− int src_mod, dest_mod;
824−
825− dev_dbg(&s3cdma->pdev->dev, "prepare memcpy of %zu bytes from %s\n",
826− len, s3cchan->name);
827−
828− if ((len & S3C24XX_DCON_TC_MASK) != len) {
829− dev_err(&s3cdma->pdev->dev, "memcpy size %zu to large\n", len);
830− return NULL;
831− }
832−
833− txd = s3c24xx_dma_get_txd();
834− if (!txd)
835− return NULL;
836−
837− dsg = kzalloc(sizeof(*dsg), GFP_NOWAIT);
838− if (!dsg) {
839− s3c24xx_dma_free_txd(txd);
840− return NULL;
841− }
842− list_add_tail(&dsg->node, &txd->dsg_list);
843−
844− dsg->src_addr = src;
845− dsg->dst_addr = dest;
846− dsg->len = len;
847−
848− /*
849− * Determine a suitable transfer width.
850− * The DMA controller cannot fetch/store information which is not
851− * naturally aligned on the bus, i.e., a 4 byte fetch must start at
852− * an address divisible by 4 - more generally addr % width must be 0.
853− */
854− src_mod = src % 4;
855− dest_mod = dest % 4;
856− switch (len % 4) {
857− case 0:
858− txd->width = (src_mod == 0 && dest_mod == 0) ? 4 : 1;
859− break;
860− case 2:
861− txd->width = ((src_mod == 2 || src_mod == 0) &&
862− (dest_mod == 2 || dest_mod == 0)) ? 2 : 1;
863− break;
864− default:
865− txd->width = 1;
866− break;
867− }
868−
869− txd->disrcc = S3C24XX_DISRCC_LOC_AHB | S3C24XX_DISRCC_INC_INCREMENT;
870− txd->didstc = S3C24XX_DIDSTC_LOC_AHB | S3C24XX_DIDSTC_INC_INCREMENT;
871− txd->dcon |= S3C24XX_DCON_DEMAND | S3C24XX_DCON_SYNC_HCLK |
872− S3C24XX_DCON_SERV_WHOLE;
873−
874− return vchan_tx_prep(&s3cchan->vc, &txd->vd, flags);
875−}
876−
877−static struct dma_async_tx_descriptor *s3c24xx_dma_prep_dma_cyclic(
878− struct dma_chan *chan, dma_addr_t addr, size_t size, size_t period,
879− enum dma_transfer_direction direction, unsigned long flags)
880−{
881− struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
882− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
883− const struct s3c24xx_dma_platdata *pdata = s3cdma->pdata;
884− struct s3c24xx_dma_channel *cdata = &pdata->channels[s3cchan->id];
885− struct s3c24xx_txd *txd;
886− struct s3c24xx_sg *dsg;
887− unsigned sg_len;
888− dma_addr_t slave_addr;
889− u32 hwcfg = 0;
890− int i;
891−
892− dev_dbg(&s3cdma->pdev->dev,
893− "prepare cyclic transaction of %zu bytes with period %zu from %s\n",
894− size, period, s3cchan->name);
895−
896− if (!is_slave_direction(direction)) {
897− dev_err(&s3cdma->pdev->dev,
898− "direction %d unsupported\n", direction);
899− return NULL;
900− }
901−
902− txd = s3c24xx_dma_get_txd();
903− if (!txd)
904− return NULL;
905−
906− txd->cyclic = 1;
907−
908− if (cdata->handshake)
909− txd->dcon |= S3C24XX_DCON_HANDSHAKE;
910−
911− switch (cdata->bus) {
912− case S3C24XX_DMA_APB:
913− txd->dcon |= S3C24XX_DCON_SYNC_PCLK;
914− hwcfg |= S3C24XX_DISRCC_LOC_APB;
915− break;
916− case S3C24XX_DMA_AHB:
917− txd->dcon |= S3C24XX_DCON_SYNC_HCLK;
918− hwcfg |= S3C24XX_DISRCC_LOC_AHB;
919− break;
920− }
921−
922− /*
923− * Always assume our peripheral desintation is a fixed
924− * address in memory.
925− */
926− hwcfg |= S3C24XX_DISRCC_INC_FIXED;
927−
928− /*
929− * Individual dma operations are requested by the slave,
930− * so serve only single atomic operations (S3C24XX_DCON_SERV_SINGLE).
931− */
932− txd->dcon |= S3C24XX_DCON_SERV_SINGLE;
933−
934− if (direction == DMA_MEM_TO_DEV) {
935− txd->disrcc = S3C24XX_DISRCC_LOC_AHB |
936− S3C24XX_DISRCC_INC_INCREMENT;
937− txd->didstc = hwcfg;
938− slave_addr = s3cchan->cfg.dst_addr;
939− txd->width = s3cchan->cfg.dst_addr_width;
940− } else {
941− txd->disrcc = hwcfg;
942− txd->didstc = S3C24XX_DIDSTC_LOC_AHB |
943− S3C24XX_DIDSTC_INC_INCREMENT;
944− slave_addr = s3cchan->cfg.src_addr;
945− txd->width = s3cchan->cfg.src_addr_width;
946− }
947−
948− sg_len = size / period;
949−
950− for (i = 0; i < sg_len; i++) {
951− dsg = kzalloc(sizeof(*dsg), GFP_NOWAIT);
952− if (!dsg) {
953− s3c24xx_dma_free_txd(txd);
954− return NULL;
955− }
956− list_add_tail(&dsg->node, &txd->dsg_list);
957−
958− dsg->len = period;
959− /* Check last period length */
960− if (i == sg_len - 1)
961− dsg->len = size - period * i;
962− if (direction == DMA_MEM_TO_DEV) {
963− dsg->src_addr = addr + period * i;
964− dsg->dst_addr = slave_addr;
965− } else { /* DMA_DEV_TO_MEM */
966− dsg->src_addr = slave_addr;
967− dsg->dst_addr = addr + period * i;
968− }
969− }
970−
971− return vchan_tx_prep(&s3cchan->vc, &txd->vd, flags);
972−}
973−
974−static struct dma_async_tx_descriptor *s3c24xx_dma_prep_slave_sg(
975− struct dma_chan *chan, struct scatterlist *sgl,
976− unsigned int sg_len, enum dma_transfer_direction direction,
977− unsigned long flags, void *context)
978−{
979− struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
980− struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
981− const struct s3c24xx_dma_platdata *pdata = s3cdma->pdata;
982− struct s3c24xx_dma_channel *cdata = &pdata->channels[s3cchan->id];
983− struct s3c24xx_txd *txd;
984− struct s3c24xx_sg *dsg;
985− struct scatterlist *sg;
986− dma_addr_t slave_addr;
987− u32 hwcfg = 0;
988− int tmp;
989−
990− dev_dbg(&s3cdma->pdev->dev, "prepare transaction of %d bytes from %s\n",
991− sg_dma_len(sgl), s3cchan->name);
992−
993− txd = s3c24xx_dma_get_txd();
994− if (!txd)
995− return NULL;
996−
997− if (cdata->handshake)
998− txd->dcon |= S3C24XX_DCON_HANDSHAKE;
999−
1000− switch (cdata->bus) {
1001− case S3C24XX_DMA_APB:
1002− txd->dcon |= S3C24XX_DCON_SYNC_PCLK;
1003− hwcfg |= S3C24XX_DISRCC_LOC_APB;
1004− break;
1005− case S3C24XX_DMA_AHB:
1006− txd->dcon |= S3C24XX_DCON_SYNC_HCLK;
1007− hwcfg |= S3C24XX_DISRCC_LOC_AHB;
1008− break;
1009− }
1010−
1011− /*
1012− * Always assume our peripheral desintation is a fixed
1013− * address in memory.
1014− */
1015− hwcfg |= S3C24XX_DISRCC_INC_FIXED;
1016−
1017− /*
1018− * Individual dma operations are requested by the slave,
1019− * so serve only single atomic operations (S3C24XX_DCON_SERV_SINGLE).
1020− */
1021− txd->dcon |= S3C24XX_DCON_SERV_SINGLE;
1022−
1023− if (direction == DMA_MEM_TO_DEV) {
1024− txd->disrcc = S3C24XX_DISRCC_LOC_AHB |
1025− S3C24XX_DISRCC_INC_INCREMENT;
1026− txd->didstc = hwcfg;
1027− slave_addr = s3cchan->cfg.dst_addr;
1028− txd->width = s3cchan->cfg.dst_addr_width;
1029− } else if (direction == DMA_DEV_TO_MEM) {
1030− txd->disrcc = hwcfg;
1031− txd->didstc = S3C24XX_DIDSTC_LOC_AHB |
1032− S3C24XX_DIDSTC_INC_INCREMENT;
1033− slave_addr = s3cchan->cfg.src_addr;
1034− txd->width = s3cchan->cfg.src_addr_width;
1035− } else {
1036− s3c24xx_dma_free_txd(txd);
1037− dev_err(&s3cdma->pdev->dev,
1038− "direction %d unsupported\n", direction);
1039− return NULL;
1040− }
1041−
1042− for_each_sg(sgl, sg, sg_len, tmp) {
1043− dsg = kzalloc(sizeof(*dsg), GFP_NOWAIT);
1044− if (!dsg) {
1045− s3c24xx_dma_free_txd(txd);
1046− return NULL;
1047− }
1048− list_add_tail(&dsg->node, &txd->dsg_list);
1049−
1050− dsg->len = sg_dma_len(sg);
1051− if (direction == DMA_MEM_TO_DEV) {
1052− dsg->src_addr = sg_dma_address(sg);
1053− dsg->dst_addr = slave_addr;
1054− } else { /* DMA_DEV_TO_MEM */
1055− dsg->src_addr = slave_addr;
1056− dsg->dst_addr = sg_dma_address(sg);
1057− }
1058− }
1059−
1060− return vchan_tx_prep(&s3cchan->vc, &txd->vd, flags);
1061−}
1062−
1063−/*
1064− * Slave transactions callback to the slave device to allow
1065− * synchronization of slave DMA signals with the DMAC enable
1066− */
1067−static void s3c24xx_dma_issue_pending(struct dma_chan *chan)
1068−{
1069− struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
1070− unsigned long flags;
1071−
1072− spin_lock_irqsave(&s3cchan->vc.lock, flags);
1073− if (vchan_issue_pending(&s3cchan->vc)) {
1074− if (!s3cchan->phy && s3cchan->state != S3C24XX_DMA_CHAN_WAITING)
1075− s3c24xx_dma_phy_alloc_and_start(s3cchan);
1076− }
1077− spin_unlock_irqrestore(&s3cchan->vc.lock, flags);
1078−}
1079−
1080−/*
1081− * Bringup and teardown
1082− */
1083−
1084−/*
1085− * Initialise the DMAC memcpy/slave channels.
1086− * Make a local wrapper to hold required data
1087− */
1088−static int s3c24xx_dma_init_virtual_channels(struct s3c24xx_dma_engine *s3cdma,
1089− struct dma_device *dmadev, unsigned int channels, bool slave)
1090−{
1091− struct s3c24xx_dma_chan *chan;
1092− int i;
1093−
1094− INIT_LIST_HEAD(&dmadev->channels);
1095−
1096− /*
1097− * Register as many memcpy as we have physical channels,
1098− * we won't always be able to use all but the code will have
1099− * to cope with that situation.
1100− */
1101− for (i = 0; i < channels; i++) {
1102− chan = devm_kzalloc(dmadev->dev, sizeof(*chan), GFP_KERNEL);
1103− if (!chan)
1104− return -ENOMEM;
1105−
1106− chan->id = i;
1107− chan->host = s3cdma;
1108− chan->state = S3C24XX_DMA_CHAN_IDLE;
1109−
1110− if (slave) {
1111− chan->slave = true;
1112− chan->name = kasprintf(GFP_KERNEL, "slave%d", i);
1113− if (!chan->name)
1114− return -ENOMEM;
1115− } else {
1116− chan->name = kasprintf(GFP_KERNEL, "memcpy%d", i);
1117− if (!chan->name)
1118− return -ENOMEM;
1119− }
1120− dev_dbg(dmadev->dev,
1121− "initialize virtual channel \"%s\"\n",
1122− chan->name);
1123−
1124− chan->vc.desc_free = s3c24xx_dma_desc_free;
1125− vchan_init(&chan->vc, dmadev);
1126− }
1127− dev_info(dmadev->dev, "initialized %d virtual %s channels\n",
1128− i, slave ? "slave" : "memcpy");
1129− return i;
1130−}
1131−
1132−static void s3c24xx_dma_free_virtual_channels(struct dma_device *dmadev)
1133−{
1134− struct s3c24xx_dma_chan *chan = NULL;
1135− struct s3c24xx_dma_chan *next;
1136−
1137− list_for_each_entry_safe(chan,
1138− next, &dmadev->channels, vc.chan.device_node) {
1139− list_del(&chan->vc.chan.device_node);
1140− tasklet_kill(&chan->vc.task);
1141− }
1142−}
1143−
1144−/* s3c2410, s3c2440 and s3c2442 have a 0x40 stride without separate clocks */
1145−static struct soc_data soc_s3c2410 = {
1146− .stride = 0x40,
1147− .has_reqsel = false,
1148− .has_clocks = false,
1149−};
1150−
1151−/* s3c2412 and s3c2413 have a 0x40 stride and dmareqsel mechanism */
1152−static struct soc_data soc_s3c2412 = {
1153− .stride = 0x40,
1154− .has_reqsel = true,
1155− .has_clocks = true,
1156−};
1157−
1158−/* s3c2443 and following have a 0x100 stride and dmareqsel mechanism */
1159−static struct soc_data soc_s3c2443 = {
1160− .stride = 0x100,
1161− .has_reqsel = true,
1162− .has_clocks = true,
1163−};
1164−
1165−static const struct platform_device_id s3c24xx_dma_driver_ids[] = {
1166− {
1167− .name = "s3c2410-dma",
1168− .driver_data = (kernel_ulong_t)&soc_s3c2410,
1169− }, {
1170− .name = "s3c2412-dma",
1171− .driver_data = (kernel_ulong_t)&soc_s3c2412,
1172− }, {
1173− .name = "s3c2443-dma",
1174− .driver_data = (kernel_ulong_t)&soc_s3c2443,
1175− },
1176− { },
1177−};
1178−
1179−static struct soc_data *s3c24xx_dma_get_soc_data(struct platform_device *pdev)
1180−{
1181− return (struct soc_data *)
1182− platform_get_device_id(pdev)->driver_data;
1183−}
1184−
1185−static int s3c24xx_dma_probe(struct platform_device *pdev)
1186−{
1187− const struct s3c24xx_dma_platdata *pdata = dev_get_platdata(&pdev->dev);
1188− struct s3c24xx_dma_engine *s3cdma;
1189− struct soc_data *sdata;
1190− struct resource *res;
1191− int ret;
1192− int i;
1193−
1194− if (!pdata) {
1195− dev_err(&pdev->dev, "platform data missing\n");
1196− return -ENODEV;
1197− }
1198−
1199− /* Basic sanity check */
1200− if (pdata->num_phy_channels > MAX_DMA_CHANNELS) {
1201− dev_err(&pdev->dev, "too many dma channels %d, max %d\n",
1202− pdata->num_phy_channels, MAX_DMA_CHANNELS);
1203− return -EINVAL;
1204− }
1205−
1206− sdata = s3c24xx_dma_get_soc_data(pdev);
1207− if (!sdata)
1208− return -EINVAL;
1209−
1210− s3cdma = devm_kzalloc(&pdev->dev, sizeof(*s3cdma), GFP_KERNEL);
1211− if (!s3cdma)
1212− return -ENOMEM;
1213−
1214− s3cdma->pdev = pdev;
1215− s3cdma->pdata = pdata;
1216− s3cdma->sdata = sdata;
1217−
1218− res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1219− s3cdma->base = devm_ioremap_resource(&pdev->dev, res);
1220− if (IS_ERR(s3cdma->base))
1221− return PTR_ERR(s3cdma->base);
1222−
1223− s3cdma->phy_chans = devm_kcalloc(&pdev->dev,
1224− pdata->num_phy_channels,
1225− sizeof(struct s3c24xx_dma_phy),
1226− GFP_KERNEL);
1227− if (!s3cdma->phy_chans)
1228− return -ENOMEM;
1229−
1230− /* acquire irqs and clocks for all physical channels */
1231− for (i = 0; i < pdata->num_phy_channels; i++) {
1232− struct s3c24xx_dma_phy *phy = &s3cdma->phy_chans[i];
1233− char clk_name[6];
1234−
1235− phy->id = i;
1236− phy->base = s3cdma->base + (i * sdata->stride);
1237− phy->host = s3cdma;
1238−
1239− phy->irq = platform_get_irq(pdev, i);
1240− if (phy->irq < 0)
1241− continue;
1242−
1243− ret = devm_request_irq(&pdev->dev, phy->irq, s3c24xx_dma_irq,
1244− 0, pdev->name, phy);
1245− if (ret) {
1246− dev_err(&pdev->dev, "Unable to request irq for channel %d, error %d\n",
1247− i, ret);
1248− continue;
1249− }
1250−
1251− if (sdata->has_clocks) {
1252− sprintf(clk_name, "dma.%d", i);
1253− phy->clk = devm_clk_get(&pdev->dev, clk_name);
1254− if (IS_ERR(phy->clk) && sdata->has_clocks) {
1255− dev_err(&pdev->dev, "unable to acquire clock for channel %d, error %lu\n",
1256− i, PTR_ERR(phy->clk));
1257− continue;
1258− }
1259−
1260− ret = clk_prepare(phy->clk);
1261− if (ret) {
1262− dev_err(&pdev->dev, "clock for phy %d failed, error %d\n",
1263− i, ret);
1264− continue;
1265− }
1266− }
1267−
1268− spin_lock_init(&phy->lock);
1269− phy->valid = true;
1270−
1271− dev_dbg(&pdev->dev, "physical channel %d is %s\n",
1272− i, s3c24xx_dma_phy_busy(phy) ? "BUSY" : "FREE");
1273− }
1274−
1275− /* Initialize memcpy engine */
1276− dma_cap_set(DMA_MEMCPY, s3cdma->memcpy.cap_mask);
1277− dma_cap_set(DMA_PRIVATE, s3cdma->memcpy.cap_mask);
1278− s3cdma->memcpy.dev = &pdev->dev;
1279− s3cdma->memcpy.device_free_chan_resources =
1280− s3c24xx_dma_free_chan_resources;
1281− s3cdma->memcpy.device_prep_dma_memcpy = s3c24xx_dma_prep_memcpy;
1282− s3cdma->memcpy.device_tx_status = s3c24xx_dma_tx_status;
1283− s3cdma->memcpy.device_issue_pending = s3c24xx_dma_issue_pending;
1284− s3cdma->memcpy.device_config = s3c24xx_dma_set_runtime_config;
1285− s3cdma->memcpy.device_terminate_all = s3c24xx_dma_terminate_all;
1286− s3cdma->memcpy.device_synchronize = s3c24xx_dma_synchronize;
1287−
1288− /* Initialize slave engine for SoC internal dedicated peripherals */
1289− dma_cap_set(DMA_SLAVE, s3cdma->slave.cap_mask);
1290− dma_cap_set(DMA_CYCLIC, s3cdma->slave.cap_mask);
1291− dma_cap_set(DMA_PRIVATE, s3cdma->slave.cap_mask);
1292− s3cdma->slave.dev = &pdev->dev;
1293− s3cdma->slave.device_free_chan_resources =
1294− s3c24xx_dma_free_chan_resources;
1295− s3cdma->slave.device_tx_status = s3c24xx_dma_tx_status;
1296− s3cdma->slave.device_issue_pending = s3c24xx_dma_issue_pending;
1297− s3cdma->slave.device_prep_slave_sg = s3c24xx_dma_prep_slave_sg;
1298− s3cdma->slave.device_prep_dma_cyclic = s3c24xx_dma_prep_dma_cyclic;
1299− s3cdma->slave.device_config = s3c24xx_dma_set_runtime_config;
1300− s3cdma->slave.device_terminate_all = s3c24xx_dma_terminate_all;
1301− s3cdma->slave.device_synchronize = s3c24xx_dma_synchronize;
1302− s3cdma->slave.filter.map = pdata->slave_map;
1303− s3cdma->slave.filter.mapcnt = pdata->slavecnt;
1304− s3cdma->slave.filter.fn = s3c24xx_dma_filter;
1305−
1306− /* Register as many memcpy channels as there are physical channels */
1307− ret = s3c24xx_dma_init_virtual_channels(s3cdma, &s3cdma->memcpy,
1308− pdata->num_phy_channels, false);
1309− if (ret <= 0) {
1310− dev_warn(&pdev->dev,
1311− "%s failed to enumerate memcpy channels - %d\n",
1312− __func__, ret);
1313− goto err_memcpy;
1314− }
1315−
1316− /* Register slave channels */
1317− ret = s3c24xx_dma_init_virtual_channels(s3cdma, &s3cdma->slave,
1318− pdata->num_channels, true);
1319− if (ret <= 0) {
1320− dev_warn(&pdev->dev,
1321− "%s failed to enumerate slave channels - %d\n",
1322− __func__, ret);
1323− goto err_slave;
1324− }
1325−
1326− ret = dma_async_device_register(&s3cdma->memcpy);
1327− if (ret) {
1328− dev_warn(&pdev->dev,
1329− "%s failed to register memcpy as an async device - %d\n",
1330− __func__, ret);
1331− goto err_memcpy_reg;
1332− }
1333−
1334− ret = dma_async_device_register(&s3cdma->slave);
1335− if (ret) {
1336− dev_warn(&pdev->dev,
1337− "%s failed to register slave as an async device - %d\n",
1338− __func__, ret);
1339− goto err_slave_reg;
1340− }
1341−
1342− platform_set_drvdata(pdev, s3cdma);
1343− dev_info(&pdev->dev, "Loaded dma driver with %d physical channels\n",
1344− pdata->num_phy_channels);
1345−
1346− return 0;
1347−
1348−err_slave_reg:
1349− dma_async_device_unregister(&s3cdma->memcpy);
1350−err_memcpy_reg:
1351− s3c24xx_dma_free_virtual_channels(&s3cdma->slave);
1352−err_slave:
1353− s3c24xx_dma_free_virtual_channels(&s3cdma->memcpy);
1354−err_memcpy:
1355− if (sdata->has_clocks)
1356− for (i = 0; i < pdata->num_phy_channels; i++) {
1357− struct s3c24xx_dma_phy *phy = &s3cdma->phy_chans[i];
1358− if (phy->valid)
1359− clk_unprepare(phy->clk);
1360− }
1361−
1362− return ret;
1363−}
1364−
1365−static void s3c24xx_dma_free_irq(struct platform_device *pdev,
1366− struct s3c24xx_dma_engine *s3cdma)
1367−{
1368− int i;
1369−
1370− for (i = 0; i < s3cdma->pdata->num_phy_channels; i++) {
1371− struct s3c24xx_dma_phy *phy = &s3cdma->phy_chans[i];
1372−
1373− devm_free_irq(&pdev->dev, phy->irq, phy);
1374− }
1375−}
1376−
1377−static int s3c24xx_dma_remove(struct platform_device *pdev)
1378−{
1379− const struct s3c24xx_dma_platdata *pdata = dev_get_platdata(&pdev->dev);
1380− struct s3c24xx_dma_engine *s3cdma = platform_get_drvdata(pdev);
1381− struct soc_data *sdata = s3c24xx_dma_get_soc_data(pdev);
1382− int i;
1383−
1384− dma_async_device_unregister(&s3cdma->slave);
1385− dma_async_device_unregister(&s3cdma->memcpy);
1386−
1387− s3c24xx_dma_free_irq(pdev, s3cdma);
1388−
1389− s3c24xx_dma_free_virtual_channels(&s3cdma->slave);
1390− s3c24xx_dma_free_virtual_channels(&s3cdma->memcpy);
1391−
1392− if (sdata->has_clocks)
1393− for (i = 0; i < pdata->num_phy_channels; i++) {
1394− struct s3c24xx_dma_phy *phy = &s3cdma->phy_chans[i];
1395− if (phy->valid)
1396− clk_unprepare(phy->clk);
1397− }
1398−
1399− return 0;
1400−}
1401−
1402−static struct platform_driver s3c24xx_dma_driver = {
1403− .driver = {
1404− .name = "s3c24xx-dma",
1405− },
1406− .id_table = s3c24xx_dma_driver_ids,
1407− .probe = s3c24xx_dma_probe,
1408− .remove = s3c24xx_dma_remove,
1409−};
1410−
1411−module_platform_driver(s3c24xx_dma_driver);
1412−
1413−bool s3c24xx_dma_filter(struct dma_chan *chan, void *param)
1414−{
1415− struct s3c24xx_dma_chan *s3cchan;
1416−
1417− if (chan->device->dev->driver != &s3c24xx_dma_driver.driver)
1418− return false;
1419−
1420− s3cchan = to_s3c24xx_dma_chan(chan);
1421−
1422− return s3cchan->id == (uintptr_t)param;
1423−}
1424−EXPORT_SYMBOL(s3c24xx_dma_filter);
1425−
1426−MODULE_DESCRIPTION("S3C24XX DMA Driver");
1427−MODULE_AUTHOR("Heiko Stuebner");
1428−MODULE_LICENSE("GPL v2");
include/linux/platform_data/dma-s3c24xx.h+0−48
@@ -1,48 +0,0 @@
1−/* SPDX-License-Identifier: GPL-2.0-or-later */
2−/*
3− * S3C24XX DMA handling
4− *
5− * Copyright (c) 2013 Heiko Stuebner <heiko@sntech.de>
6− */
7−
8−/* Helper to encode the source selection constraints for early s3c socs. */
9−#define S3C24XX_DMA_CHANREQ(src, chan) ((BIT(3) | src) << chan * 4)
10−
11−enum s3c24xx_dma_bus {
12− S3C24XX_DMA_APB,
13− S3C24XX_DMA_AHB,
14−};
15−
16−/**
17− * @bus: on which bus does the peripheral reside - AHB or APB.
18− * @handshake: is a handshake with the peripheral necessary
19− * @chansel: channel selection information, depending on variant; reqsel for
20− * s3c2443 and later and channel-selection map for earlier SoCs
21− * see CHANSEL doc in s3c2443-dma.c
22− */
23−struct s3c24xx_dma_channel {
24− enum s3c24xx_dma_bus bus;
25− bool handshake;
26− u16 chansel;
27−};
28−
29−struct dma_slave_map;
30−
31−/**
32− * struct s3c24xx_dma_platdata - platform specific settings
33− * @num_phy_channels: number of physical channels
34− * @channels: array of virtual channel descriptions
35− * @num_channels: number of virtual channels
36− * @slave_map: dma slave map matching table
37− * @slavecnt: number of elements in slave_map
38− */
39−struct s3c24xx_dma_platdata {
40− int num_phy_channels;
41− struct s3c24xx_dma_channel *channels;
42− int num_channels;
43− const struct dma_slave_map *slave_map;
44− int slavecnt;
45−};
46−
47−struct dma_chan;
48−bool s3c24xx_dma_filter(struct dma_chan *chan, void *param);

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t