* PrimeCell generic DMA v10 @ 2010-09-01 15:24 Linus Walleij 2010-09-01 15:24 ` [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 Linus Walleij 0 siblings, 1 reply; 10+ messages in thread From: Linus Walleij @ 2010-09-01 15:24 UTC (permalink / raw) To: Dan Williams, linux-arm-kernel, yuanyabin1978; +Cc: linux-kernel, Linus Walleij This is the tenth iteration of this patchset... Now DMA is working nicely on the following platforms and PrimeCells: - U300 PL011, PL022, PL180 - U8500 PL011, PL022, PL180 - RealView PB11MPCore PL011, PL022 PL180 (MMC) is not working with the MMC and DMA, I haven't drilled into why, could be some FIFO overflow or similar. I think DMA could actually be activated for all the RealViews with a working DMA controller (EB, PB11MPCore, PBA8 and PBX) but since I cannot test them I left them out of the patch set. I ran some serious stress tests on the PB11MPCore, with two threads submitting DMA memcpy jobs while making transfers on PL011 and PL022 simultaneously, no problems. I read up on DMA-API and proofread all three drivers with that in mind, but I cannot find any more misuses of the API. (The latest unecessary sync call in PL022 that Russell found is removed.) The compilation problem Grant saw on the PL022 driver I have *still* not been able to reproduce so I am in the blue on this one. It compiles nicely for U300, U8500 and RealView. I need help if there is still problems with this. Yours, Linus Walleij ^ permalink raw reply [flat|nested] 10+ messages in thread
* [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 2010-09-01 15:24 PrimeCell generic DMA v10 Linus Walleij @ 2010-09-01 15:24 ` Linus Walleij 2010-09-01 15:24 ` [PATCH 2/6] ARM: add PrimeCell generic DMA to PL011 v10 Linus Walleij 2010-09-23 21:31 ` [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 Dan Williams 0 siblings, 2 replies; 10+ messages in thread From: Linus Walleij @ 2010-09-01 15:24 UTC (permalink / raw) To: Dan Williams, linux-arm-kernel, yuanyabin1978; +Cc: linux-kernel, Linus Walleij This extends the PL022 SSP/SPI driver with generic DMA engine support using the PrimeCell DMA engine interface. Also fix up the test code for the U300 platform. Acked-by: Grant Likely <grant.likely@secretlab.ca> Signed-off-by: Linus Walleij <linus.walleij@stericsson.com> --- As mentioned I have no clue to why this failed to compile for Grant, please see if this tenth version is still problematic or if it was something intermittent. Else I really need help in knowing what config to compile, this was compiled for U300, U8500 and RealView with and without DMA enabled. --- arch/arm/mach-u300/dummyspichip.c | 1 + drivers/spi/amba-pl022.c | 516 ++++++++++++++++++++++++++++++------- include/linux/amba/pl022.h | 6 + 3 files changed, 435 insertions(+), 88 deletions(-) diff --git a/arch/arm/mach-u300/dummyspichip.c b/arch/arm/mach-u300/dummyspichip.c index 5f55012..5672189 100644 --- a/arch/arm/mach-u300/dummyspichip.c +++ b/arch/arm/mach-u300/dummyspichip.c @@ -268,6 +268,7 @@ static struct spi_driver pl022_dummy_driver = { .driver = { .name = "spi-dummy", .owner = THIS_MODULE, + .bus = &spi_bus_type, }, .probe = pl022_dummy_probe, .remove = __devexit_p(pl022_dummy_remove), diff --git a/drivers/spi/amba-pl022.c b/drivers/spi/amba-pl022.c index 59f8cfb..3db5402 100644 --- a/drivers/spi/amba-pl022.c +++ b/drivers/spi/amba-pl022.c @@ -27,7 +27,6 @@ /* * TODO: * - add timeout on polled transfers - * - add generic DMA framework support */ #include <linux/init.h> @@ -45,6 +44,9 @@ #include <linux/amba/pl022.h> #include <linux/io.h> #include <linux/slab.h> +#include <linux/dmaengine.h> +#include <linux/dma-mapping.h> +#include <linux/scatterlist.h> /* * This macro is used to define some register default values. @@ -381,6 +383,14 @@ struct pl022 { enum ssp_reading read; enum ssp_writing write; u32 exp_fifo_level; + /* DMA settings */ +#ifdef CONFIG_DMADEVICES + struct dma_chan *dma_rx_channel; + struct dma_chan *dma_tx_channel; + struct sg_table sgt_rx; + struct sg_table sgt_tx; + char *dummypage; +#endif }; /** @@ -406,7 +416,7 @@ struct chip_data { u16 dmacr; u16 cpsr; u8 n_bytes; - u8 enable_dma:1; + bool enable_dma; enum ssp_reading read; enum ssp_writing write; void (*cs_control) (u32 command); @@ -763,6 +773,371 @@ static void *next_transfer(struct pl022 *pl022) } return STATE_DONE; } + +/* + * This DMA functionality is only compiled in if we have + * access to the generic DMA devices/DMA engine. + */ +#ifdef CONFIG_DMADEVICES +static void unmap_free_dma_scatter(struct pl022 *pl022) +{ + /* Unmap and free the SG tables */ + dma_unmap_sg(&pl022->adev->dev, pl022->sgt_tx.sgl, + pl022->sgt_tx.nents, DMA_TO_DEVICE); + dma_unmap_sg(&pl022->adev->dev, pl022->sgt_rx.sgl, + pl022->sgt_rx.nents, DMA_FROM_DEVICE); + sg_free_table(&pl022->sgt_rx); + sg_free_table(&pl022->sgt_tx); +} + +static void dma_callback(void *data) +{ + struct pl022 *pl022 = data; + struct spi_message *msg = pl022->cur_msg; + + BUG_ON(!pl022->sgt_rx.sgl); + +#ifdef VERBOSE_DEBUG + /* + * Optionally dump out buffers to inspect contents, this is + * good if you want to convince yourself that the loopback + * read/write contents are the same, when adopting to a new + * DMA engine. + */ + { + struct scatterlist *sg; + unsigned int i; + + dma_sync_sg_for_cpu(&pl022->adev->dev, + pl022->sgt_rx.sgl, + pl022->sgt_rx.nents, + DMA_FROM_DEVICE); + + for_each_sg(pl022->sgt_rx.sgl, sg, pl022->sgt_rx.nents, i) { + dev_dbg(&pl022->adev->dev, "SPI RX SG ENTRY: %d", i); + print_hex_dump(KERN_ERR, "SPI RX: ", + DUMP_PREFIX_OFFSET, + 16, + 1, + sg_virt(sg), + sg_dma_len(sg), + 1); + } + for_each_sg(pl022->sgt_tx.sgl, sg, pl022->sgt_tx.nents, i) { + dev_dbg(&pl022->adev->dev, "SPI TX SG ENTRY: %d", i); + print_hex_dump(KERN_ERR, "SPI TX: ", + DUMP_PREFIX_OFFSET, + 16, + 1, + sg_virt(sg), + sg_dma_len(sg), + 1); + } + } +#endif + + unmap_free_dma_scatter(pl022); + + /* Update total bytes transfered */ + msg->actual_length += pl022->cur_transfer->len; + if (pl022->cur_transfer->cs_change) + pl022->cur_chip-> + cs_control(SSP_CHIP_DESELECT); + + /* Move to next transfer */ + msg->state = next_transfer(pl022); + tasklet_schedule(&pl022->pump_transfers); +} + +static void setup_dma_scatter(struct pl022 *pl022, + void *buffer, + unsigned int length, + struct sg_table *sgtab) +{ + struct scatterlist *sg; + int bytesleft = length; + void *bufp = buffer; + int mapbytes; + int i; + + if (buffer) { + for_each_sg(sgtab->sgl, sg, sgtab->nents, i) { + /* + * If there are less bytes left than what fits + * in the current page (plus page alignment offset) + * we just feed in this, else we stuff in as much + * as we can. + */ + if (bytesleft < (PAGE_SIZE - offset_in_page(bufp))) + mapbytes = bytesleft; + else + mapbytes = PAGE_SIZE - offset_in_page(bufp); + sg_set_page(sg, virt_to_page(bufp), + mapbytes, offset_in_page(bufp)); + bufp += mapbytes; + bytesleft -= mapbytes; + dev_dbg(&pl022->adev->dev, + "set RX/TX target page @ %p, %d bytes, %d left\n", + bufp, mapbytes, bytesleft); + } + } else { + /* Map the dummy buffer on every page */ + for_each_sg(sgtab->sgl, sg, sgtab->nents, i) { + if (bytesleft < PAGE_SIZE) + mapbytes = bytesleft; + else + mapbytes = PAGE_SIZE; + sg_set_page(sg, virt_to_page(pl022->dummypage), + mapbytes, 0); + bytesleft -= mapbytes; + dev_dbg(&pl022->adev->dev, + "set RX/TX to dummy page %d bytes, %d left\n", + mapbytes, bytesleft); + + } + } + BUG_ON(bytesleft); +} + +/** + * configure_dma - configures the channels for the next transfer + * @pl022: SSP driver's private data structure + */ +static int configure_dma(struct pl022 *pl022) +{ + struct dma_slave_config rx_conf = { + .src_addr = SSP_DR(pl022->phybase), + .direction = DMA_FROM_DEVICE, + .src_maxburst = pl022->vendor->fifodepth >> 1, + }; + struct dma_slave_config tx_conf = { + .dst_addr = SSP_DR(pl022->phybase), + .direction = DMA_TO_DEVICE, + .dst_maxburst = pl022->vendor->fifodepth >> 1, + }; + unsigned int pages; + int ret; + int sglen; + struct dma_chan *rxchan = pl022->dma_rx_channel; + struct dma_chan *txchan = pl022->dma_tx_channel; + struct dma_async_tx_descriptor *rxdesc; + struct dma_async_tx_descriptor *txdesc; + dma_cookie_t cookie; + + /* Check that the channels are available */ + if (!rxchan || !txchan) + return -ENODEV; + + switch (pl022->read) { + case READING_NULL: + /* Use the same as for writing */ + rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_UNDEFINED; + break; + case READING_U8: + rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE; + break; + case READING_U16: + rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES; + break; + case READING_U32: + rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; + break; + } + + switch (pl022->write) { + case WRITING_NULL: + /* Use the same as for reading */ + tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_UNDEFINED; + break; + case WRITING_U8: + tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE; + break; + case WRITING_U16: + tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES; + break; + case WRITING_U32: + tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;; + break; + } + + /* SPI pecularity: we need to read and write the same width */ + if (rx_conf.src_addr_width == DMA_SLAVE_BUSWIDTH_UNDEFINED) + rx_conf.src_addr_width = tx_conf.dst_addr_width; + if (tx_conf.dst_addr_width == DMA_SLAVE_BUSWIDTH_UNDEFINED) + tx_conf.dst_addr_width = rx_conf.src_addr_width; + BUG_ON(rx_conf.src_addr_width != tx_conf.dst_addr_width); + + rxchan->device->device_control(rxchan, DMA_SLAVE_CONFIG, + (unsigned long) &rx_conf); + txchan->device->device_control(txchan, DMA_SLAVE_CONFIG, + (unsigned long) &tx_conf); + + /* Create sglists for the transfers */ + pages = (pl022->cur_transfer->len >> PAGE_SHIFT) + 1; + dev_dbg(&pl022->adev->dev, "using %d pages for transfer\n", pages); + + ret = sg_alloc_table(&pl022->sgt_rx, pages, GFP_KERNEL); + if (ret) + goto err_alloc_rx_sg; + + ret = sg_alloc_table(&pl022->sgt_tx, pages, GFP_KERNEL); + if (ret) + goto err_alloc_tx_sg; + + /* Fill in the scatterlists for the RX+TX buffers */ + setup_dma_scatter(pl022, pl022->rx, + pl022->cur_transfer->len, &pl022->sgt_rx); + setup_dma_scatter(pl022, pl022->tx, + pl022->cur_transfer->len, &pl022->sgt_tx); + + /* Map DMA buffers */ + sglen = dma_map_sg(&pl022->adev->dev, pl022->sgt_rx.sgl, + pl022->sgt_rx.nents, DMA_FROM_DEVICE); + if (!sglen) + goto err_rx_sgmap; + + sglen = dma_map_sg(&pl022->adev->dev, pl022->sgt_tx.sgl, + pl022->sgt_tx.nents, DMA_TO_DEVICE); + if (!sglen) + goto err_tx_sgmap; + + /* Send both scatterlists */ + rxdesc = rxchan->device->device_prep_slave_sg(rxchan, + pl022->sgt_rx.sgl, + pl022->sgt_rx.nents, + DMA_FROM_DEVICE, + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); + if (!rxdesc) + goto err_rxdesc; + + txdesc = txchan->device->device_prep_slave_sg(txchan, + pl022->sgt_tx.sgl, + pl022->sgt_tx.nents, + DMA_TO_DEVICE, + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); + if (!txdesc) + goto err_txdesc; + + /* Put the callback on the RX transfer only, that should finish last */ + rxdesc->callback = dma_callback; + rxdesc->callback_param = pl022; + + /* Submit and fire RX and TX with TX last so we're ready to read! */ + cookie = rxdesc->tx_submit(rxdesc); + if (dma_submit_error(cookie)) + goto err_submit_rx; + cookie = txdesc->tx_submit(txdesc); + if (dma_submit_error(cookie)) + goto err_submit_tx; + rxchan->device->device_issue_pending(rxchan); + txchan->device->device_issue_pending(txchan); + + return 0; + +err_submit_tx: +err_submit_rx: +err_txdesc: + txchan->device->device_control(txchan, DMA_TERMINATE_ALL, 0); +err_rxdesc: + rxchan->device->device_control(rxchan, DMA_TERMINATE_ALL, 0); + dma_unmap_sg(&pl022->adev->dev, pl022->sgt_tx.sgl, + pl022->sgt_tx.nents, DMA_TO_DEVICE); +err_tx_sgmap: + dma_unmap_sg(&pl022->adev->dev, pl022->sgt_rx.sgl, + pl022->sgt_tx.nents, DMA_FROM_DEVICE); +err_rx_sgmap: + sg_free_table(&pl022->sgt_tx); +err_alloc_tx_sg: + sg_free_table(&pl022->sgt_rx); +err_alloc_rx_sg: + return -ENOMEM; +} + +static int __init pl022_dma_probe(struct pl022 *pl022) +{ + dma_cap_mask_t mask; + + /* Try to acquire a generic DMA engine slave channel */ + dma_cap_zero(mask); + dma_cap_set(DMA_SLAVE, mask); + /* + * We need both RX and TX channels to do DMA, else do none + * of them. + */ + pl022->dma_rx_channel = dma_request_channel(mask, + pl022->master_info->dma_filter, + pl022->master_info->dma_rx_param); + if (!pl022->dma_rx_channel) { + dev_err(&pl022->adev->dev, "no RX DMA channel!\n"); + goto err_no_rxchan; + } + + pl022->dma_tx_channel = dma_request_channel(mask, + pl022->master_info->dma_filter, + pl022->master_info->dma_tx_param); + if (!pl022->dma_tx_channel) { + dev_err(&pl022->adev->dev, "no TX DMA channel!\n"); + goto err_no_txchan; + } + + pl022->dummypage = kmalloc(PAGE_SIZE, GFP_KERNEL); + if (!pl022->dummypage) { + dev_err(&pl022->adev->dev, "no DMA dummypage!\n"); + goto err_no_dummypage; + } + + dev_info(&pl022->adev->dev, "setup for DMA on RX %s, TX %s\n", + dma_chan_name(pl022->dma_rx_channel), + dma_chan_name(pl022->dma_tx_channel)); + + return 0; + +err_no_dummypage: + dma_release_channel(pl022->dma_tx_channel); +err_no_txchan: + dma_release_channel(pl022->dma_rx_channel); + pl022->dma_rx_channel = NULL; +err_no_rxchan: + return -ENODEV; +} + +static void terminate_dma(struct pl022 *pl022) +{ + struct dma_chan *rxchan = pl022->dma_rx_channel; + struct dma_chan *txchan = pl022->dma_tx_channel; + + rxchan->device->device_control(rxchan, DMA_TERMINATE_ALL, 0); + txchan->device->device_control(txchan, DMA_TERMINATE_ALL, 0); + unmap_free_dma_scatter(pl022); +} + +static void pl022_dma_remove(struct pl022 *pl022) +{ + if (pl022->busy) + terminate_dma(pl022); + if (pl022->dma_tx_channel) + dma_release_channel(pl022->dma_tx_channel); + if (pl022->dma_rx_channel) + dma_release_channel(pl022->dma_rx_channel); + kfree(pl022->dummypage); +} + +#else +static inline int configure_dma(struct pl022 *pl022) +{ + return -ENODEV; +} + +static inline int pl022_dma_probe(struct pl022 *pl022) +{ + return 0; +} + +static inline void pl022_dma_remove(struct pl022 *pl022) +{ +} +#endif + /** * pl022_interrupt_handler - Interrupt handler for SSP controller * @@ -794,14 +1169,17 @@ static irqreturn_t pl022_interrupt_handler(int irq, void *dev_id) if (unlikely(!irq_status)) return IRQ_NONE; - /* This handles the error code interrupts */ + /* + * This handles the FIFO interrupts, the timeout + * interrupts are flatly ignored, they cannot be + * trusted. + */ if (unlikely(irq_status & SSP_MIS_MASK_RORMIS)) { /* * Overrun interrupt - bail out since our Data has been * corrupted */ - dev_err(&pl022->adev->dev, - "FIFO overrun\n"); + dev_err(&pl022->adev->dev, "FIFO overrun\n"); if (readw(SSP_SR(pl022->virtbase)) & SSP_SR_MASK_RFF) dev_err(&pl022->adev->dev, "RXFIFO is full\n"); @@ -896,8 +1274,8 @@ static int set_up_next_transfer(struct pl022 *pl022, } /** - * pump_transfers - Tasklet function which schedules next interrupt transfer - * when running in interrupt transfer mode. + * pump_transfers - Tasklet function which schedules next transfer + * when running in interrupt or DMA transfer mode. * @data: SSP driver private data structure * */ @@ -954,65 +1332,23 @@ static void pump_transfers(unsigned long data) } /* Flush the FIFOs and let's go! */ flush(pl022); - writew(ENABLE_ALL_INTERRUPTS, SSP_IMSC(pl022->virtbase)); -} - -/** - * NOT IMPLEMENTED - * configure_dma - It configures the DMA pipes for DMA transfers - * @data: SSP driver's private data structure - * - */ -static int configure_dma(void *data) -{ - struct pl022 *pl022 = data; - dev_dbg(&pl022->adev->dev, "configure DMA\n"); - return -ENOTSUPP; -} - -/** - * do_dma_transfer - It handles transfers of the current message - * if it is DMA xfer. - * NOT FULLY IMPLEMENTED - * @data: SSP driver's private data structure - */ -static void do_dma_transfer(void *data) -{ - struct pl022 *pl022 = data; - - if (configure_dma(data)) { - dev_dbg(&pl022->adev->dev, "configuration of DMA Failed!\n"); - goto err_config_dma; - } - /* TODO: Implememt DMA setup of pipes here */ - - /* Enable target chip, set up transfer */ - pl022->cur_chip->cs_control(SSP_CHIP_SELECT); - if (set_up_next_transfer(pl022, pl022->cur_transfer)) { - /* Error path */ - pl022->cur_msg->state = STATE_ERROR; - pl022->cur_msg->status = -EIO; - giveback(pl022); + if (pl022->cur_chip->enable_dma) { + if (configure_dma(pl022)) { + dev_dbg(&pl022->adev->dev, + "configuration of DMA failed, fall back to interrupt mode\n"); + goto err_config_dma; + } return; } - /* Enable SSP */ - writew((readw(SSP_CR1(pl022->virtbase)) | SSP_CR1_MASK_SSE), - SSP_CR1(pl022->virtbase)); - - /* TODO: Enable the DMA transfer here */ - return; - err_config_dma: - pl022->cur_msg->state = STATE_ERROR; - pl022->cur_msg->status = -EIO; - giveback(pl022); - return; +err_config_dma: + writew(ENABLE_ALL_INTERRUPTS, SSP_IMSC(pl022->virtbase)); } -static void do_interrupt_transfer(void *data) +static void do_interrupt_dma_transfer(struct pl022 *pl022) { - struct pl022 *pl022 = data; + u32 irqflags = ENABLE_ALL_INTERRUPTS; /* Enable target chip */ pl022->cur_chip->cs_control(SSP_CHIP_SELECT); @@ -1023,15 +1359,26 @@ static void do_interrupt_transfer(void *data) giveback(pl022); return; } + /* If we're using DMA, set up DMA here */ + if (pl022->cur_chip->enable_dma) { + /* Configure DMA transfer */ + if (configure_dma(pl022)) { + dev_dbg(&pl022->adev->dev, + "configuration of DMA failed, fall back to interrupt mode\n"); + goto err_config_dma; + } + /* Disable interrupts in DMA mode, IRQ from DMA controller */ + irqflags = DISABLE_ALL_INTERRUPTS; + } +err_config_dma: /* Enable SSP, turn on interrupts */ writew((readw(SSP_CR1(pl022->virtbase)) | SSP_CR1_MASK_SSE), SSP_CR1(pl022->virtbase)); - writew(ENABLE_ALL_INTERRUPTS, SSP_IMSC(pl022->virtbase)); + writew(irqflags, SSP_IMSC(pl022->virtbase)); } -static void do_polling_transfer(void *data) +static void do_polling_transfer(struct pl022 *pl022) { - struct pl022 *pl022 = data; struct spi_message *message = NULL; struct spi_transfer *transfer = NULL; struct spi_transfer *previous = NULL; @@ -1101,7 +1448,7 @@ static void do_polling_transfer(void *data) * * This function checks if there is any spi message in the queue that * needs processing and delegate control to appropriate function - * do_polling_transfer()/do_interrupt_transfer()/do_dma_transfer() + * do_polling_transfer()/do_interrupt_dma_transfer() * based on the kind of the transfer * */ @@ -1150,10 +1497,8 @@ static void pump_messages(struct work_struct *work) if (pl022->cur_chip->xfer_type == POLLING_TRANSFER) do_polling_transfer(pl022); - else if (pl022->cur_chip->xfer_type == INTERRUPT_TRANSFER) - do_interrupt_transfer(pl022); else - do_dma_transfer(pl022); + do_interrupt_dma_transfer(pl022); } @@ -1469,23 +1814,6 @@ static int calculate_effective_freq(struct pl022 *pl022, } /** - * NOT IMPLEMENTED - * process_dma_info - Processes the DMA info provided by client drivers - * @chip_info: chip info provided by client device - * @chip: Runtime state maintained by the SSP controller for each spi device - * - * This function processes and stores DMA config provided by client driver - * into the runtime state maintained by the SSP controller driver - */ -static int process_dma_info(struct pl022_config_chip *chip_info, - struct chip_data *chip) -{ - dev_err(chip_info->dev, - "cannot process DMA info, DMA not implemented!\n"); - return -ENOTSUPP; -} - -/** * pl022_setup - setup function registered to SPI master framework * @spi: spi device which is requesting setup * @@ -1552,8 +1880,6 @@ static int pl022_setup(struct spi_device *spi) dev_dbg(&spi->dev, "allocated memory for controller data\n"); - /* Pointer back to the SPI device */ - chip_info->dev = &spi->dev; /* * Set controller data default values: * Polling is supported by default @@ -1579,6 +1905,9 @@ static int pl022_setup(struct spi_device *spi) "using user supplied controller_data settings\n"); } + /* Pointer back to the SPI device */ + chip_info->dev = &spi->dev; + /* * We can override with custom divisors, else we use the board * frequency setting @@ -1637,9 +1966,8 @@ static int pl022_setup(struct spi_device *spi) chip->cpsr = 0; if ((chip_info->com_mode == DMA_TRANSFER) && ((pl022->master_info)->enable_dma)) { - chip->enable_dma = 1; + chip->enable_dma = true; dev_dbg(&spi->dev, "DMA mode set in controller state\n"); - status = process_dma_info(chip_info, chip); if (status < 0) goto err_config_params; SSP_WRITE_BITS(chip->dmacr, SSP_DMA_ENABLED, @@ -1647,7 +1975,7 @@ static int pl022_setup(struct spi_device *spi) SSP_WRITE_BITS(chip->dmacr, SSP_DMA_ENABLED, SSP_DMACR_MASK_TXDMAE, 1); } else { - chip->enable_dma = 0; + chip->enable_dma = false; dev_dbg(&spi->dev, "DMA mode NOT set in controller state\n"); SSP_WRITE_BITS(chip->dmacr, SSP_DMA_DISABLED, SSP_DMACR_MASK_RXDMAE, 0); @@ -1773,6 +2101,7 @@ pl022_probe(struct amba_device *adev, struct amba_id *id) if (status) goto err_no_ioregion; + pl022->phybase = adev->res.start; pl022->virtbase = ioremap(adev->res.start, resource_size(&adev->res)); if (pl022->virtbase == NULL) { status = -ENOMEM; @@ -1799,6 +2128,14 @@ pl022_probe(struct amba_device *adev, struct amba_id *id) dev_err(&adev->dev, "probe - cannot get IRQ (%d)\n", status); goto err_no_irq; } + + /* Get DMA channels */ + if (platform_info->enable_dma) { + status = pl022_dma_probe(pl022); + if (status != 0) + goto err_no_dma; + } + /* Initialize and start queue */ status = init_queue(pl022); if (status != 0) { @@ -1827,6 +2164,8 @@ pl022_probe(struct amba_device *adev, struct amba_id *id) err_start_queue: err_init_queue: destroy_queue(pl022); + pl022_dma_remove(pl022); + err_no_dma: free_irq(adev->irq[0], pl022); err_no_irq: clk_put(pl022->clk); @@ -1857,6 +2196,7 @@ pl022_remove(struct amba_device *adev) return status; } load_ssp_default_config(pl022); + pl022_dma_remove(pl022); free_irq(adev->irq[0], pl022); clk_disable(pl022->clk); clk_put(pl022->clk); diff --git a/include/linux/amba/pl022.h b/include/linux/amba/pl022.h index abf26cc..db6a191 100644 --- a/include/linux/amba/pl022.h +++ b/include/linux/amba/pl022.h @@ -228,6 +228,7 @@ enum ssp_chip_select { }; +struct dma_chan; /** * struct pl022_ssp_master - device.platform_data for SPI controller devices. * @num_chipselect: chipselects are used to distinguish individual @@ -235,11 +236,16 @@ enum ssp_chip_select { * each slave has a chipselect signal, but it's common that not * every chipselect is connected to a slave. * @enable_dma: if true enables DMA driven transfers. + * @dma_rx_param: parameter to locate an RX DMA channel. + * @dma_tx_param: parameter to locate a TX DMA channel. */ struct pl022_ssp_controller { u16 bus_id; u8 num_chipselect; u8 enable_dma:1; + bool (*dma_filter)(struct dma_chan *chan, void *filter_param); + void *dma_rx_param; + void *dma_tx_param; }; /** -- 1.6.3.3 ^ permalink raw reply related [flat|nested] 10+ messages in thread
* [PATCH 2/6] ARM: add PrimeCell generic DMA to PL011 v10 2010-09-01 15:24 ` [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 Linus Walleij @ 2010-09-01 15:24 ` Linus Walleij 2010-09-01 15:24 ` [PATCH 3/6] ARM: add PrimeCell generic DMA to MMCI/PL180 v10 Linus Walleij 2010-09-23 21:31 ` [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 Dan Williams 1 sibling, 1 reply; 10+ messages in thread From: Linus Walleij @ 2010-09-01 15:24 UTC (permalink / raw) To: Dan Williams, linux-arm-kernel, yuanyabin1978; +Cc: linux-kernel, Linus Walleij This extends the PL011 UART driver with generic DMA engine support using the PrimeCell DMA engine interface. Tested-by: Jerzy Kasenberg <jerzy.kasenberg@tieto.com> Tested-by: Grzegorz Sygieda <grzegorz.sygieda@tieto.com> Tested-by: Marcin Mielczarczyk <marcin.mielczarczyk@tieto.com> Signed-off-by: Linus Walleij <linus.walleij@stericsson.com> --- drivers/serial/amba-pl011.c | 851 ++++++++++++++++++++++++++++++++++++++++++- include/linux/amba/serial.h | 6 + 2 files changed, 848 insertions(+), 9 deletions(-) diff --git a/drivers/serial/amba-pl011.c b/drivers/serial/amba-pl011.c index 6ca7a44..8a6ead8 100644 --- a/drivers/serial/amba-pl011.c +++ b/drivers/serial/amba-pl011.c @@ -7,6 +7,7 @@ * * Copyright 1999 ARM Limited * Copyright (C) 2000 Deep Blue Solutions Ltd. + * Copyright (C) 2010 ST-Ericsson SA * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -48,6 +49,11 @@ #include <linux/amba/serial.h> #include <linux/clk.h> #include <linux/slab.h> +#include <linux/dmaengine.h> +#include <linux/dma-mapping.h> +#include <linux/scatterlist.h> +#include <linux/completion.h> +#include <linux/delay.h> #include <asm/io.h> #include <asm/sizes.h> @@ -63,6 +69,24 @@ #define UART_DR_ERROR (UART011_DR_OE|UART011_DR_BE|UART011_DR_PE|UART011_DR_FE) #define UART_DUMMY_DR_RX (1 << 16) +/* Deals with DMA transactions */ +struct pl011_dma_rx_transaction { + struct completion complete; + bool use_buffer_b; + struct scatterlist scatter_a; + struct scatterlist scatter_b; + char *rx_dma_buf_a; + char *rx_dma_buf_b; + dma_cookie_t cookie; +}; + +struct pl011_dma_tx_transaction { + struct completion complete; + struct scatterlist scatter; + char *tx_dma_buf; + dma_cookie_t cookie; +}; + /* * We wrap our port structure around the generic uart_port. */ @@ -76,6 +100,16 @@ struct uart_amba_port { unsigned int lcrh_rx; /* vendor-specific */ bool oversampling; /* vendor-specific */ bool autorts; + unsigned int fifosize; + /* DMA stuff */ + bool enable_dma; + bool rx_dma_running; +#ifdef CONFIG_DMADEVICES + struct dma_chan *dma_rx_channel; + struct dma_chan *dma_tx_channel; + struct pl011_dma_rx_transaction dmarx; + struct pl011_dma_tx_transaction dmatx; +#endif }; /* There is by now at least one vendor with differing details, so handle it */ @@ -103,6 +137,725 @@ static struct vendor_data vendor_st = { .oversampling = true, }; +/* + * All the DMA operation mode stuff goes inside this ifdef. + * This assumes that you have a generic DMA device interface, + * no custom DMA interfaces are supported. + * + * If we had discardable probe() functions akin to + * platform_device_probe() in the PrimeCell/AMBA bus, we could + * discard most of this code after use, but since we haven't, + * we have to keep it all around. + */ +#ifdef CONFIG_DMADEVICES + +#define PL011_DMA_BUFFER_SIZE PAGE_SIZE + +static void pl011_dma_probe_initcall(struct uart_amba_port *uap) +{ + /* DMA is the sole user of the platform data right now */ + struct amba_pl011_data *plat = uap->port.dev->platform_data; + struct pl011_dma_rx_transaction *dmarx = &uap->dmarx; + struct pl011_dma_tx_transaction *dmatx = &uap->dmatx; + struct dma_slave_config rx_conf = { + .src_addr = uap->port.mapbase + UART01x_DR, + .src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE, + .direction = DMA_FROM_DEVICE, + .src_maxburst = uap->fifosize >> 1, + }; + struct dma_slave_config tx_conf = { + .dst_addr = uap->port.mapbase + UART01x_DR, + .dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE, + .direction = DMA_TO_DEVICE, + .dst_maxburst = uap->fifosize >> 1, + }; + dma_cap_mask_t mask; + int sglen; + + /* We need platform data */ + if (!plat) { + dev_err(uap->port.dev, "no DMA platform data!\n"); + return; + } + + /* Try to acquire a generic DMA engine slave channel */ + dma_cap_zero(mask); + dma_cap_set(DMA_SLAVE, mask); + + /* + * We need both RX and TX channels to do DMA, else do none + * of them. + */ + uap->dma_rx_channel = dma_request_channel(mask, + plat->dma_filter, + plat->dma_rx_param); + if (!uap->dma_rx_channel) { + dev_err(uap->port.dev, "no RX DMA channel!\n"); + return; + } + uap->dma_rx_channel->device->device_control(uap->dma_rx_channel, + DMA_SLAVE_CONFIG, + (unsigned long) &rx_conf); + + uap->dma_tx_channel = dma_request_channel(mask, + plat->dma_filter, + plat->dma_tx_param); + if (!uap->dma_tx_channel) { + dev_err(uap->port.dev, "no TX DMA channel!\n"); + goto err_no_txchan; + } + uap->dma_tx_channel->device->device_control(uap->dma_tx_channel, + DMA_SLAVE_CONFIG, + (unsigned long) &tx_conf); + + /* Allocate DMA RX and TX buffers */ + dmarx->rx_dma_buf_a = kmalloc(PL011_DMA_BUFFER_SIZE, GFP_KERNEL); + if (!dmarx->rx_dma_buf_a) { + dev_err(uap->port.dev, "failed to allocate DMA RX buffer A\n"); + goto err_no_rxbuf_a; + } + + dmarx->rx_dma_buf_b = kmalloc(PL011_DMA_BUFFER_SIZE, GFP_KERNEL); + if (!dmarx->rx_dma_buf_b) { + dev_err(uap->port.dev, "failed to allocate DMA RX buffer B\n"); + goto err_no_rxbuf_b; + } + + dmatx->tx_dma_buf = kmalloc(PL011_DMA_BUFFER_SIZE, GFP_KERNEL); + if (!dmatx->tx_dma_buf) { + dev_err(uap->port.dev, "failed to allocate DMA TX buffer\n"); + goto err_no_txbuf; + } + + /* Provide single SG list with one item to the buffers */ + sg_init_one(&dmarx->scatter_a, dmarx->rx_dma_buf_a, + PL011_DMA_BUFFER_SIZE); + sg_init_one(&dmarx->scatter_b, dmarx->rx_dma_buf_b, + PL011_DMA_BUFFER_SIZE); + sg_init_one(&dmatx->scatter, dmatx->tx_dma_buf, PL011_DMA_BUFFER_SIZE); + + /* Map DMA buffers */ + sglen = dma_map_sg(uap->port.dev, &dmarx->scatter_a, + 1, DMA_FROM_DEVICE); + if (sglen != 1) + goto err_rx_sgmap_a; + + sglen = dma_map_sg(uap->port.dev, &dmarx->scatter_b, + 1, DMA_FROM_DEVICE); + if (sglen != 1) + goto err_rx_sgmap_b; + + sglen = dma_map_sg(uap->port.dev, &dmatx->scatter, + 1, DMA_TO_DEVICE); + if (sglen != 1) + goto err_tx_sgmap; + + /* Initially we say the transfers are incomplete */ + init_completion(&uap->dmatx.complete); + complete(&uap->dmatx.complete); + + /* The DMA buffer is now the FIFO the TTY subsystem can use */ + uap->port.fifosize = PL011_DMA_BUFFER_SIZE; + + uap->enable_dma = true; + dev_info(uap->port.dev, "setup for DMA on RX %s, TX %s\n", + dma_chan_name(uap->dma_rx_channel), + dma_chan_name(uap->dma_tx_channel)); + return; + +err_tx_sgmap: + dma_unmap_sg(uap->port.dev, &dmarx->scatter_b, + 1, DMA_FROM_DEVICE); +err_rx_sgmap_b: + dma_unmap_sg(uap->port.dev, &dmarx->scatter_a, + 1, DMA_FROM_DEVICE); +err_rx_sgmap_a: + kfree(dmatx->tx_dma_buf); +err_no_txbuf: + kfree(dmarx->rx_dma_buf_b); +err_no_rxbuf_b: + kfree(dmarx->rx_dma_buf_a); +err_no_rxbuf_a: + dma_release_channel(uap->dma_tx_channel); + uap->dma_tx_channel = NULL; +err_no_txchan: + dma_release_channel(uap->dma_rx_channel); + uap->dma_rx_channel = NULL; + return; +} + +/* + * Stack up the UARTs and let the above initcall be done at + * device initcall time, because the serial driver is called as + * an arch initcall, and at this time the DMA subsystem is not yet + * registered. At this point the driver will switch over to using + * DMA where desired. + */ + +struct dma_uap { + struct list_head node; + struct uart_amba_port *uap; +}; + +struct list_head pl011_dma_uarts = LIST_HEAD_INIT(pl011_dma_uarts); + +static int pl011_dma_initcall(void) +{ + struct list_head *node, *tmp; + + list_for_each_safe(node, tmp, &pl011_dma_uarts) { + struct dma_uap *dmau = list_entry(node, struct dma_uap, node); + pl011_dma_probe_initcall(dmau->uap); + list_del(node); + kfree(dmau); + } + return 0; +} + +device_initcall(pl011_dma_initcall); + +static void pl011_dma_probe(struct uart_amba_port *uap) +{ + struct dma_uap *dmau = kzalloc(sizeof(struct dma_uap), GFP_KERNEL); + + if (dmau == NULL) + return; + dmau->uap = uap; + list_add_tail(&dmau->node, &pl011_dma_uarts); +} + +static void pl011_dma_remove(struct uart_amba_port *uap) +{ + struct pl011_dma_rx_transaction *dmarx = &uap->dmarx; + struct pl011_dma_tx_transaction *dmatx = &uap->dmatx; + + /* TODO: remove the initcall if it has not yet executed */ + /* Unmap and free DMA buffers */ + if (uap->dma_rx_channel) + dma_release_channel(uap->dma_rx_channel); + if (uap->dma_tx_channel) + dma_release_channel(uap->dma_tx_channel); + if (dmatx->tx_dma_buf) { + dma_unmap_sg(uap->port.dev, &dmatx->scatter, + 1, DMA_TO_DEVICE); + kfree(dmatx->tx_dma_buf); + } + if (dmarx->rx_dma_buf_b) { + dma_unmap_sg(uap->port.dev, &dmarx->scatter_b, + 1, DMA_FROM_DEVICE); + kfree(dmarx->rx_dma_buf_b); + } + if (dmarx->rx_dma_buf_a) { + dma_unmap_sg(uap->port.dev, &dmarx->scatter_a, + 1, DMA_FROM_DEVICE); + kfree(dmarx->rx_dma_buf_a); + } +} + +/* Forward declare this for the refill routine */ +static int pl011_dma_tx_refill(struct uart_amba_port *uap); + +/* + * Move the tail when this IRQ occurs, if not empty refill and + * fire another transaction + */ +static void pl011_dma_tx_callback(void *data) +{ + struct uart_amba_port *uap = data; + struct pl011_dma_tx_transaction *dmatx = &uap->dmatx; + struct circ_buf *xmit = &uap->port.state->xmit; + u16 val; + int ret; + + /* Temporarily disable TX DMA */ + val = readw(uap->port.membase + UART011_DMACR); + val &= ~(UART011_TXDMAE); + writew(val, uap->port.membase + UART011_DMACR); + + /* Refill the TX if the buffer is not empty */ + if (!uart_circ_empty(xmit)) { + ret = pl011_dma_tx_refill(uap); + if (ret == -EBUSY) + /* + * If DMA cannot be used right now, we complete this + * transaction and let the TTY layer retry. If the + * firs following xfer fails to set up for DMA, it + * will fall through to interrupt mode. + */ + dev_dbg(uap->port.dev, "DMA busy\n"); + } else { + complete(&dmatx->complete); + } +} + +static int pl011_dma_tx_refill(struct uart_amba_port *uap) +{ + struct pl011_dma_tx_transaction *dmatx = &uap->dmatx; + struct dma_chan *chan = uap->dma_tx_channel; + struct dma_async_tx_descriptor *desc; + struct circ_buf *xmit = &uap->port.state->xmit; + unsigned int count; + unsigned long flags; + u16 val; + + /* Don't bother about using DMA on XON/XOFF */ + if (uap->port.x_char) { + /* If we can't get it into the FIFO, retry later */ + if (readw(uap->port.membase + UART01x_FR) & + UART01x_FR_TXFF) { + complete(&dmatx->complete); + return 0; + } + writew(uap->port.x_char, uap->port.membase + UART01x_DR); + uap->port.icount.tx++; + uap->port.x_char = 0; + complete(&dmatx->complete); + return 0; + } + + /* + * Try to avoid the overhead involved in using DMA if the + * transaction fits in the first half of the FIFO and it's not + * full. Unfortunately there is only one single bit in the + * hardware to tell whether the FIFO is full or not, so + * we don't know exactly how many chars we can fit in. + */ + if (uart_circ_chars_pending(xmit) < (uap->fifosize >> 1)) { + while (uart_circ_chars_pending(xmit)) { + if (readw(uap->port.membase + UART01x_FR) & + UART01x_FR_TXFF) { + /* + * Ooops TX FIFO is full, we'd better stop + * this. Let's enable TX interrupt here to get + * informed when there is again some space in + * the TX FIFO so we can continue the transfer. + * This interrupt will be cleared just before + * setting up DMA, as it could interfere with + * TX interrupt handling routine. + */ + uap->im |= UART011_TXIM; + writew(uap->im, + uap->port.membase + UART011_IMSC); + break; + } + writew(xmit->buf[xmit->tail], + uap->port.membase + UART01x_DR); + uap->port.icount.tx++; + xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); + } + complete(&dmatx->complete); + return 0; + } + + /* + * Clear TX interrupt to be sure that DMA will not interfere with + * TX ISR + */ + local_irq_save(flags); + uap->im &= ~UART011_TXIM; + writew(uap->im, uap->port.membase + UART011_IMSC); + local_irq_restore(flags); + + /* Sync the buffer for the CPU so we can write into it */ + dma_sync_sg_for_cpu(uap->port.dev, + &dmatx->scatter, + 1, + DMA_TO_DEVICE); + + /* Else proceed to copy the TX chars to the DMA buffer and fire DMA */ + count = uart_circ_chars_pending(xmit); + if (count > PL011_DMA_BUFFER_SIZE) + count = PL011_DMA_BUFFER_SIZE; + + if (xmit->tail < xmit->head) + memcpy(&dmatx->tx_dma_buf[0], &xmit->buf[xmit->tail], count); + else { + size_t first = UART_XMIT_SIZE - xmit->tail; + size_t second = xmit->head; + + memcpy(&dmatx->tx_dma_buf[0], &xmit->buf[xmit->tail], first); + memcpy(&dmatx->tx_dma_buf[first], &xmit->buf[0], second); + } + + dmatx->scatter.length = count; + + /* Synchronize the scatterlist, invalidate buffers, caches etc */ + dma_sync_sg_for_device(uap->port.dev, + &dmatx->scatter, + 1, + DMA_TO_DEVICE); + + /* Prepare the scatterlist */ + desc = chan->device->device_prep_slave_sg(chan, + &dmatx->scatter, + 1, + DMA_TO_DEVICE, + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); + if (!desc) { + /* "Complete" DMA (errorpath) */ + complete(&dmatx->complete); + chan->device->device_control(chan, DMA_TERMINATE_ALL, 0); + return -EBUSY; + } + + /* Some data to go along to the callback */ + desc->callback = pl011_dma_tx_callback; + desc->callback_param = uap; + + /* Here is where overloaded DMA controllers can fail */ + dmatx->cookie = desc->tx_submit(desc); + if (dma_submit_error(dmatx->cookie)) { + /* "Complete" DMA (errorpath) */ + complete(&dmatx->complete); + chan->device->device_control(chan, DMA_TERMINATE_ALL, 0); + return dmatx->cookie; + } + + /* + * Now we know that DMA will fire, so advance the ring buffer + * with the stuff we just dispatched + */ + xmit->tail = (xmit->tail + count) & (UART_XMIT_SIZE - 1); + uap->port.icount.tx += count; + if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) + uart_write_wakeup(&uap->port); + + /* Fire the DMA transaction */ + chan->device->device_issue_pending(chan); + + val = readw(uap->port.membase + UART011_DMACR); + val |= UART011_TXDMAE; + writew(val, uap->port.membase + UART011_DMACR); + return 0; +} + +static void pl011_dma_rx_callback(void *data); + +static int pl011_dma_rx_trigger_dma(struct uart_amba_port *uap) +{ + struct dma_chan *rxchan = uap->dma_rx_channel; + struct pl011_dma_rx_transaction *dmarx = &uap->dmarx; + struct dma_async_tx_descriptor *desc; + struct scatterlist *scatter = dmarx->use_buffer_b ? + &dmarx->scatter_b : &dmarx->scatter_a; + u16 val; + + /* Start the RX DMA job */ + desc = rxchan->device->device_prep_slave_sg(rxchan, + scatter, + 1, + DMA_FROM_DEVICE, + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); + /* + * If the DMA engine is busy and cannot prepare a + * channel, no big deal, the driver will fall back + * to interrupt mode as a result of this error code. + */ + if (!desc) { + uap->rx_dma_running = false; + rxchan->device->device_control(rxchan, DMA_TERMINATE_ALL, 0); + return -EBUSY; + } + + /* Some data to go along to the callback */ + desc->callback = pl011_dma_rx_callback; + desc->callback_param = uap; + /* This is another point where an overloaded engine can fail */ + dmarx->cookie = desc->tx_submit(desc); + if (dma_submit_error(dmarx->cookie)) { + uap->rx_dma_running = false; + rxchan->device->device_control(rxchan, DMA_TERMINATE_ALL, 0); + return -EBUSY; + } + + rxchan->device->device_issue_pending(rxchan); + + val = readw(uap->port.membase + UART011_DMACR); + val |= UART011_RXDMAE; + writew(val, uap->port.membase + UART011_DMACR); + uap->rx_dma_running = true; + + return 0; +} + +/* + * This is called when either the DMA job is complete, or + * the FIFO timeout interrupt occurred. This must be called + * with the port spinlock uap->port.lock held. + */ +static void pl011_dma_rx_chars(struct uart_amba_port *uap, + u32 pending, bool use_buffer_b, + bool readfifo) +{ + struct pl011_dma_rx_transaction *dmarx = &uap->dmarx; + struct tty_struct *tty = uap->port.state->port.tty; + char *buf = use_buffer_b ? dmarx->rx_dma_buf_b : dmarx->rx_dma_buf_a; + struct scatterlist *scatter = use_buffer_b ? + &dmarx->scatter_b : &dmarx->scatter_a; + unsigned int status, ch, flag; + u32 count = pending; + u32 bufp = 0; + u32 fifotaken = 0; /* only used for vdbg() */ + + /* Sync in buffer */ + dma_sync_sg_for_cpu(uap->port.dev, + scatter, + 1, + DMA_FROM_DEVICE); + + status = readw(uap->port.membase + UART01x_FR); + + /* + * First take all chars in the DMA pipe, then look + * in the FIFO. So loop while we have chars in the + * DMA buffer or the FIFO. If we came here from a + * DMA buffer full interrupt, there is already another + * DMA job triggered to read the FIFO, so don't look + * at it. + */ + while (count || + (readfifo && (status & UART01x_FR_RXFE) == 0)) { + + flag = TTY_NORMAL; + uap->port.icount.rx++; + + if (count) { + /* Take chars from the DMA buffer */ + int inserted = tty_insert_flip_string( + uap->port.state->port.tty, buf, count); + + /* + * Check if insertion is successful to avoid + * infinite loop. This can happen when TTY is full. + */ + if (unlikely(inserted == 0)) + count = 0; + else { + count -= inserted; + bufp += inserted; + } + continue; + } else { + /* Take chars from the FIFO and update status */ + ch = readw(uap->port.membase + UART01x_DR); + status = readw(uap->port.membase + UART01x_FR); + fifotaken++; + + /* + * Error conditions will only occur in the FIFO, + * these will trigger an immediate interrupt and + * stop the DMA job, so we will always find the + * error in the FIFO, never in the DMA buffer. + */ + if (unlikely(ch & UART_DR_ERROR)) { + if (ch & UART011_DR_BE) { + ch &= ~(UART011_DR_FE | UART011_DR_PE); + uap->port.icount.brk++; + if (uart_handle_break(&uap->port)) + continue; + } else if (ch & UART011_DR_PE) + uap->port.icount.parity++; + else if (ch & UART011_DR_FE) + uap->port.icount.frame++; + if (ch & UART011_DR_OE) + uap->port.icount.overrun++; + + ch &= uap->port.read_status_mask; + + if (ch & UART011_DR_BE) + flag = TTY_BREAK; + else if (ch & UART011_DR_PE) + flag = TTY_PARITY; + else if (ch & UART011_DR_FE) + flag = TTY_FRAME; + } + } + + if (uart_handle_sysrq_char(&uap->port, ch & 255)) + continue; + + uart_insert_char(&uap->port, ch, UART011_DR_OE, ch, flag); + } + + spin_unlock(&uap->port.lock); + dev_vdbg(uap->port.dev, + "Took %d chars from DMA buffer and %d chars from the FIFO\n", + bufp, fifotaken); + tty_flip_buffer_push(tty); + spin_lock(&uap->port.lock); +} + +static void pl011_dma_rx_irq(struct uart_amba_port *uap) +{ + struct dma_chan *rxchan = uap->dma_rx_channel; + struct pl011_dma_rx_transaction *dmarx = &uap->dmarx; + struct scatterlist *scatter = dmarx->use_buffer_b ? + &dmarx->scatter_b : &dmarx->scatter_a; + u32 pending; + int ret; + struct dma_tx_state state; + enum dma_status dmastat; + u16 val; + + /* Use PrimeCell DMA extensions to stop the transfer */ + ret = rxchan->device->device_control(rxchan, DMA_PAUSE, 0); + if (ret) + dev_err(uap->port.dev, "unable to pause DMA transfer\n"); + dmastat = rxchan->device->device_tx_status(rxchan, + dmarx->cookie, &state); + + /* Disable RX DMA temporarily */ + val = readw(uap->port.membase + UART011_DMACR); + val &= ~(UART011_RXDMAE); + writew(val, uap->port.membase + UART011_DMACR); + uap->rx_dma_running = false; + + if (dmastat != DMA_PAUSED) + dev_err(uap->port.dev, "unable to pause DMA transfer\n"); + pending = scatter->length - state.residue; + + BUG_ON(pending > PL011_DMA_BUFFER_SIZE); + + ret = rxchan->device->device_control(rxchan, DMA_TERMINATE_ALL, 0); + if (ret) + dev_err(uap->port.dev, "unable to terminate DMA transfer\n"); + + /* + * This will take the chars we have so far and insert + * into the framework. + */ + pl011_dma_rx_chars(uap, pending, dmarx->use_buffer_b, true); + + /* Switch buffer & re-trigger DMA job */ + dmarx->use_buffer_b = !dmarx->use_buffer_b; + ret = pl011_dma_rx_trigger_dma(uap); + if (ret) { + dev_dbg(uap->port.dev, "could not retrigger RX DMA job " + "fall back to interrupt mode\n"); + uap->im |= UART011_RXIM; + writew(uap->im, uap->port.membase + UART011_IMSC); + } +} + +static void pl011_dma_rx_callback(void *data) +{ + struct uart_amba_port *uap = data; + struct pl011_dma_rx_transaction *dmarx = &uap->dmarx; + bool lastbuf = dmarx->use_buffer_b; + int ret; + + /* + * This completion interrupt occurs typically when the + * RX buffer is totally stuffed but no timeout has yet + * occurred. When that happens, we just want the RX + * routine to flush out the secondary DMA buffer while + * we immediately trigger the next DMA job. + */ + uap->rx_dma_running = false; + dmarx->use_buffer_b = !lastbuf; + ret = pl011_dma_rx_trigger_dma(uap); + + spin_lock_irq(&uap->port.lock); + pl011_dma_rx_chars(uap, PL011_DMA_BUFFER_SIZE, lastbuf, false); + spin_unlock_irq(&uap->port.lock); + /* + * Do this check after we picked the DMA chars so we don't + * get some IRQ immediately from RX. + */ + if (ret) { + dev_dbg(uap->port.dev, "could not retrigger RX DMA job " + "fall back to interrupt mode\n"); + uap->im |= UART011_RXIM; + writew(uap->im, uap->port.membase + UART011_IMSC); + } +} + +static void pl011_dma_startup(struct uart_amba_port *uap) +{ + u16 val; + int ret = 0; + + if (!uap->enable_dma) + return; + + /* Turn on DMA error (RX/TX will be enabled on demand) */ + val = readw(uap->port.membase + UART011_DMACR); + val |= UART011_DMAONERR; + writew(val, uap->port.membase + UART011_DMACR); + + ret = pl011_dma_rx_trigger_dma(uap); + if (ret) + dev_dbg(uap->port.dev, "could not trigger initial " + "RX DMA job, fall back to interrupt mode\n"); +} + +static void pl011_dma_shutdown(struct uart_amba_port *uap) +{ + struct dma_chan *rxchan = uap->dma_rx_channel; + struct dma_chan *txchan = uap->dma_tx_channel; + u16 val; + + if (!uap->enable_dma) + return; + + /* Disable RX and TX DMA */ + while (readw(uap->port.membase + UART01x_FR) & UART01x_FR_BUSY) + barrier(); + val = readw(uap->port.membase + UART011_DMACR); + val &= ~(UART011_DMAONERR | UART011_RXDMAE | UART011_TXDMAE); + writew(val, uap->port.membase + UART011_DMACR); + /* Terminate any RX and TX DMA jobs */ + rxchan->device->device_control(rxchan, DMA_TERMINATE_ALL, 0); + txchan->device->device_control(txchan, DMA_TERMINATE_ALL, 0); +} + +static int pl011_dma_tx_chars(struct uart_amba_port *uap) +{ + struct pl011_dma_tx_transaction *dmatx = &uap->dmatx; + + /* Try to wait for completion, return if something is in progress */ + if (!try_wait_for_completion(&dmatx->complete)) + return -EINPROGRESS; + + /* Set up and fire the DMA job */ + init_completion(&dmatx->complete); + return pl011_dma_tx_refill(uap); +} + +#else +/* Blank functions if the DMA engine is not available */ +static inline void pl011_dma_probe(struct uart_amba_port *uap) +{ +} + +static inline void pl011_dma_remove(struct uart_amba_port *uap) +{ +} + +static inline void pl011_dma_rx_irq(struct uart_amba_port *uap) +{ +} + +static inline int pl011_dma_rx_trigger_dma(struct uart_amba_port *uap) +{ + return -EIO; +} + +static inline void pl011_dma_startup(struct uart_amba_port *uap) +{ +} + +static inline void pl011_dma_shutdown(struct uart_amba_port *uap) +{ +} + +static inline int pl011_dma_tx_chars(struct uart_amba_port *uap) +{ + return -EIO; +} +#endif + + static void pl011_stop_tx(struct uart_port *port) { struct uart_amba_port *uap = (struct uart_amba_port *)port; @@ -111,10 +864,18 @@ static void pl011_stop_tx(struct uart_port *port) writew(uap->im, uap->port.membase + UART011_IMSC); } +static void pl011_tx_chars(struct uart_amba_port *uap); + static void pl011_start_tx(struct uart_port *port) { struct uart_amba_port *uap = (struct uart_amba_port *)port; + if (uap->enable_dma) { + /* Immediately push out chars in DMA mode */ + pl011_tx_chars(uap); + return; + } + /* In interrupt mode, let the interrupt pull chars */ uap->im |= UART011_TXIM; writew(uap->im, uap->port.membase + UART011_IMSC); } @@ -140,6 +901,7 @@ static void pl011_rx_chars(struct uart_amba_port *uap) { struct tty_struct *tty = uap->port.state->port.tty; unsigned int status, ch, flag, max_count = 256; + int ret; status = readw(uap->port.membase + UART01x_FR); while ((status & UART01x_FR_RXFE) == 0 && max_count--) { @@ -184,6 +946,21 @@ static void pl011_rx_chars(struct uart_amba_port *uap) } spin_unlock(&uap->port.lock); tty_flip_buffer_push(tty); + /* + * If we were temporarily out of DMA mode for a while, + * attempt to switch back to DMA mode again. + */ + if (uap->enable_dma) { + uap->im &= ~UART011_RXIM; + writew(uap->im, uap->port.membase + UART011_IMSC); + ret = pl011_dma_rx_trigger_dma(uap); + if (ret) { + dev_dbg(uap->port.dev, "could not trigger RX DMA job " + "fall back to interrupt mode again\n"); + uap->im |= UART011_RXIM; + writew(uap->im, uap->port.membase + UART011_IMSC); + } + } spin_lock(&uap->port.lock); } @@ -192,6 +969,25 @@ static void pl011_tx_chars(struct uart_amba_port *uap) struct circ_buf *xmit = &uap->port.state->xmit; int count; + if (uap->enable_dma) { + int ret; + + ret = pl011_dma_tx_chars(uap); + if (!ret) + return; + if (ret == -EINPROGRESS) + return; + + /* + * On any other error (including -EBUSY which is emitted + * in case the DMA engine is out of physical channels + * for example) we fall through to interrupt mode + */ + dev_dbg(uap->port.dev, "DMA unavailable for TX\n"); + uap->im |= UART011_TXIM; + writew(uap->im, uap->port.membase + UART011_IMSC); + } + if (uap->port.x_char) { writew(uap->port.x_char, uap->port.membase + UART01x_DR); uap->port.icount.tx++; @@ -203,8 +999,10 @@ static void pl011_tx_chars(struct uart_amba_port *uap) return; } - count = uap->port.fifosize >> 1; + count = uap->fifosize >> 1; do { + if (readw(uap->port.membase + UART01x_FR) & UART01x_FR_TXFF) + break; writew(xmit->buf[xmit->tail], uap->port.membase + UART01x_DR); xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); uap->port.icount.tx++; @@ -249,7 +1047,7 @@ static irqreturn_t pl011_int(int irq, void *dev_id) unsigned int status, pass_counter = AMBA_ISR_PASS_LIMIT; int handled = 0; - spin_lock(&uap->port.lock); + spin_lock_irq(&uap->port.lock); status = readw(uap->port.membase + UART011_MIS); if (status) { @@ -258,13 +1056,30 @@ static irqreturn_t pl011_int(int irq, void *dev_id) UART011_RXIS), uap->port.membase + UART011_ICR); - if (status & (UART011_RTIS|UART011_RXIS)) - pl011_rx_chars(uap); + if (status & (UART011_RTIS|UART011_RXIS)) { + if (uap->enable_dma && uap->rx_dma_running) + pl011_dma_rx_irq(uap); + else + pl011_rx_chars(uap); + } if (status & (UART011_DSRMIS|UART011_DCDMIS| UART011_CTSMIS|UART011_RIMIS)) pl011_modem_status(uap); - if (status & UART011_TXIS) + if (status & UART011_TXIS) { + /* + * When DMA is enabled we still use TX + * interrupt to send small amounts of data, + * and as a fallback when the DMA channel is + * not available. This interrupt is cleared + * here and will be enabled when it's needed. + */ + if (uap->enable_dma) { + uap->im &= ~UART011_TXIM; + writew(uap->im, + uap->port.membase + UART011_IMSC); + } pl011_tx_chars(uap); + } if (pass_counter-- == 0) break; @@ -274,7 +1089,7 @@ static irqreturn_t pl011_int(int irq, void *dev_id) handled = 1; } - spin_unlock(&uap->port.lock); + spin_unlock_irq(&uap->port.lock); return IRQ_RETVAL(handled); } @@ -423,16 +1238,28 @@ static int pl011_startup(struct uart_port *port) cr = UART01x_CR_UARTEN | UART011_CR_RXE | UART011_CR_TXE; writew(cr, uap->port.membase + UART011_CR); + /* Clear pending error interrupts*/ + writew(0xFFFF & ~(UART011_TXIS | UART011_RTIS | UART011_RXIS), + uap->port.membase + UART011_ICR); + /* * initialise the old status of the modem signals */ uap->old_status = readw(uap->port.membase + UART01x_FR) & UART01x_FR_MODEM_ANY; + /* Startup DMA */ + pl011_dma_startup(uap); + /* - * Finally, enable interrupts + * Finally, enable interrupts, only timeouts when using DMA + * if initial RX DMA job failed, start in interrupt mode + * as well. */ spin_lock_irq(&uap->port.lock); - uap->im = UART011_RXIM | UART011_RTIM; + if (uap->enable_dma && uap->rx_dma_running) + uap->im = UART011_RTIM; + else + uap->im = UART011_RXIM | UART011_RTIM; writew(uap->im, uap->port.membase + UART011_IMSC); spin_unlock_irq(&uap->port.lock); @@ -467,6 +1294,8 @@ static void pl011_shutdown(struct uart_port *port) writew(0xffff, uap->port.membase + UART011_ICR); spin_unlock_irq(&uap->port.lock); + pl011_dma_shutdown(uap); + /* * Free the interrupt */ @@ -532,7 +1361,7 @@ pl011_set_termios(struct uart_port *port, struct ktermios *termios, if (!(termios->c_cflag & PARODD)) lcr_h |= UART01x_LCRH_EPS; } - if (port->fifosize > 1) + if (uap->fifosize > 1) lcr_h |= UART01x_LCRH_FEN; spin_lock_irqsave(&port->lock, flags); @@ -871,6 +1700,8 @@ static int pl011_probe(struct amba_device *dev, struct amba_id *id) uap->port.ops = &amba_pl011_pops; uap->port.flags = UPF_BOOT_AUTOCONF; uap->port.line = i; + uap->fifosize = vendor->fifosize; + pl011_dma_probe(uap); amba_ports[i] = uap; @@ -879,6 +1710,7 @@ static int pl011_probe(struct amba_device *dev, struct amba_id *id) if (ret) { amba_set_drvdata(dev, NULL); amba_ports[i] = NULL; + pl011_dma_remove(uap); clk_put(uap->clk); unmap: iounmap(base); @@ -902,6 +1734,7 @@ static int pl011_remove(struct amba_device *dev) if (amba_ports[i] == uap) amba_ports[i] = NULL; + pl011_dma_remove(uap); iounmap(uap->port.membase); clk_put(uap->clk); kfree(uap); diff --git a/include/linux/amba/serial.h b/include/linux/amba/serial.h index e1b634b..e00744f 100644 --- a/include/linux/amba/serial.h +++ b/include/linux/amba/serial.h @@ -169,6 +169,12 @@ struct amba_device; /* in uncompress this is included but amba/bus.h is not */ struct amba_pl010_data { void (*set_mctrl)(struct amba_device *dev, void __iomem *base, unsigned int mctrl); }; +struct dma_chan; +struct amba_pl011_data { + bool (*dma_filter)(struct dma_chan *chan, void *filter_param); + void *dma_rx_param; + void *dma_tx_param; +}; #endif #endif -- 1.6.3.3 ^ permalink raw reply related [flat|nested] 10+ messages in thread
* [PATCH 3/6] ARM: add PrimeCell generic DMA to MMCI/PL180 v10 2010-09-01 15:24 ` [PATCH 2/6] ARM: add PrimeCell generic DMA to PL011 v10 Linus Walleij @ 2010-09-01 15:24 ` Linus Walleij 2010-09-01 15:24 ` [PATCH 4/6] ARM: config U300 PL180 PL011 PL022 for DMA v10 Linus Walleij 0 siblings, 1 reply; 10+ messages in thread From: Linus Walleij @ 2010-09-01 15:24 UTC (permalink / raw) To: Dan Williams, linux-arm-kernel, yuanyabin1978; +Cc: linux-kernel, Linus Walleij This extends the MMCI/PL180 driver with generic DMA engine support using the PrimeCell DMA engine interface. Signed-off-by: Linus Walleij <linus.walleij@stericsson.com> --- drivers/mmc/host/mmci.c | 329 ++++++++++++++++++++++++++++++++++++++++----- drivers/mmc/host/mmci.h | 16 +++ include/linux/amba/mmci.h | 16 +++ 3 files changed, 330 insertions(+), 31 deletions(-) diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c index f0c7313..876a293 100644 --- a/drivers/mmc/host/mmci.c +++ b/drivers/mmc/host/mmci.c @@ -2,7 +2,7 @@ * linux/drivers/mmc/host/mmci.c - ARM PrimeCell MMCI PL180/1 driver * * Copyright (C) 2003 Deep Blue Solutions, Ltd, All Rights Reserved. - * Copyright (C) 2010 ST-Ericsson AB. + * Copyright (C) 2010 ST-Ericsson SA * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as @@ -23,8 +23,10 @@ #include <linux/clk.h> #include <linux/scatterlist.h> #include <linux/gpio.h> -#include <linux/amba/mmci.h> #include <linux/regulator/consumer.h> +#include <linux/dmaengine.h> +#include <linux/dma-mapping.h> +#include <linux/amba/mmci.h> #include <asm/div64.h> #include <asm/io.h> @@ -40,6 +42,7 @@ static unsigned int fmax = 515633; * struct variant_data - MMCI variant-specific quirks * @clkreg: default value for MCICLOCK register * @clkreg_enable: enable value for MMCICLOCK register + * @dmareg_enable: enable value for MMCIDATACTRL register * @datalength_bits: number of bits in the MMCIDATALENGTH register * @fifosize: number of bytes that can be written when MMCI_TXFIFOEMPTY * is asserted (likewise for RX) @@ -50,6 +53,7 @@ static unsigned int fmax = 515633; struct variant_data { unsigned int clkreg; unsigned int clkreg_enable; + unsigned int dmareg_enable; unsigned int datalength_bits; unsigned int fifosize; unsigned int fifohalfsize; @@ -74,6 +78,7 @@ static struct variant_data variant_ux500 = { .fifohalfsize = 8 * 4, .clkreg = MCI_CLK_ENABLE, .clkreg_enable = 1 << 14, /* HWFCEN */ + .dmareg_enable = 1 << 12, /* DMAREQCTRL */ .datalength_bits = 24, .singleirq = true, }; @@ -169,6 +174,203 @@ static void mmci_init_sg(struct mmci_host *host, struct mmc_data *data) sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags); } +/* + * All the DMA operation mode stuff goes inside this ifdef. + * This assumes that you have a generic DMA device interface, + * no custom DMA interfaces are supported. + */ +#ifdef CONFIG_DMADEVICES +static void __devinit mmci_setup_dma(struct mmci_host *host) +{ + struct mmci_platform_data *plat = host->plat; + dma_cap_mask_t mask; + + if (!plat || !plat->dma_filter) { + dev_err(mmc_dev(host->mmc), "no DMA platform data!\n"); + return; + } + + /* Try to acquire a generic DMA engine slave channel */ + dma_cap_zero(mask); + dma_cap_set(DMA_SLAVE, mask); + /* + * If only an RX channel is specified, the driver will + * attempt to use it bidirectionally, however if it is + * is specified but cannot be located, DMA will be disabled. + */ + host->dma_rx_channel = dma_request_channel(mask, + plat->dma_filter, + plat->dma_rx_param); + /* E.g if no DMA hardware is present */ + if (!host->dma_rx_channel) { + dev_err(mmc_dev(host->mmc), "no RX DMA channel!\n"); + return; + } + if (plat->dma_tx_param) { + host->dma_tx_channel = dma_request_channel(mask, + plat->dma_filter, + plat->dma_tx_param); + if (!host->dma_tx_channel) { + dma_release_channel(host->dma_rx_channel); + host->dma_rx_channel = NULL; + return; + } + } else { + host->dma_tx_channel = host->dma_rx_channel; + } + host->dma_enable = true; + dev_info(mmc_dev(host->mmc), "use DMA channels DMA RX %s, DMA TX %s\n", + dma_chan_name(host->dma_rx_channel), + dma_chan_name(host->dma_tx_channel)); +} + +/* + * This is used in __devinit or __devexit so inline it + * so it can be discarded. + */ +static inline void mmci_disable_dma(struct mmci_host *host) +{ + if (host->dma_rx_channel) + dma_release_channel(host->dma_rx_channel); + if (host->dma_tx_channel) + dma_release_channel(host->dma_tx_channel); + host->dma_enable = false; +} + +static void mmci_dma_data_end(struct mmci_host *host) +{ + struct mmc_data *data = host->data; + + dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len, + (data->flags & MMC_DATA_WRITE) + ? DMA_TO_DEVICE : DMA_FROM_DEVICE); +} + +static void mmci_dma_data_error(struct mmci_host *host) +{ + struct mmc_data *data = host->data; + struct dma_chan *chan; + + dev_err(mmc_dev(host->mmc), "error during DMA transfer!\n"); + if (data->flags & MMC_DATA_READ) + chan = host->dma_rx_channel; + else + chan = host->dma_tx_channel; + dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len, + (data->flags & MMC_DATA_WRITE) + ? DMA_TO_DEVICE : DMA_FROM_DEVICE); + chan->device->device_control(chan, DMA_TERMINATE_ALL, 0); +} + +static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl) +{ + struct variant_data *variant = host->variant; + struct dma_slave_config rx_conf = { + .src_addr = host->phybase + MMCIFIFO, + .src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES, + .direction = DMA_FROM_DEVICE, + .src_maxburst = variant->fifohalfsize >> 2, /* # of words */ + }; + struct dma_slave_config tx_conf = { + .dst_addr = host->phybase + MMCIFIFO, + .dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES, + .direction = DMA_TO_DEVICE, + .dst_maxburst = variant->fifohalfsize >> 2, /* # of words */ + }; + struct mmc_data *data = host->data; + enum dma_data_direction direction; + struct dma_chan *chan; + struct dma_async_tx_descriptor *desc; + struct scatterlist *sg; + dma_cookie_t cookie; + int i; + + datactrl |= MCI_DPSM_DMAENABLE; + datactrl |= variant->dmareg_enable; + + if (data->flags & MMC_DATA_READ) { + direction = DMA_FROM_DEVICE; + chan = host->dma_rx_channel; + chan->device->device_control(chan, DMA_SLAVE_CONFIG, + (unsigned long) &rx_conf); + } else { + direction = DMA_TO_DEVICE; + chan = host->dma_tx_channel; + chan->device->device_control(chan, DMA_SLAVE_CONFIG, + (unsigned long) &tx_conf); + } + + /* Check for weird stuff in the sg list */ + for_each_sg(data->sg, sg, data->sg_len, i) { + dev_vdbg(mmc_dev(host->mmc), "MMCI SGlist %d dir %d: length: %08x\n", + i, direction, sg->length); + if (sg->offset & 3 || sg->length & 3) + return -EINVAL; + } + + dma_map_sg(mmc_dev(host->mmc), data->sg, + data->sg_len, direction); + + desc = chan->device->device_prep_slave_sg(chan, + data->sg, data->sg_len, direction, + DMA_CTRL_ACK); + if (!desc) + goto unmap_exit; + + host->dma_desc = desc; + dev_vdbg(mmc_dev(host->mmc), "Submit MMCI DMA job, sglen %d " + "blksz %04x blks %04x flags %08x\n", + data->sg_len, data->blksz, data->blocks, data->flags); + cookie = desc->tx_submit(desc); + + /* Here overloaded DMA controllers may fail */ + if (dma_submit_error(cookie)) + goto unmap_exit; + + host->dma_on_current_xfer = true; + chan->device->device_issue_pending(chan); + + /* Trigger the DMA transfer */ + writel(datactrl, host->base + MMCIDATACTRL); + /* + * Let the MMCI say when the data is ended and it's time + * to fire next DMA request. When that happens, MMCI will + * call mmci_data_end() + */ + writel(readl(host->base + MMCIMASK0) | MCI_DATAENDMASK, + host->base + MMCIMASK0); + return 0; + +unmap_exit: + chan->device->device_control(chan, DMA_TERMINATE_ALL, 0); + dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len, direction); + host->dma_on_current_xfer = false; + return -ENOMEM; +} +#else +/* Blank functions if the DMA engine is not available */ +static inline void mmci_setup_dma(struct mmci_host *host) +{ +} + +static inline void mmci_disable_dma(struct mmci_host *host) +{ +} + +static inline void mmci_dma_data_end(struct mmci_host *host) +{ +} + +static inline void mmci_dma_data_error(struct mmci_host *host) +{ +} + +static inline int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl) +{ + return -ENOSYS; +} +#endif + static void mmci_start_data(struct mmci_host *host, struct mmc_data *data) { struct variant_data *variant = host->variant; @@ -183,8 +385,8 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data) host->data = data; host->size = data->blksz * data->blocks; host->data_xfered = 0; - - mmci_init_sg(host, data); + host->blockend = false; + host->dataend = false; clks = (unsigned long long)data->timeout_ns * host->cclk; do_div(clks, 1000000000UL); @@ -199,13 +401,32 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data) BUG_ON(1 << blksz_bits != data->blksz); datactrl = MCI_DPSM_ENABLE | blksz_bits << 4; - if (data->flags & MMC_DATA_READ) { + + if (data->flags & MMC_DATA_READ) datactrl |= MCI_DPSM_DIRECTION; + + if (host->dma_enable) { + int ret; + + /* + * Attempt to use DMA operation mode, if this + * should fail, fall back to PIO mode + */ + ret = mmci_dma_start_data(host, datactrl); + if (!ret) + return; + } + + /* IRQ mode, map the SG list for CPU reading/writing */ + mmci_init_sg(host, data); + + if (data->flags & MMC_DATA_READ) { irqmask = MCI_RXFIFOHALFFULLMASK; /* - * If we have less than a FIFOSIZE of bytes to transfer, - * trigger a PIO interrupt as soon as any data is available. + * If we have less than a FIFOSIZE of bytes to + * transfer, trigger a PIO interrupt as soon as any + * data is available. */ if (host->size < variant->fifosize) irqmask |= MCI_RXDATAAVLBLMASK; @@ -254,20 +475,7 @@ static void mmci_data_irq(struct mmci_host *host, struct mmc_data *data, unsigned int status) { - if (status & MCI_DATABLOCKEND) { - host->data_xfered += data->blksz; -#ifdef CONFIG_ARCH_U300 - /* - * On the U300 some signal or other is - * badly routed so that a data write does - * not properly terminate with a MCI_DATAEND - * status flag. This quirk will make writes - * work again. - */ - if (data->flags & MMC_DATA_WRITE) - status |= MCI_DATAEND; -#endif - } + /* First check for errors */ if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) { dev_dbg(mmc_dev(host->mmc), "MCI ERROR IRQ (status %08x)\n", status); if (status & MCI_DATACRCFAIL) @@ -276,13 +484,19 @@ mmci_data_irq(struct mmci_host *host, struct mmc_data *data, data->error = -ETIMEDOUT; else if (status & (MCI_TXUNDERRUN|MCI_RXOVERRUN)) data->error = -EIO; - status |= MCI_DATAEND; + + /* Force-complete the transaction */ + host->blockend = true; + host->dataend = true; /* * We hit an error condition. Ensure that any data - * partially written to a page is properly coherent. + * partially written to a page is properly coherent, + * unless we're using DMA. */ - if (data->flags & MMC_DATA_READ) { + if (host->dma_on_current_xfer) + mmci_dma_data_error(host); + else if (data->flags & MMC_DATA_READ) { struct sg_mapping_iter *sg_miter = &host->sg_miter; unsigned long flags; @@ -294,12 +508,59 @@ mmci_data_irq(struct mmci_host *host, struct mmc_data *data, local_irq_restore(flags); } } - if (status & MCI_DATAEND) { + + /* + * On ARM variants in PIO mode, MCI_DATABLOCKEND + * is always sent first, and we increase the + * transfered number of bytes for that IRQ. Then + * MCI_DATEND follows and we conclude the transaction. + * This is also the case in the U300 PIO mode. + * + * The Ux500 single-IRQ variant only fires the + * MCI_DATAEND IRQ at the end of the entire transfer. + * + * In DMA mode, the IRQs can arrive out-of-order, + * e.g. MCI_DATABLOCKEND sometimes arrives after MCI_DATAEND, + * so in this case we use the flags "blockend" and + * "dataend" to make sure both IRQs have arrived before + * concluding the transaction. (This does not apply + * to the Ux500 which doesn't fire MCI_DATABLOCKEND + * at all.) + */ + if (status & MCI_DATABLOCKEND) { + /* + * Just being a little over-cautious, we do not + * use this progressive update in DMA or single-IRQ + * mode. + */ + if (!host->variant->singleirq && !host->dma_on_current_xfer) + host->data_xfered += data->blksz; + host->blockend = true; + } + + if (status & MCI_DATAEND) + host->dataend = true; + + /* + * On Ux500 we shall only wait for dataend, on others we must sync + * with the blockend signal since they can appear out-of-order + * when using DMA. + */ + if (host->dataend && (host->blockend || host->variant->singleirq)) { + mmci_dma_data_end(host); mmci_stop_data(host); - /* MCI_DATABLOCKEND not used with single irq */ - if (host->variant->singleirq && !data->error) - host->data_xfered = data->blksz * data->blocks; + /* Reset these flags */ + host->blockend = false; + host->dataend = false; + + /* + * Single IRQ variants do not transmit MCI_DATABLOCKEND + * and in DMA mode this signal need to be synchronized + * with MCI_DATEND + */ + if ((host->variant->singleirq || host->dma_on_current_xfer) && !data->error) + host->data_xfered += data->blksz * data->blocks; if (!data->stop) { mmci_request_end(host, data->mrq); @@ -718,6 +979,7 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id) dev_dbg(mmc_dev(mmc), "eventual mclk rate: %u Hz\n", host->mclk); } + host->phybase = dev->res.start; host->base = ioremap(dev->res.start, resource_size(&dev->res)); if (!host->base) { ret = -ENOMEM; @@ -829,6 +1091,8 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id) && host->gpio_cd_irq < 0) mmc->caps |= MMC_CAP_NEEDS_POLL; + mmci_setup_dma(host); + ret = request_irq(dev->irq[0], mmci_irq, IRQF_SHARED, DRIVER_NAME " (cmd)", host); if (ret) goto unmap; @@ -855,15 +1119,17 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id) mmc_add_host(mmc); - dev_info(&dev->dev, "%s: MMCI rev %x cfg %02x at 0x%016llx irq %d,%d\n", - mmc_hostname(mmc), amba_rev(dev), amba_config(dev), - (unsigned long long)dev->res.start, dev->irq[0], dev->irq[1]); + dev_info(&dev->dev, "%s: MMCI/PL180 manf %x rev %x cfg %02x at 0x%016llx\n", + mmc_hostname(mmc), amba_manf(dev), amba_rev(dev), amba_config(dev), + (unsigned long long)dev->res.start); + dev_info(&dev->dev, "IRQ %d, %d (pio)\n", dev->irq[0], dev->irq[1]); return 0; irq0_free: free_irq(dev->irq[0], host); unmap: + mmci_disable_dma(host); if (host->gpio_wp != -ENOSYS) gpio_free(host->gpio_wp); err_gpio_wp: @@ -903,6 +1169,7 @@ static int __devexit mmci_remove(struct amba_device *dev) writel(0, host->base + MMCICOMMAND); writel(0, host->base + MMCIDATACTRL); + mmci_disable_dma(host); free_irq(dev->irq[0], host); if (!variant->singleirq) free_irq(dev->irq[1], host); diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h index ba203b8..3736d93 100644 --- a/drivers/mmc/host/mmci.h +++ b/drivers/mmc/host/mmci.h @@ -142,8 +142,11 @@ struct clk; struct variant_data; +struct dma_chan; +struct dma_async_tx_descriptor; struct mmci_host { + phys_addr_t phybase; void __iomem *base; struct mmc_request *mrq; struct mmc_command *cmd; @@ -170,9 +173,22 @@ struct mmci_host { struct timer_list timer; unsigned int oldstat; + bool blockend; + bool dataend; + /* pio stuff */ struct sg_mapping_iter sg_miter; unsigned int size; + struct regulator *vcc; + + /* DMA stuff */ + bool dma_enable; + bool dma_on_current_xfer; +#ifdef CONFIG_DMADEVICES + struct dma_chan *dma_rx_channel; + struct dma_chan *dma_tx_channel; + struct dma_async_tx_descriptor *dma_desc; +#endif }; diff --git a/include/linux/amba/mmci.h b/include/linux/amba/mmci.h index f4ee9ac..dbeba68 100644 --- a/include/linux/amba/mmci.h +++ b/include/linux/amba/mmci.h @@ -6,6 +6,8 @@ #include <linux/mmc/host.h> +/* Just some dummy forwarding */ +struct dma_chan; /** * struct mmci_platform_data - platform configuration for the MMCI * (also known as PL180) block. @@ -27,6 +29,17 @@ * @cd_invert: true if the gpio_cd pin value is active low * @capabilities: the capabilities of the block as implemented in * this platform, signify anything MMC_CAP_* from mmc/host.h + * @dma_filter: function used to select an apropriate RX and TX + * DMA channel to be used for DMA, if and only if you're deploying the + * generic DMA engine + * @dma_rx_param: parameter passed to the DMA allocation + * filter in order to select an apropriate RX channel. If + * there is a bidirectional RX+TX channel, then just specify + * this and leave dma_tx_param set to NULL + * @dma_tx_param: parameter passed to the DMA allocation + * filter in order to select an apropriate TX channel. If this + * is NULL the driver will attempt to use the RX channel as a + * bidirectional channel */ struct mmci_platform_data { unsigned int f_max; @@ -38,6 +51,9 @@ struct mmci_platform_data { int gpio_cd; bool cd_invert; unsigned long capabilities; + bool (*dma_filter)(struct dma_chan *chan, void *filter_param); + void *dma_rx_param; + void *dma_tx_param; }; #endif -- 1.6.3.3 ^ permalink raw reply related [flat|nested] 10+ messages in thread
* [PATCH 4/6] ARM: config U300 PL180 PL011 PL022 for DMA v10 2010-09-01 15:24 ` [PATCH 3/6] ARM: add PrimeCell generic DMA to MMCI/PL180 v10 Linus Walleij @ 2010-09-01 15:24 ` Linus Walleij 2010-09-01 15:24 ` [PATCH 5/6] ARM: config Ux500 PL011 PL022 PL180 " Linus Walleij 0 siblings, 1 reply; 10+ messages in thread From: Linus Walleij @ 2010-09-01 15:24 UTC (permalink / raw) To: Dan Williams, linux-arm-kernel, yuanyabin1978; +Cc: linux-kernel, Linus Walleij This will configure the platform data for the PL180, PL011 and PL022 PrimeCells found in the U300 to use DMA with the generic PrimeCell DMA engine. Signed-off-by: Linus Walleij <linus.walleij@stericsson.com> --- arch/arm/mach-u300/core.c | 179 ++++++++++++++++++++++++++++++++++++++++----- arch/arm/mach-u300/mmc.c | 13 +++- arch/arm/mach-u300/spi.c | 21 ++++-- 3 files changed, 184 insertions(+), 29 deletions(-) diff --git a/arch/arm/mach-u300/core.c b/arch/arm/mach-u300/core.c index ea41c23..4093af7 100644 --- a/arch/arm/mach-u300/core.c +++ b/arch/arm/mach-u300/core.c @@ -3,7 +3,7 @@ * arch/arm/mach-u300/core.c * * - * Copyright (C) 2007-2010 ST-Ericsson AB + * Copyright (C) 2007-2010 ST-Ericsson SA * License terms: GNU General Public License (GPL) version 2 * Core platform support, IRQ handling and device definitions. * Author: Linus Walleij <linus.walleij@stericsson.com> @@ -16,7 +16,9 @@ #include <linux/device.h> #include <linux/mm.h> #include <linux/termios.h> +#include <linux/dmaengine.h> #include <linux/amba/bus.h> +#include <linux/amba/serial.h> #include <linux/platform_device.h> #include <linux/gpio.h> #include <linux/clk.h> @@ -94,10 +96,20 @@ void __init u300_map_io(void) * Declaration of devices found on the U300 board and * their respective memory locations. */ + +static struct amba_pl011_data uart0_plat_data = { +#ifdef CONFIG_COH901318 + .dma_filter = coh901318_filter_id, + .dma_rx_param = (void *) U300_DMA_UART0_RX, + .dma_tx_param = (void *) U300_DMA_UART0_TX, +#endif +}; + static struct amba_device uart0_device = { .dev = { + .coherent_dma_mask = ~0, .init_name = "uart0", /* Slow device at 0x3000 offset */ - .platform_data = NULL, + .platform_data = &uart0_plat_data, }, .res = { .start = U300_UART0_BASE, @@ -109,10 +121,19 @@ static struct amba_device uart0_device = { /* The U335 have an additional UART1 on the APP CPU */ #ifdef CONFIG_MACH_U300_BS335 +static struct amba_pl011_data uart1_plat_data = { +#ifdef CONFIG_COH901318 + .dma_filter = coh901318_filter_id, + .dma_rx_param = (void *) U300_DMA_UART1_RX, + .dma_tx_param = (void *) U300_DMA_UART1_TX, +#endif +}; + static struct amba_device uart1_device = { .dev = { + .coherent_dma_mask = ~0, .init_name = "uart1", /* Fast device at 0x7000 offset */ - .platform_data = NULL, + .platform_data = &uart1_plat_data, }, .res = { .start = U300_UART1_BASE, @@ -951,42 +972,37 @@ const struct coh_dma_channel chan_config[U300_DMA_CHANNELS] = { .priority_high = 0, .dev_addr = U300_MSL_BASE + 6 * 0x40 + 0x220, }, + /* + * Don't set up device address, burst count or size of src + * or dst bus for this peripheral - handled by PrimeCell + * DMA extension. + */ { .number = U300_DMA_MMCSD_RX_TX, .name = "MMCSD RX TX", .priority_high = 0, - .dev_addr = U300_MMCSD_BASE + 0x080, .param.config = COH901318_CX_CFG_CH_DISABLE | COH901318_CX_CFG_LCR_DISABLE | COH901318_CX_CFG_TC_IRQ_ENABLE | COH901318_CX_CFG_BE_IRQ_ENABLE, .param.ctrl_lli_chained = 0 | COH901318_CX_CTRL_TC_ENABLE | - COH901318_CX_CTRL_BURST_COUNT_32_BYTES | - COH901318_CX_CTRL_SRC_BUS_SIZE_32_BITS | - COH901318_CX_CTRL_DST_BUS_SIZE_32_BITS | COH901318_CX_CTRL_MASTER_MODE_M1RW | COH901318_CX_CTRL_TCP_ENABLE | - COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_TC_IRQ_DISABLE | COH901318_CX_CTRL_HSP_ENABLE | COH901318_CX_CTRL_HSS_DISABLE | COH901318_CX_CTRL_DDMA_LEGACY, .param.ctrl_lli = 0 | COH901318_CX_CTRL_TC_ENABLE | - COH901318_CX_CTRL_BURST_COUNT_32_BYTES | - COH901318_CX_CTRL_SRC_BUS_SIZE_32_BITS | - COH901318_CX_CTRL_DST_BUS_SIZE_32_BITS | COH901318_CX_CTRL_MASTER_MODE_M1RW | COH901318_CX_CTRL_TCP_ENABLE | - COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_TC_IRQ_DISABLE | COH901318_CX_CTRL_HSP_ENABLE | COH901318_CX_CTRL_HSS_DISABLE | COH901318_CX_CTRL_DDMA_LEGACY, .param.ctrl_lli_last = 0 | COH901318_CX_CTRL_TC_ENABLE | - COH901318_CX_CTRL_BURST_COUNT_32_BYTES | - COH901318_CX_CTRL_SRC_BUS_SIZE_32_BITS | - COH901318_CX_CTRL_DST_BUS_SIZE_32_BITS | COH901318_CX_CTRL_MASTER_MODE_M1RW | COH901318_CX_CTRL_TCP_DISABLE | COH901318_CX_CTRL_TC_IRQ_ENABLE | @@ -1005,15 +1021,76 @@ const struct coh_dma_channel chan_config[U300_DMA_CHANNELS] = { .name = "MSPRO RX", .priority_high = 0, }, + /* + * Don't set up device address, burst count or size of src + * or dst bus for this peripheral - handled by PrimeCell + * DMA extension. + */ { .number = U300_DMA_UART0_TX, .name = "UART0 TX", .priority_high = 0, + .param.config = COH901318_CX_CFG_CH_DISABLE | + COH901318_CX_CFG_LCR_DISABLE | + COH901318_CX_CFG_TC_IRQ_ENABLE | + COH901318_CX_CFG_BE_IRQ_ENABLE, + .param.ctrl_lli_chained = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_ENABLE | + COH901318_CX_CTRL_TC_IRQ_DISABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, + .param.ctrl_lli = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_ENABLE | + COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, + .param.ctrl_lli_last = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_ENABLE | + COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, }, { .number = U300_DMA_UART0_RX, .name = "UART0 RX", .priority_high = 0, + .param.config = COH901318_CX_CFG_CH_DISABLE | + COH901318_CX_CFG_LCR_DISABLE | + COH901318_CX_CFG_TC_IRQ_ENABLE | + COH901318_CX_CFG_BE_IRQ_ENABLE, + .param.ctrl_lli_chained = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_ENABLE | + COH901318_CX_CTRL_TC_IRQ_DISABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, + .param.ctrl_lli = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_ENABLE | + COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, + .param.ctrl_lli_last = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_ENABLE | + COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, }, { .number = U300_DMA_APEX_TX, @@ -1071,7 +1148,7 @@ const struct coh_dma_channel chan_config[U300_DMA_CHANNELS] = { COH901318_CX_CTRL_DST_ADDR_INC_DISABLE | COH901318_CX_CTRL_MASTER_MODE_M1RW | COH901318_CX_CTRL_TCP_ENABLE | - COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_TC_IRQ_DISABLE | COH901318_CX_CTRL_HSP_ENABLE | COH901318_CX_CTRL_HSS_DISABLE | COH901318_CX_CTRL_DDMA_LEGACY | @@ -1243,15 +1320,77 @@ const struct coh_dma_channel chan_config[U300_DMA_CHANNELS] = { .name = "XGAM PDI", .priority_high = 0, }, + /* + * Don't set up device address, burst count or size of src + * or dst bus for this peripheral - handled by PrimeCell + * DMA extension. + */ { .number = U300_DMA_SPI_TX, .name = "SPI TX", .priority_high = 0, + .param.config = COH901318_CX_CFG_CH_DISABLE | + COH901318_CX_CFG_LCR_DISABLE | + COH901318_CX_CFG_TC_IRQ_ENABLE | + COH901318_CX_CFG_BE_IRQ_ENABLE, + .param.ctrl_lli_chained = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_DISABLE | + COH901318_CX_CTRL_TC_IRQ_DISABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, + .param.ctrl_lli = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_DISABLE | + COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, + .param.ctrl_lli_last = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_DISABLE | + COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, }, { .number = U300_DMA_SPI_RX, .name = "SPI RX", .priority_high = 0, + .param.config = COH901318_CX_CFG_CH_DISABLE | + COH901318_CX_CFG_LCR_DISABLE | + COH901318_CX_CFG_TC_IRQ_ENABLE | + COH901318_CX_CFG_BE_IRQ_ENABLE, + .param.ctrl_lli_chained = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_DISABLE | + COH901318_CX_CTRL_TC_IRQ_DISABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, + .param.ctrl_lli = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_DISABLE | + COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, + .param.ctrl_lli_last = 0 | + COH901318_CX_CTRL_TC_ENABLE | + COH901318_CX_CTRL_MASTER_MODE_M1RW | + COH901318_CX_CTRL_TCP_DISABLE | + COH901318_CX_CTRL_TC_IRQ_ENABLE | + COH901318_CX_CTRL_HSP_ENABLE | + COH901318_CX_CTRL_HSS_DISABLE | + COH901318_CX_CTRL_DDMA_LEGACY, + }, { .number = U300_DMA_GENERAL_PURPOSE_0, @@ -1580,7 +1719,7 @@ static void __init u300_init_check_chip(void) #endif #ifdef CONFIG_MACH_U300_BS335 if ((val & 0xFF00U) != 0xf000 && (val & 0xFF00U) != 0xf100) { - printk(KERN_ERR "Platform configured for BS365 " \ + printk(KERN_ERR "Platform configured for BS335 " \ " with DB3350 but %s detected, expect problems!", chipname); } @@ -1655,12 +1794,12 @@ void __init u300_init_devices(void) /* Register subdevices on the I2C buses */ u300_i2c_register_board_devices(); - /* Register subdevices on the SPI bus */ - u300_spi_register_board_devices(); - /* Register the platform devices */ platform_add_devices(platform_devs, ARRAY_SIZE(platform_devs)); + /* Register subdevices on the SPI bus */ + u300_spi_register_board_devices(); + #ifndef CONFIG_MACH_U300_SEMI_IS_SHARED /* * Enable SEMI self refresh. Self-refresh of the SDRAM is entered when diff --git a/arch/arm/mach-u300/mmc.c b/arch/arm/mach-u300/mmc.c index de1ac9a..2382175 100644 --- a/arch/arm/mach-u300/mmc.c +++ b/arch/arm/mach-u300/mmc.c @@ -3,11 +3,11 @@ * arch/arm/mach-u300/mmc.c * * - * Copyright (C) 2009 ST-Ericsson AB + * Copyright (C) 2009 ST-Ericsson SA * License terms: GNU General Public License (GPL) version 2 * * Author: Linus Walleij <linus.walleij@stericsson.com> - * Author: Johan Lundin <johan.lundin@stericsson.com> + * Author: Johan Lundin * Author: Jonas Aaberg <jonas.aberg@stericsson.com> */ #include <linux/device.h> @@ -19,8 +19,11 @@ #include <linux/regulator/consumer.h> #include <linux/regulator/machine.h> #include <linux/gpio.h> +#include <linux/dmaengine.h> #include <linux/amba/mmci.h> #include <linux/slab.h> +#include <mach/coh901318.h> +#include <mach/dma_channels.h> #include "mmc.h" #include "padmux.h" @@ -108,6 +111,12 @@ int __devinit mmc_init(struct amba_device *adev) mmci_card->mmc0_plat_data.gpio_cd = -1; mmci_card->mmc0_plat_data.capabilities = MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED | MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA; +#ifdef CONFIG_COH901318 + mmci_card->mmc0_plat_data.dma_filter = coh901318_filter_id; + mmci_card->mmc0_plat_data.dma_rx_param = + (void *) U300_DMA_MMCSD_RX_TX; + /* Don't specify a TX channel, this RX channel is bidirectional */ +#endif mmcsd_device->platform_data = (void *) &mmci_card->mmc0_plat_data; diff --git a/arch/arm/mach-u300/spi.c b/arch/arm/mach-u300/spi.c index f0e887b..243c999 100644 --- a/arch/arm/mach-u300/spi.c +++ b/arch/arm/mach-u300/spi.c @@ -11,6 +11,9 @@ #include <linux/spi/spi.h> #include <linux/amba/pl022.h> #include <linux/err.h> +#include <mach/coh901318.h> +#include <mach/dma_channels.h> + #include "padmux.h" /* @@ -32,11 +35,8 @@ static void select_dummy_chip(u32 chipselect) struct pl022_config_chip dummy_chip_info = { /* Nominally this is LOOPBACK_DISABLED, but this is our dummy chip! */ .lbm = LOOPBACK_ENABLED, - /* - * available POLLING_TRANSFER and INTERRUPT_TRANSFER, - * DMA_TRANSFER does not work - */ - .com_mode = INTERRUPT_TRANSFER, + /* available POLLING_TRANSFER, INTERRUPT_TRANSFER, DMA_TRANSFER */ + .com_mode = DMA_TRANSFER, .iface = SSP_INTERFACE_MOTOROLA_SPI, /* We can only act as master but SSP_SLAVE is possible in theory */ .hierarchy = SSP_MASTER, @@ -83,8 +83,6 @@ static struct spi_board_info u300_spi_devices[] = { static struct pl022_ssp_controller ssp_platform_data = { /* If you have several SPI buses this varies, we have only bus 0 */ .bus_id = 0, - /* Set this to 1 when we think we got DMA working */ - .enable_dma = 0, /* * On the APP CPU GPIO 4, 5 and 6 are connected as generic * chip selects for SPI. (Same on U330, U335 and U365.) @@ -92,6 +90,14 @@ static struct pl022_ssp_controller ssp_platform_data = { * and do padmuxing accordingly too. */ .num_chipselect = 3, +#ifdef CONFIG_COH901318 + .enable_dma = 1, + .dma_filter = coh901318_filter_id, + .dma_rx_param = (void *) U300_DMA_SPI_RX, + .dma_tx_param = (void *) U300_DMA_SPI_TX, +#else + .enable_dma = 0, +#endif }; @@ -117,6 +123,7 @@ void __init u300_spi_init(struct amba_device *adev) } } + void __init u300_spi_register_board_devices(void) { /* Register any SPI devices */ -- 1.6.3.3 ^ permalink raw reply related [flat|nested] 10+ messages in thread
* [PATCH 5/6] ARM: config Ux500 PL011 PL022 PL180 for DMA v10 2010-09-01 15:24 ` [PATCH 4/6] ARM: config U300 PL180 PL011 PL022 for DMA v10 Linus Walleij @ 2010-09-01 15:24 ` Linus Walleij 2010-09-01 15:24 ` [PATCH 6/6] ARM: config RealViews PL011 PL022 " Linus Walleij 0 siblings, 1 reply; 10+ messages in thread From: Linus Walleij @ 2010-09-01 15:24 UTC (permalink / raw) To: Dan Williams, linux-arm-kernel, yuanyabin1978; +Cc: linux-kernel, Linus Walleij This will configure the platform data for the PL011 and PL022 PrimeCells found in the Ux500 to use DMA with the generic PrimeCell DMA engine. Signed-off-by: Linus Walleij <linus.walleij@stericsson.com> --- arch/arm/mach-ux500/board-mop500-sdi.c | 127 ++++++++++++++++++++++++++++++ arch/arm/mach-ux500/board-mop500.c | 12 --- arch/arm/mach-ux500/devices-db8500.c | 92 +++++++++++++++++++++- arch/arm/mach-ux500/devices.c | 133 +++++++++++++++++++++++++++++++- 4 files changed, 346 insertions(+), 18 deletions(-) diff --git a/arch/arm/mach-ux500/board-mop500-sdi.c b/arch/arm/mach-ux500/board-mop500-sdi.c index f0095ff..61b0fdd 100644 --- a/arch/arm/mach-ux500/board-mop500-sdi.c +++ b/arch/arm/mach-ux500/board-mop500-sdi.c @@ -13,11 +13,13 @@ #include <linux/platform_device.h> #include <plat/pincfg.h> +#include <plat/ste_dma40.h> #include <mach/devices.h> #include <mach/hardware.h> #include "pins-db8500.h" #include "board-mop500.h" +#include "ste-dma40-db8500.h" static pin_cfg_t mop500_sdi_pins[] = { /* SDI0 (MicroSD slot) */ @@ -62,6 +64,20 @@ static pin_cfg_t mop500_sdi2_pins[] = { GPIO138_MC2_DAT7, }; +/* Some custom DMA40 callbacks for MMC */ +static int dma40_mmc_pre_transfer(struct dma_chan *chan, void *data, int size) +{ + if (size <= 16) + stedma40_set_psize(chan, + STEDMA40_PSIZE_LOG_1, + STEDMA40_PSIZE_LOG_1); + else + stedma40_set_psize(chan, + STEDMA40_PSIZE_LOG_4, + STEDMA40_PSIZE_LOG_4); + return 0; +} + /* * SDI 0 (MicroSD slot) */ @@ -85,6 +101,38 @@ static u32 mop500_sdi0_vdd_handler(struct device *dev, unsigned int vdd, MCI_DATA2DIREN | MCI_DATA31DIREN; } +#ifdef CONFIG_STE_DMA40 +struct stedma40_chan_cfg sdi0_dma_cfg_rx = { + .pre_transfer = dma40_mmc_pre_transfer, + .channel_type = STEDMA40_CHANNEL_IN_LOG_MODE + | STEDMA40_LCHAN_SRC_LOG_DST_LOG + | STEDMA40_NO_TIM_FOR_LINK + | STEDMA40_LOW_PRIORITY_CHANNEL, + .dir = STEDMA40_PERIPH_TO_MEM, + .src_dev_type = STEDMA40_DEV_SD_MM0_RX, + .dst_dev_type = STEDMA40_DEV_DST_MEMORY, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_WORD_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_WORD_WIDTH, +}; + +static struct stedma40_chan_cfg sdi0_dma_cfg_tx = { + .pre_transfer = dma40_mmc_pre_transfer, + .channel_type = STEDMA40_CHANNEL_IN_LOG_MODE + | STEDMA40_LCHAN_SRC_LOG_DST_LOG + | STEDMA40_NO_TIM_FOR_LINK + | STEDMA40_LOW_PRIORITY_CHANNEL, + .dir = STEDMA40_MEM_TO_PERIPH, + .src_dev_type = STEDMA40_DEV_SRC_MEMORY, + .dst_dev_type = STEDMA40_DEV_SD_MM0_TX, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_WORD_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_WORD_WIDTH, +}; +#endif + static struct mmci_platform_data mop500_sdi0_data = { .vdd_handler = mop500_sdi0_vdd_handler, .ocr_mask = MMC_VDD_29_30, @@ -92,6 +140,11 @@ static struct mmci_platform_data mop500_sdi0_data = { .capabilities = MMC_CAP_4_BIT_DATA, .gpio_cd = GPIO_SDMMC_CD, .gpio_wp = -1, +#ifdef CONFIG_STE_DMA40 + .dma_filter = stedma40_filter, + .dma_rx_param = &sdi0_dma_cfg_rx, + .dma_tx_param = &sdi0_dma_cfg_tx, +#endif }; void mop500_sdi_tc35892_init(void) @@ -115,18 +168,87 @@ void mop500_sdi_tc35892_init(void) * SDI 2 (POP eMMC, not on DB8500ed) */ +#ifdef CONFIG_STE_DMA40 +struct stedma40_chan_cfg sdi2_dma_cfg_rx = { + .pre_transfer = dma40_mmc_pre_transfer, + .channel_type = STEDMA40_CHANNEL_IN_LOG_MODE + | STEDMA40_LCHAN_SRC_LOG_DST_LOG + | STEDMA40_NO_TIM_FOR_LINK + | STEDMA40_LOW_PRIORITY_CHANNEL, + .dir = STEDMA40_PERIPH_TO_MEM, + .src_dev_type = STEDMA40_DEV_SD_MM2_RX, + .dst_dev_type = STEDMA40_DEV_DST_MEMORY, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_WORD_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_WORD_WIDTH, +}; + +static struct stedma40_chan_cfg sdi2_dma_cfg_tx = { + .pre_transfer = dma40_mmc_pre_transfer, + .channel_type = STEDMA40_CHANNEL_IN_LOG_MODE + | STEDMA40_LCHAN_SRC_LOG_DST_LOG + | STEDMA40_NO_TIM_FOR_LINK + | STEDMA40_LOW_PRIORITY_CHANNEL, + .dir = STEDMA40_MEM_TO_PERIPH, + .src_dev_type = STEDMA40_DEV_SRC_MEMORY, + .dst_dev_type = STEDMA40_DEV_SD_MM2_TX, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_WORD_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_WORD_WIDTH, +}; +#endif + static struct mmci_platform_data mop500_sdi2_data = { .ocr_mask = MMC_VDD_165_195, .f_max = 100000000, .capabilities = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA, .gpio_cd = -1, .gpio_wp = -1, +#ifdef CONFIG_STE_DMA40 + .dma_filter = stedma40_filter, + .dma_rx_param = &sdi2_dma_cfg_rx, + .dma_tx_param = &sdi2_dma_cfg_tx, +#endif }; /* * SDI 4 (on-board eMMC) */ +#ifdef CONFIG_STE_DMA40 +struct stedma40_chan_cfg sdi4_dma_cfg_rx = { + .pre_transfer = dma40_mmc_pre_transfer, + .channel_type = STEDMA40_CHANNEL_IN_LOG_MODE + | STEDMA40_LCHAN_SRC_LOG_DST_LOG + | STEDMA40_NO_TIM_FOR_LINK + | STEDMA40_LOW_PRIORITY_CHANNEL, + .dir = STEDMA40_PERIPH_TO_MEM, + .src_dev_type = STEDMA40_DEV_SD_MM4_RX, + .dst_dev_type = STEDMA40_DEV_DST_MEMORY, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_WORD_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_WORD_WIDTH, +}; + +static struct stedma40_chan_cfg sdi4_dma_cfg_tx = { + .pre_transfer = dma40_mmc_pre_transfer, + .channel_type = STEDMA40_CHANNEL_IN_LOG_MODE + | STEDMA40_LCHAN_SRC_LOG_DST_LOG + | STEDMA40_NO_TIM_FOR_LINK + | STEDMA40_LOW_PRIORITY_CHANNEL, + .dir = STEDMA40_MEM_TO_PERIPH, + .src_dev_type = STEDMA40_DEV_SRC_MEMORY, + .dst_dev_type = STEDMA40_DEV_SD_MM4_TX, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_WORD_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_WORD_WIDTH, +}; +#endif + static struct mmci_platform_data mop500_sdi4_data = { .ocr_mask = MMC_VDD_29_30, .f_max = 100000000, @@ -134,6 +256,11 @@ static struct mmci_platform_data mop500_sdi4_data = { MMC_CAP_MMC_HIGHSPEED, .gpio_cd = -1, .gpio_wp = -1, +#ifdef CONFIG_STE_DMA40 + .dma_filter = stedma40_filter, + .dma_rx_param = &sdi4_dma_cfg_rx, + .dma_tx_param = &sdi4_dma_cfg_tx, +#endif }; void mop500_sdi_init(void) diff --git a/arch/arm/mach-ux500/board-mop500.c b/arch/arm/mach-ux500/board-mop500.c index 879747c..5312576 100644 --- a/arch/arm/mach-ux500/board-mop500.c +++ b/arch/arm/mach-ux500/board-mop500.c @@ -112,16 +112,6 @@ static struct spi_board_info u8500_spi_devices[] = { }, }; -static struct pl022_ssp_controller ssp0_platform_data = { - .bus_id = 0, - /* pl022 not yet supports dma */ - .enable_dma = 0, - /* on this platform, gpio 31,142,144,214 & - * 224 are connected as chip selects - */ - .num_chipselect = 5, -}; - /* * TC35892 */ @@ -206,8 +196,6 @@ static void __init u8500_init_machine(void) ux500_i2c2_device.dev.platform_data = &u8500_i2c2_data; ux500_i2c3_device.dev.platform_data = &u8500_i2c3_data; - u8500_ssp0_device.dev.platform_data = &ssp0_platform_data; - /* Register the active AMBA devices on this board */ for (i = 0; i < ARRAY_SIZE(amba_devs); i++) amba_device_register(amba_devs[i], &iomem_resource); diff --git a/arch/arm/mach-ux500/devices-db8500.c b/arch/arm/mach-ux500/devices-db8500.c index 28866b4..bcba256 100644 --- a/arch/arm/mach-ux500/devices-db8500.c +++ b/arch/arm/mach-ux500/devices-db8500.c @@ -11,6 +11,7 @@ #include <linux/io.h> #include <linux/gpio.h> #include <linux/amba/bus.h> +#include <linux/amba/pl022.h> #include <plat/ste_dma40.h> @@ -55,10 +56,55 @@ struct platform_device u8500_gpio_devs[] = { GPIO_DEVICE(8), }; +#ifdef CONFIG_STE_DMA40 +static struct stedma40_chan_cfg ssp0_dma_cfg_rx = { + .channel_type = (STEDMA40_CHANNEL_IN_LOG_MODE| + STEDMA40_LCHAN_SRC_LOG_DST_LOG|STEDMA40_NO_TIM_FOR_LINK| + STEDMA40_LOW_PRIORITY_CHANNEL), + .dir = STEDMA40_PERIPH_TO_MEM, + .src_dev_type = STEDMA40_DEV_SSP0_RX, + .dst_dev_type = STEDMA40_DEV_DST_MEMORY, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_BYTE_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_BYTE_WIDTH, +}; + +static struct stedma40_chan_cfg ssp0_dma_cfg_tx = { + .channel_type = (STEDMA40_CHANNEL_IN_LOG_MODE| + STEDMA40_LCHAN_SRC_LOG_DST_LOG|STEDMA40_NO_TIM_FOR_LINK| + STEDMA40_LOW_PRIORITY_CHANNEL), + .dir = STEDMA40_MEM_TO_PERIPH, + .src_dev_type = STEDMA40_DEV_SRC_MEMORY, + .dst_dev_type = STEDMA40_DEV_SSP0_TX, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_BYTE_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_BYTE_WIDTH, +}; +#endif + +static struct pl022_ssp_controller ssp0_platform_data = { + .bus_id = 0, +#ifdef CONFIG_STE_DMA40 + .enable_dma = 1, + .dma_filter = stedma40_filter, + .dma_rx_param = &ssp0_dma_cfg_rx, + .dma_tx_param = &ssp0_dma_cfg_tx, +#else + .enable_dma = 0, +#endif + /* on this platform, gpio 31,142,144,214 & + * 224 are connected as chip selects + */ + .num_chipselect = 5, +}; + struct amba_device u8500_ssp0_device = { .dev = { .coherent_dma_mask = ~0, .init_name = "ssp0", + .platform_data = &ssp0_platform_data, }, .res = { .start = U8500_SSP0_BASE, @@ -244,12 +290,52 @@ struct stedma40_chan_cfg dma40_memcpy_conf_log = { /* * Mapping between destination event lines and physical device address. - * The event line is tied to a device and therefor the address is constant. + * The event line is tied to a device and therefore the address is constant. + * When the address comes from a primecell it will be configured in runtime + * and we set the address to -1 as a placeholder. */ -static const dma_addr_t dma40_tx_map[STEDMA40_NR_DEV]; +static const dma_addr_t dma40_tx_map[STEDMA40_NR_DEV] = { + [STEDMA40_DEV_SPI0_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MMC0_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MMC1_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MMC2_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SSP0_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SSP1_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_UART2_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_UART1_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_UART0_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM2_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM0_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM1_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SPI2_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SPI1_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SPI3_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM3_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM4_TX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM5_TX] = -1, /* PrimeCell DMA */ +}; /* Mapping between source event lines and physical device address */ -static const dma_addr_t dma40_rx_map[STEDMA40_NR_DEV]; +static const dma_addr_t dma40_rx_map[STEDMA40_NR_DEV] = { + [STEDMA40_DEV_SPI0_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MMC0_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MMC1_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MMC2_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SSP0_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SSP1_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_UART2_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_UART1_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_UART0_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM2_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM0_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM1_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SPI2_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SPI1_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SPI3_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM3_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM4_RX] = -1, /* PrimeCell DMA */ + [STEDMA40_DEV_SD_MM5_RX] = -1, /* PrimeCell DMA */ +}; /* Reserved event lines for memcpy only */ static int dma40_memcpy_event[] = { diff --git a/arch/arm/mach-ux500/devices.c b/arch/arm/mach-ux500/devices.c index 8a26889..f04d8d9 100644 --- a/arch/arm/mach-ux500/devices.c +++ b/arch/arm/mach-ux500/devices.c @@ -10,10 +10,21 @@ #include <linux/interrupt.h> #include <linux/io.h> #include <linux/amba/bus.h> +#include <linux/amba/serial.h> + +#include <plat/ste_dma40.h> #include <mach/hardware.h> #include <mach/setup.h> +/* Channel assignments are per-SoC */ +#ifdef CONFIG_UX500_SOC_DB8500 +#include "ste-dma40-db8500.h" +#endif +#if defined(CONFIG_UX500_SOC_DB5500) && defined(CONFIG_STE_DMA40) +#error "You need to define the DMA channels for DB5500!" +#endif + #define __MEM_4K_RESOURCE(x) \ .res = {.start = (x), .end = (x) + SZ_4K - 1, .flags = IORESOURCE_MEM} @@ -29,20 +40,136 @@ struct amba_device ux500_pl031_device = { .irq = {IRQ_RTC_RTT, NO_IRQ}, }; +#ifdef CONFIG_STE_DMA40 +static struct stedma40_chan_cfg uart0_dma_cfg_rx = { + .channel_type = (STEDMA40_CHANNEL_IN_LOG_MODE| + STEDMA40_LCHAN_SRC_LOG_DST_LOG|STEDMA40_NO_TIM_FOR_LINK| + STEDMA40_LOW_PRIORITY_CHANNEL), + .dir = STEDMA40_PERIPH_TO_MEM, + .src_dev_type = STEDMA40_DEV_UART0_RX, + .dst_dev_type = STEDMA40_DEV_DST_MEMORY, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_BYTE_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_BYTE_WIDTH, +}; + +static struct stedma40_chan_cfg uart0_dma_cfg_tx = { + .channel_type = (STEDMA40_CHANNEL_IN_LOG_MODE| + STEDMA40_LCHAN_SRC_LOG_DST_LOG|STEDMA40_NO_TIM_FOR_LINK| + STEDMA40_LOW_PRIORITY_CHANNEL), + .dir = STEDMA40_MEM_TO_PERIPH, + .src_dev_type = STEDMA40_DEV_SRC_MEMORY, + .dst_dev_type = STEDMA40_DEV_UART0_TX, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_BYTE_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_BYTE_WIDTH, +}; + +static struct stedma40_chan_cfg uart1_dma_cfg_rx = { + .channel_type = (STEDMA40_CHANNEL_IN_LOG_MODE| + STEDMA40_LCHAN_SRC_LOG_DST_LOG|STEDMA40_NO_TIM_FOR_LINK| + STEDMA40_LOW_PRIORITY_CHANNEL), + .dir = STEDMA40_PERIPH_TO_MEM, + .src_dev_type = STEDMA40_DEV_UART1_RX, + .dst_dev_type = STEDMA40_DEV_DST_MEMORY, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_BYTE_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_BYTE_WIDTH, +}; + +static struct stedma40_chan_cfg uart1_dma_cfg_tx = { + .channel_type = (STEDMA40_CHANNEL_IN_LOG_MODE| + STEDMA40_LCHAN_SRC_LOG_DST_LOG|STEDMA40_NO_TIM_FOR_LINK| + STEDMA40_LOW_PRIORITY_CHANNEL), + .dir = STEDMA40_MEM_TO_PERIPH, + .src_dev_type = STEDMA40_DEV_SRC_MEMORY, + .dst_dev_type = STEDMA40_DEV_UART1_TX, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_BYTE_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_BYTE_WIDTH, +}; + +static struct stedma40_chan_cfg uart2_dma_cfg_rx = { + .channel_type = (STEDMA40_CHANNEL_IN_LOG_MODE| + STEDMA40_LCHAN_SRC_LOG_DST_LOG|STEDMA40_NO_TIM_FOR_LINK| + STEDMA40_LOW_PRIORITY_CHANNEL), + .dir = STEDMA40_PERIPH_TO_MEM, + .src_dev_type = STEDMA40_DEV_UART2_RX, + .dst_dev_type = STEDMA40_DEV_DST_MEMORY, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_BYTE_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_BYTE_WIDTH, +}; + +static struct stedma40_chan_cfg uart2_dma_cfg_tx = { + .channel_type = (STEDMA40_CHANNEL_IN_LOG_MODE| + STEDMA40_LCHAN_SRC_LOG_DST_LOG|STEDMA40_NO_TIM_FOR_LINK| + STEDMA40_LOW_PRIORITY_CHANNEL), + .dir = STEDMA40_MEM_TO_PERIPH, + .src_dev_type = STEDMA40_DEV_SRC_MEMORY, + .dst_dev_type = STEDMA40_DEV_UART2_TX, + .src_info.endianess = STEDMA40_LITTLE_ENDIAN, + .src_info.data_width = STEDMA40_BYTE_WIDTH, + .dst_info.endianess = STEDMA40_LITTLE_ENDIAN, + .dst_info.data_width = STEDMA40_BYTE_WIDTH, +}; +#endif + +static struct amba_pl011_data uart0_plat = { +#ifdef CONFIG_STE_DMA40 + .dma_filter = stedma40_filter, + .dma_rx_param = &uart0_dma_cfg_rx, + .dma_tx_param = &uart0_dma_cfg_tx, +#endif +}; + +static struct amba_pl011_data uart1_plat = { +#ifdef CONFIG_STE_DMA40 + .dma_filter = stedma40_filter, + .dma_rx_param = &uart1_dma_cfg_rx, + .dma_tx_param = &uart1_dma_cfg_tx, +#endif +}; + +static struct amba_pl011_data uart2_plat = { +#ifdef CONFIG_STE_DMA40 + .dma_filter = stedma40_filter, + .dma_rx_param = &uart2_dma_cfg_rx, + .dma_tx_param = &uart2_dma_cfg_tx, +#endif +}; + struct amba_device ux500_uart0_device = { - .dev = { .init_name = "uart0" }, + .dev = { + .coherent_dma_mask = ~0, + .init_name = "uart0", + .platform_data = &uart0_plat, + }, __MEM_4K_RESOURCE(UX500_UART0_BASE), .irq = {IRQ_UART0, NO_IRQ}, }; struct amba_device ux500_uart1_device = { - .dev = { .init_name = "uart1" }, + .dev = { + .coherent_dma_mask = ~0, + .init_name = "uart1", + .platform_data = &uart1_plat, + }, __MEM_4K_RESOURCE(UX500_UART1_BASE), .irq = {IRQ_UART1, NO_IRQ}, }; struct amba_device ux500_uart2_device = { - .dev = { .init_name = "uart2" }, + .dev = { + .coherent_dma_mask = ~0, + .init_name = "uart2", + .platform_data = &uart2_plat, + }, __MEM_4K_RESOURCE(UX500_UART2_BASE), .irq = {IRQ_UART2, NO_IRQ}, }; -- 1.6.3.3 ^ permalink raw reply related [flat|nested] 10+ messages in thread
* [PATCH 6/6] ARM: config RealViews PL011 PL022 for DMA v10 2010-09-01 15:24 ` [PATCH 5/6] ARM: config Ux500 PL011 PL022 PL180 " Linus Walleij @ 2010-09-01 15:24 ` Linus Walleij 2010-09-01 15:24 ` Linus Walleij 0 siblings, 1 reply; 10+ messages in thread From: Linus Walleij @ 2010-09-01 15:24 UTC (permalink / raw) To: Dan Williams, linux-arm-kernel, yuanyabin1978; +Cc: linux-kernel, Linus Walleij This adds the platform necessary to make the PL08x driver from the async_tx tree probe successfully with the RealView boards (except for the PB1176 which lacks a working DMAC) and thus makes the memcpy channels available on all of them. Further it implements the logic for muxing the two sets of device (slave) DMA channels, so that devices can request their DMA channels and have them muxed in on request. Platform data for the PL022 and PL011 is supplied for the PB11MPCore. This was tested successfully on an PB11MPCore using DMA for the PL022 SPI and PL011 UART simultaneously with the DMA engine test client running memcpy on two of the channels. The slave transfers bail out and switch to PIO mode on oversubscribed channels and memcpy transfers queue if no physical channel is available. Signed-off-by: Linus Walleij <linus.walleij@stericsson.com> --- arch/arm/mach-realview/core.c | 239 ++++++++++++++++++++++++ arch/arm/mach-realview/core.h | 2 + arch/arm/mach-realview/include/mach/platform.h | 2 + arch/arm/mach-realview/realview_eb.c | 3 +- arch/arm/mach-realview/realview_pb11mp.c | 43 ++++- arch/arm/mach-realview/realview_pba8.c | 3 +- arch/arm/mach-realview/realview_pbx.c | 3 +- 7 files changed, 287 insertions(+), 8 deletions(-) diff --git a/arch/arm/mach-realview/core.c b/arch/arm/mach-realview/core.c index 07c0815..937300f 100644 --- a/arch/arm/mach-realview/core.c +++ b/arch/arm/mach-realview/core.c @@ -25,6 +25,8 @@ #include <linux/interrupt.h> #include <linux/amba/bus.h> #include <linux/amba/clcd.h> +#include <linux/amba/pl08x.h> +#include <linux/amba/serial.h> #include <linux/io.h> #include <linux/smsc911x.h> #include <linux/ata_platform.h> @@ -46,6 +48,7 @@ #include <asm/mach/map.h> #include <asm/hardware/gic.h> +#include <asm/hardware/pl080.h> #include <mach/clkdev.h> #include <mach/platform.h> @@ -619,6 +622,242 @@ struct clcd_board clcd_plat_data = { .remove = realview_clcd_remove, }; + +/* + * DMA config + */ +#ifdef CONFIG_AMBA_PL08X + +/* State of the big DMA mux */ +static u32 current_mux = 0x00; +static u32 mux_users = 0x00; +static spinlock_t current_mux_lock = SPIN_LOCK_UNLOCKED; + +static int pl081_get_signal(struct pl08x_dma_chan *ch) +{ + struct pl08x_channel_data *cd = ch->cd; + unsigned long flags; + u32 val; + + spin_lock_irqsave(¤t_mux_lock, flags); + /* + * We're on the same mux so fine, go ahead! + */ + if (cd->muxval == current_mux) { + mux_users ++; + spin_unlock_irqrestore(¤t_mux_lock, flags); + /* We still have to write it since it may be OFF by default */ + val = readl(__io_address(REALVIEW_SYS_DMAPSR)); + val &= 0xFFFFFFFCU; + val |= current_mux; + writel(val, __io_address(REALVIEW_SYS_DMAPSR)); + return cd->min_signal; + } + /* + * If we're not on the same mux and there are already + * users on the other mux setting, tough luck, the client + * can come back and retry or give up and fall back to + * PIO mode. + */ + if (mux_users) { + spin_unlock_irqrestore(¤t_mux_lock, flags); + return -EBUSY; + } + + /* Switch mux setting */ + current_mux = cd->muxval; + + val = readl(__io_address(REALVIEW_SYS_DMAPSR)); + val &= 0xFFFFFFFCU; + val |= cd->muxval; + writel(val, __io_address(REALVIEW_SYS_DMAPSR)); + + pr_info("%s: muxing in %s in bank %d writing value " + "%08x to register %08x\n", + __func__, ch->name, cd->muxval, + val, REALVIEW_SYS_DMAPSR); + + spin_unlock_irqrestore(¤t_mux_lock, flags); + + return cd->min_signal; +} + +static void pl081_put_signal(struct pl08x_dma_chan *ch) +{ + unsigned long flags; + + spin_lock_irqsave(¤t_mux_lock, flags); + mux_users--; + spin_unlock_irqrestore(¤t_mux_lock, flags); +} + +#define PRIMECELL_DEFAULT_CCTL (PL080_BSIZE_8 << PL080_CONTROL_SB_SIZE_SHIFT | \ + PL080_BSIZE_8 << PL080_CONTROL_DB_SIZE_SHIFT | \ + PL080_WIDTH_32BIT << PL080_CONTROL_SWIDTH_SHIFT | \ + PL080_WIDTH_32BIT << PL080_CONTROL_DWIDTH_SHIFT | \ + PL080_CONTROL_PROT_SYS) + +/* Muxed channels as found in most RealViews */ +struct pl08x_channel_data realview_chan_data[] = { + /* Muxed on signal bank 0 */ + [0] = { + .bus_id = "usb0", + .min_signal = 0, + .max_signal = 0, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + }, + [1] = { + .bus_id = "usb1", + .min_signal = 1, + .max_signal = 1, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + }, + [2] = { + .bus_id = "t1dmac0", + .min_signal = 2, + .max_signal = 2, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + }, + [3] = { + .bus_id = "mci0", + .min_signal = 3, + .max_signal = 3, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + }, + [4] = { + .bus_id = "aacitx", + .min_signal = 4, + .max_signal = 4, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [5] = { + .bus_id = "aacirx", + .min_signal = 5, + .max_signal = 5, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [6] = { + .bus_id = "scirx", + .min_signal = 6, + .max_signal = 6, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [7] = { + .bus_id = "scitx", + .min_signal = 7, + .max_signal = 7, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + /* Muxed on signal bank 1 */ + [8] = { + .bus_id = "ssprx", + .min_signal = 0, + .max_signal = 0, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [9] = { + .bus_id = "ssptx", + .min_signal = 1, + .max_signal = 1, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [10] = { + .bus_id = "uart2rx", + .min_signal = 2, + .max_signal = 2, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [11] = { + .bus_id = "uart2tx", + .min_signal = 3, + .max_signal = 3, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [12] = { + .bus_id = "uart1rx", + .min_signal = 4, + .max_signal = 4, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [13] = { + .bus_id = "uart1tx", + .min_signal = 5, + .max_signal = 5, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [14] = { + .bus_id = "uart0rx", + .min_signal = 6, + .max_signal = 6, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [15] = { + .bus_id = "uart0tx", + .min_signal = 7, + .max_signal = 7, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, +}; + +struct pl08x_platform_data pl081_plat_data = { + .memcpy_channel = { + .bus_id = "memcpy", + /* + * We pass in some optimal memcpy config, the + * driver will augment it if need be. 256 byte + * bursts and 32bit bus width. + */ + .cctl = + (PL080_BSIZE_256 << PL080_CONTROL_SB_SIZE_SHIFT | \ + PL080_BSIZE_256 << PL080_CONTROL_DB_SIZE_SHIFT | \ + PL080_WIDTH_32BIT << PL080_CONTROL_SWIDTH_SHIFT | \ + PL080_WIDTH_32BIT << PL080_CONTROL_DWIDTH_SHIFT | \ + PL080_CONTROL_PROT_BUFF | \ + PL080_CONTROL_PROT_CACHE | \ + PL080_CONTROL_PROT_SYS), + /* Flow control: DMAC controls this */ + .ccfg = PL080_FLOW_MEM2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + .slave_channels = realview_chan_data, + .num_slave_channels = ARRAY_SIZE(realview_chan_data), + .get_signal = pl081_get_signal, + .put_signal = pl081_put_signal, +}; + +#else +struct pl08x_platform_data pl081_plat_data = { +}; +#endif + + #ifdef CONFIG_LEDS #define VA_LEDS_BASE (__io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_LED_OFFSET) diff --git a/arch/arm/mach-realview/core.h b/arch/arm/mach-realview/core.h index 781bca6..af8427f 100644 --- a/arch/arm/mach-realview/core.h +++ b/arch/arm/mach-realview/core.h @@ -53,12 +53,14 @@ extern struct platform_device realview_i2c_device; extern struct mmci_platform_data realview_mmc0_plat_data; extern struct mmci_platform_data realview_mmc1_plat_data; extern struct clcd_board clcd_plat_data; +extern struct pl08x_platform_data pl081_plat_data; extern void __iomem *gic_cpu_base_addr; extern void __iomem *timer0_va_base; extern void __iomem *timer1_va_base; extern void __iomem *timer2_va_base; extern void __iomem *timer3_va_base; +extern void pl081_fixup(void); extern void realview_leds_event(led_event_t ledevt); extern void realview_timer_init(unsigned int timer_irq); extern int realview_flash_register(struct resource *res, u32 num); diff --git a/arch/arm/mach-realview/include/mach/platform.h b/arch/arm/mach-realview/include/mach/platform.h index 1b77a27..934c5c2 100644 --- a/arch/arm/mach-realview/include/mach/platform.h +++ b/arch/arm/mach-realview/include/mach/platform.h @@ -77,6 +77,7 @@ #define REALVIEW_SYS_BOOTCS_OFFSET 0x58 #define REALVIEW_SYS_24MHz_OFFSET 0x5C #define REALVIEW_SYS_MISC_OFFSET 0x60 +#define REALVIEW_SYS_DMAPSR_OFFSET 0x64 #define REALVIEW_SYS_IOSEL_OFFSET 0x70 #define REALVIEW_SYS_PROCID_OFFSET 0x84 #define REALVIEW_SYS_TEST_OSC0_OFFSET 0xC0 @@ -111,6 +112,7 @@ #define REALVIEW_SYS_BOOTCS (REALVIEW_SYS_BASE + REALVIEW_SYS_BOOTCS_OFFSET) #define REALVIEW_SYS_24MHz (REALVIEW_SYS_BASE + REALVIEW_SYS_24MHz_OFFSET) #define REALVIEW_SYS_MISC (REALVIEW_SYS_BASE + REALVIEW_SYS_MISC_OFFSET) +#define REALVIEW_SYS_DMAPSR (REALVIEW_SYS_BASE + REALVIEW_SYS_DMAPSR_OFFSET) #define REALVIEW_SYS_IOSEL (REALVIEW_SYS_BASE + REALVIEW_SYS_IOSEL_OFFSET) #define REALVIEW_SYS_PROCID (REALVIEW_SYS_BASE + REALVIEW_SYS_PROCID_OFFSET) #define REALVIEW_SYS_TEST_OSC0 (REALVIEW_SYS_BASE + REALVIEW_SYS_TEST_OSC0_OFFSET) diff --git a/arch/arm/mach-realview/realview_eb.c b/arch/arm/mach-realview/realview_eb.c index 991c1f8..3117510 100644 --- a/arch/arm/mach-realview/realview_eb.c +++ b/arch/arm/mach-realview/realview_eb.c @@ -23,6 +23,7 @@ #include <linux/platform_device.h> #include <linux/sysdev.h> #include <linux/amba/bus.h> +#include <linux/amba/pl08x.h> #include <linux/amba/pl061.h> #include <linux/amba/mmci.h> #include <linux/amba/pl022.h> @@ -209,7 +210,7 @@ AMBA_DEVICE(uart3, "fpga:uart3", EB_UART3, NULL); /* DevChip Primecells */ AMBA_DEVICE(smc, "dev:smc", EB_SMC, NULL); AMBA_DEVICE(clcd, "dev:clcd", EB_CLCD, &clcd_plat_data); -AMBA_DEVICE(dmac, "dev:dmac", DMAC, NULL); +AMBA_DEVICE(dmac, "dev:dmac", DMAC, &pl081_plat_data); AMBA_DEVICE(sctl, "dev:sctl", SCTL, NULL); AMBA_DEVICE(wdog, "dev:wdog", EB_WATCHDOG, NULL); AMBA_DEVICE(gpio0, "dev:gpio0", EB_GPIO0, &gpio0_plat_data); diff --git a/arch/arm/mach-realview/realview_pb11mp.c b/arch/arm/mach-realview/realview_pb11mp.c index d591bc0..50e921b 100644 --- a/arch/arm/mach-realview/realview_pb11mp.c +++ b/arch/arm/mach-realview/realview_pb11mp.c @@ -23,9 +23,11 @@ #include <linux/platform_device.h> #include <linux/sysdev.h> #include <linux/amba/bus.h> +#include <linux/amba/pl08x.h> #include <linux/amba/pl061.h> #include <linux/amba/mmci.h> #include <linux/amba/pl022.h> +#include <linux/amba/serial.h> #include <linux/io.h> #include <mach/hardware.h> @@ -127,8 +129,39 @@ static struct pl061_platform_data gpio2_plat_data = { static struct pl022_ssp_controller ssp0_plat_data = { .bus_id = 0, - .enable_dma = 0, .num_chipselect = 1, +#ifdef CONFIG_AMBA_PL08X + .enable_dma = 1, + .dma_filter = pl08x_filter_id, + .dma_rx_param = (void *) "ssprx", + .dma_tx_param = (void *) "ssptx", +#else + .enable_dma = 0, +#endif +}; + +static struct amba_pl011_data uart0_plat_data = { +#ifdef CONFIG_AMBA_PL08X + .dma_filter = pl08x_filter_id, + .dma_rx_param = (void *) "uart0rx", + .dma_tx_param = (void *) "uart0tx", +#endif +}; + +static struct amba_pl011_data uart1_plat_data = { +#ifdef CONFIG_AMBA_PL08X + .dma_filter = pl08x_filter_id, + .dma_rx_param = (void *) "uart1rx", + .dma_tx_param = (void *) "uart1tx", +#endif +}; + +static struct amba_pl011_data uart2_plat_data = { +#ifdef CONFIG_AMBA_PL08X + .dma_filter = pl08x_filter_id, + .dma_rx_param = (void *) "uart2rx", + .dma_tx_param = (void *) "uart2tx", +#endif }; /* @@ -194,14 +227,14 @@ AMBA_DEVICE(gpio1, "dev:gpio1", GPIO1, &gpio1_plat_data); AMBA_DEVICE(gpio2, "dev:gpio2", GPIO2, &gpio2_plat_data); AMBA_DEVICE(rtc, "dev:rtc", PB11MP_RTC, NULL); AMBA_DEVICE(sci0, "dev:sci0", SCI, NULL); -AMBA_DEVICE(uart0, "dev:uart0", PB11MP_UART0, NULL); -AMBA_DEVICE(uart1, "dev:uart1", PB11MP_UART1, NULL); -AMBA_DEVICE(uart2, "dev:uart2", PB11MP_UART2, NULL); +AMBA_DEVICE(uart0, "dev:uart0", PB11MP_UART0, &uart0_plat_data); +AMBA_DEVICE(uart1, "dev:uart1", PB11MP_UART1, &uart1_plat_data); +AMBA_DEVICE(uart2, "dev:uart2", PB11MP_UART2, &uart2_plat_data); AMBA_DEVICE(ssp0, "dev:ssp0", PB11MP_SSP, &ssp0_plat_data); /* Primecells on the NEC ISSP chip */ AMBA_DEVICE(clcd, "issp:clcd", PB11MP_CLCD, &clcd_plat_data); -AMBA_DEVICE(dmac, "issp:dmac", DMAC, NULL); +AMBA_DEVICE(dmac, "issp:dmac", DMAC, &pl081_plat_data); static struct amba_device *amba_devs[] __initdata = { &dmac_device, diff --git a/arch/arm/mach-realview/realview_pba8.c b/arch/arm/mach-realview/realview_pba8.c index 6c37621..bafd457 100644 --- a/arch/arm/mach-realview/realview_pba8.c +++ b/arch/arm/mach-realview/realview_pba8.c @@ -23,6 +23,7 @@ #include <linux/platform_device.h> #include <linux/sysdev.h> #include <linux/amba/bus.h> +#include <linux/amba/pl08x.h> #include <linux/amba/pl061.h> #include <linux/amba/mmci.h> #include <linux/amba/pl022.h> @@ -191,7 +192,7 @@ AMBA_DEVICE(ssp0, "dev:ssp0", PBA8_SSP, &ssp0_plat_data); /* Primecells on the NEC ISSP chip */ AMBA_DEVICE(clcd, "issp:clcd", PBA8_CLCD, &clcd_plat_data); -AMBA_DEVICE(dmac, "issp:dmac", DMAC, NULL); +AMBA_DEVICE(dmac, "issp:dmac", DMAC, &pl081_plat_data); static struct amba_device *amba_devs[] __initdata = { &dmac_device, diff --git a/arch/arm/mach-realview/realview_pbx.c b/arch/arm/mach-realview/realview_pbx.c index 9428eff..20c7eae 100644 --- a/arch/arm/mach-realview/realview_pbx.c +++ b/arch/arm/mach-realview/realview_pbx.c @@ -22,6 +22,7 @@ #include <linux/platform_device.h> #include <linux/sysdev.h> #include <linux/amba/bus.h> +#include <linux/amba/pl08x.h> #include <linux/amba/pl061.h> #include <linux/amba/mmci.h> #include <linux/amba/pl022.h> @@ -213,7 +214,7 @@ AMBA_DEVICE(ssp0, "dev:ssp0", PBX_SSP, &ssp0_plat_data); /* Primecells on the NEC ISSP chip */ AMBA_DEVICE(clcd, "issp:clcd", PBX_CLCD, &clcd_plat_data); -AMBA_DEVICE(dmac, "issp:dmac", DMAC, NULL); +AMBA_DEVICE(dmac, "issp:dmac", DMAC, &pl081_plat_data); static struct amba_device *amba_devs[] __initdata = { &dmac_device, -- 1.6.3.3 ^ permalink raw reply related [flat|nested] 10+ messages in thread
* [PATCH 6/6] ARM: config RealViews PL011 PL022 for DMA v10 2010-09-01 15:24 ` [PATCH 6/6] ARM: config RealViews PL011 PL022 " Linus Walleij @ 2010-09-01 15:24 ` Linus Walleij 0 siblings, 0 replies; 10+ messages in thread From: Linus Walleij @ 2010-09-01 15:24 UTC (permalink / raw) To: Dan Williams, linux-arm-kernel, yuanyabin1978; +Cc: linux-kernel, Linus Walleij This adds the platform necessary to make the PL08x driver from the async_tx tree probe successfully with the RealView boards (except for the PB1176 which lacks a working DMAC) and thus makes the memcpy channels available on all of them. Further it implements the logic for muxing the two sets of device (slave) DMA channels, so that devices can request their DMA channels and have them muxed in on request. Platform data for the PL022 and PL011 is supplied for the PB11MPCore. This was tested successfully on an PB11MPCore using DMA for the PL022 SPI and PL011 UART simultaneously with the DMA engine test client running memcpy on two of the channels. The slave transfers bail out and switch to PIO mode on oversubscribed channels and memcpy transfers queue if no physical channel is available. Signed-off-by: Linus Walleij <linus.walleij@stericsson.com> --- arch/arm/mach-realview/core.c | 239 ++++++++++++++++++++++++ arch/arm/mach-realview/core.h | 2 + arch/arm/mach-realview/include/mach/platform.h | 2 + arch/arm/mach-realview/realview_eb.c | 3 +- arch/arm/mach-realview/realview_pb11mp.c | 43 ++++- arch/arm/mach-realview/realview_pba8.c | 3 +- arch/arm/mach-realview/realview_pbx.c | 3 +- 7 files changed, 287 insertions(+), 8 deletions(-) diff --git a/arch/arm/mach-realview/core.c b/arch/arm/mach-realview/core.c index 07c0815..937300f 100644 --- a/arch/arm/mach-realview/core.c +++ b/arch/arm/mach-realview/core.c @@ -25,6 +25,8 @@ #include <linux/interrupt.h> #include <linux/amba/bus.h> #include <linux/amba/clcd.h> +#include <linux/amba/pl08x.h> +#include <linux/amba/serial.h> #include <linux/io.h> #include <linux/smsc911x.h> #include <linux/ata_platform.h> @@ -46,6 +48,7 @@ #include <asm/mach/map.h> #include <asm/hardware/gic.h> +#include <asm/hardware/pl080.h> #include <mach/clkdev.h> #include <mach/platform.h> @@ -619,6 +622,242 @@ struct clcd_board clcd_plat_data = { .remove = realview_clcd_remove, }; + +/* + * DMA config + */ +#ifdef CONFIG_AMBA_PL08X + +/* State of the big DMA mux */ +static u32 current_mux = 0x00; +static u32 mux_users = 0x00; +static spinlock_t current_mux_lock = SPIN_LOCK_UNLOCKED; + +static int pl081_get_signal(struct pl08x_dma_chan *ch) +{ + struct pl08x_channel_data *cd = ch->cd; + unsigned long flags; + u32 val; + + spin_lock_irqsave(¤t_mux_lock, flags); + /* + * We're on the same mux so fine, go ahead! + */ + if (cd->muxval == current_mux) { + mux_users ++; + spin_unlock_irqrestore(¤t_mux_lock, flags); + /* We still have to write it since it may be OFF by default */ + val = readl(__io_address(REALVIEW_SYS_DMAPSR)); + val &= 0xFFFFFFFCU; + val |= current_mux; + writel(val, __io_address(REALVIEW_SYS_DMAPSR)); + return cd->min_signal; + } + /* + * If we're not on the same mux and there are already + * users on the other mux setting, tough luck, the client + * can come back and retry or give up and fall back to + * PIO mode. + */ + if (mux_users) { + spin_unlock_irqrestore(¤t_mux_lock, flags); + return -EBUSY; + } + + /* Switch mux setting */ + current_mux = cd->muxval; + + val = readl(__io_address(REALVIEW_SYS_DMAPSR)); + val &= 0xFFFFFFFCU; + val |= cd->muxval; + writel(val, __io_address(REALVIEW_SYS_DMAPSR)); + + pr_info("%s: muxing in %s in bank %d writing value " + "%08x to register %08x\n", + __func__, ch->name, cd->muxval, + val, REALVIEW_SYS_DMAPSR); + + spin_unlock_irqrestore(¤t_mux_lock, flags); + + return cd->min_signal; +} + +static void pl081_put_signal(struct pl08x_dma_chan *ch) +{ + unsigned long flags; + + spin_lock_irqsave(¤t_mux_lock, flags); + mux_users--; + spin_unlock_irqrestore(¤t_mux_lock, flags); +} + +#define PRIMECELL_DEFAULT_CCTL (PL080_BSIZE_8 << PL080_CONTROL_SB_SIZE_SHIFT | \ + PL080_BSIZE_8 << PL080_CONTROL_DB_SIZE_SHIFT | \ + PL080_WIDTH_32BIT << PL080_CONTROL_SWIDTH_SHIFT | \ + PL080_WIDTH_32BIT << PL080_CONTROL_DWIDTH_SHIFT | \ + PL080_CONTROL_PROT_SYS) + +/* Muxed channels as found in most RealViews */ +struct pl08x_channel_data realview_chan_data[] = { + /* Muxed on signal bank 0 */ + [0] = { + .bus_id = "usb0", + .min_signal = 0, + .max_signal = 0, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + }, + [1] = { + .bus_id = "usb1", + .min_signal = 1, + .max_signal = 1, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + }, + [2] = { + .bus_id = "t1dmac0", + .min_signal = 2, + .max_signal = 2, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + }, + [3] = { + .bus_id = "mci0", + .min_signal = 3, + .max_signal = 3, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + }, + [4] = { + .bus_id = "aacitx", + .min_signal = 4, + .max_signal = 4, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [5] = { + .bus_id = "aacirx", + .min_signal = 5, + .max_signal = 5, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [6] = { + .bus_id = "scirx", + .min_signal = 6, + .max_signal = 6, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [7] = { + .bus_id = "scitx", + .min_signal = 7, + .max_signal = 7, + .muxval = 0x00, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + /* Muxed on signal bank 1 */ + [8] = { + .bus_id = "ssprx", + .min_signal = 0, + .max_signal = 0, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [9] = { + .bus_id = "ssptx", + .min_signal = 1, + .max_signal = 1, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [10] = { + .bus_id = "uart2rx", + .min_signal = 2, + .max_signal = 2, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [11] = { + .bus_id = "uart2tx", + .min_signal = 3, + .max_signal = 3, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [12] = { + .bus_id = "uart1rx", + .min_signal = 4, + .max_signal = 4, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [13] = { + .bus_id = "uart1tx", + .min_signal = 5, + .max_signal = 5, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [14] = { + .bus_id = "uart0rx", + .min_signal = 6, + .max_signal = 6, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + [15] = { + .bus_id = "uart0tx", + .min_signal = 7, + .max_signal = 7, + .muxval = 0x01, + .cctl = PRIMECELL_DEFAULT_CCTL, + .ccfg = PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, +}; + +struct pl08x_platform_data pl081_plat_data = { + .memcpy_channel = { + .bus_id = "memcpy", + /* + * We pass in some optimal memcpy config, the + * driver will augment it if need be. 256 byte + * bursts and 32bit bus width. + */ + .cctl = + (PL080_BSIZE_256 << PL080_CONTROL_SB_SIZE_SHIFT | \ + PL080_BSIZE_256 << PL080_CONTROL_DB_SIZE_SHIFT | \ + PL080_WIDTH_32BIT << PL080_CONTROL_SWIDTH_SHIFT | \ + PL080_WIDTH_32BIT << PL080_CONTROL_DWIDTH_SHIFT | \ + PL080_CONTROL_PROT_BUFF | \ + PL080_CONTROL_PROT_CACHE | \ + PL080_CONTROL_PROT_SYS), + /* Flow control: DMAC controls this */ + .ccfg = PL080_FLOW_MEM2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT, + }, + .slave_channels = realview_chan_data, + .num_slave_channels = ARRAY_SIZE(realview_chan_data), + .get_signal = pl081_get_signal, + .put_signal = pl081_put_signal, +}; + +#else +struct pl08x_platform_data pl081_plat_data = { +}; +#endif + + #ifdef CONFIG_LEDS #define VA_LEDS_BASE (__io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_LED_OFFSET) diff --git a/arch/arm/mach-realview/core.h b/arch/arm/mach-realview/core.h index 781bca6..af8427f 100644 --- a/arch/arm/mach-realview/core.h +++ b/arch/arm/mach-realview/core.h @@ -53,12 +53,14 @@ extern struct platform_device realview_i2c_device; extern struct mmci_platform_data realview_mmc0_plat_data; extern struct mmci_platform_data realview_mmc1_plat_data; extern struct clcd_board clcd_plat_data; +extern struct pl08x_platform_data pl081_plat_data; extern void __iomem *gic_cpu_base_addr; extern void __iomem *timer0_va_base; extern void __iomem *timer1_va_base; extern void __iomem *timer2_va_base; extern void __iomem *timer3_va_base; +extern void pl081_fixup(void); extern void realview_leds_event(led_event_t ledevt); extern void realview_timer_init(unsigned int timer_irq); extern int realview_flash_register(struct resource *res, u32 num); diff --git a/arch/arm/mach-realview/include/mach/platform.h b/arch/arm/mach-realview/include/mach/platform.h index 1b77a27..934c5c2 100644 --- a/arch/arm/mach-realview/include/mach/platform.h +++ b/arch/arm/mach-realview/include/mach/platform.h @@ -77,6 +77,7 @@ #define REALVIEW_SYS_BOOTCS_OFFSET 0x58 #define REALVIEW_SYS_24MHz_OFFSET 0x5C #define REALVIEW_SYS_MISC_OFFSET 0x60 +#define REALVIEW_SYS_DMAPSR_OFFSET 0x64 #define REALVIEW_SYS_IOSEL_OFFSET 0x70 #define REALVIEW_SYS_PROCID_OFFSET 0x84 #define REALVIEW_SYS_TEST_OSC0_OFFSET 0xC0 @@ -111,6 +112,7 @@ #define REALVIEW_SYS_BOOTCS (REALVIEW_SYS_BASE + REALVIEW_SYS_BOOTCS_OFFSET) #define REALVIEW_SYS_24MHz (REALVIEW_SYS_BASE + REALVIEW_SYS_24MHz_OFFSET) #define REALVIEW_SYS_MISC (REALVIEW_SYS_BASE + REALVIEW_SYS_MISC_OFFSET) +#define REALVIEW_SYS_DMAPSR (REALVIEW_SYS_BASE + REALVIEW_SYS_DMAPSR_OFFSET) #define REALVIEW_SYS_IOSEL (REALVIEW_SYS_BASE + REALVIEW_SYS_IOSEL_OFFSET) #define REALVIEW_SYS_PROCID (REALVIEW_SYS_BASE + REALVIEW_SYS_PROCID_OFFSET) #define REALVIEW_SYS_TEST_OSC0 (REALVIEW_SYS_BASE + REALVIEW_SYS_TEST_OSC0_OFFSET) diff --git a/arch/arm/mach-realview/realview_eb.c b/arch/arm/mach-realview/realview_eb.c index 991c1f8..3117510 100644 --- a/arch/arm/mach-realview/realview_eb.c +++ b/arch/arm/mach-realview/realview_eb.c @@ -23,6 +23,7 @@ #include <linux/platform_device.h> #include <linux/sysdev.h> #include <linux/amba/bus.h> +#include <linux/amba/pl08x.h> #include <linux/amba/pl061.h> #include <linux/amba/mmci.h> #include <linux/amba/pl022.h> @@ -209,7 +210,7 @@ AMBA_DEVICE(uart3, "fpga:uart3", EB_UART3, NULL); /* DevChip Primecells */ AMBA_DEVICE(smc, "dev:smc", EB_SMC, NULL); AMBA_DEVICE(clcd, "dev:clcd", EB_CLCD, &clcd_plat_data); -AMBA_DEVICE(dmac, "dev:dmac", DMAC, NULL); +AMBA_DEVICE(dmac, "dev:dmac", DMAC, &pl081_plat_data); AMBA_DEVICE(sctl, "dev:sctl", SCTL, NULL); AMBA_DEVICE(wdog, "dev:wdog", EB_WATCHDOG, NULL); AMBA_DEVICE(gpio0, "dev:gpio0", EB_GPIO0, &gpio0_plat_data); diff --git a/arch/arm/mach-realview/realview_pb11mp.c b/arch/arm/mach-realview/realview_pb11mp.c index d591bc0..50e921b 100644 --- a/arch/arm/mach-realview/realview_pb11mp.c +++ b/arch/arm/mach-realview/realview_pb11mp.c @@ -23,9 +23,11 @@ #include <linux/platform_device.h> #include <linux/sysdev.h> #include <linux/amba/bus.h> +#include <linux/amba/pl08x.h> #include <linux/amba/pl061.h> #include <linux/amba/mmci.h> #include <linux/amba/pl022.h> +#include <linux/amba/serial.h> #include <linux/io.h> #include <mach/hardware.h> @@ -127,8 +129,39 @@ static struct pl061_platform_data gpio2_plat_data = { static struct pl022_ssp_controller ssp0_plat_data = { .bus_id = 0, - .enable_dma = 0, .num_chipselect = 1, +#ifdef CONFIG_AMBA_PL08X + .enable_dma = 1, + .dma_filter = pl08x_filter_id, + .dma_rx_param = (void *) "ssprx", + .dma_tx_param = (void *) "ssptx", +#else + .enable_dma = 0, +#endif +}; + +static struct amba_pl011_data uart0_plat_data = { +#ifdef CONFIG_AMBA_PL08X + .dma_filter = pl08x_filter_id, + .dma_rx_param = (void *) "uart0rx", + .dma_tx_param = (void *) "uart0tx", +#endif +}; + +static struct amba_pl011_data uart1_plat_data = { +#ifdef CONFIG_AMBA_PL08X + .dma_filter = pl08x_filter_id, + .dma_rx_param = (void *) "uart1rx", + .dma_tx_param = (void *) "uart1tx", +#endif +}; + +static struct amba_pl011_data uart2_plat_data = { +#ifdef CONFIG_AMBA_PL08X + .dma_filter = pl08x_filter_id, + .dma_rx_param = (void *) "uart2rx", + .dma_tx_param = (void *) "uart2tx", +#endif }; /* @@ -194,14 +227,14 @@ AMBA_DEVICE(gpio1, "dev:gpio1", GPIO1, &gpio1_plat_data); AMBA_DEVICE(gpio2, "dev:gpio2", GPIO2, &gpio2_plat_data); AMBA_DEVICE(rtc, "dev:rtc", PB11MP_RTC, NULL); AMBA_DEVICE(sci0, "dev:sci0", SCI, NULL); -AMBA_DEVICE(uart0, "dev:uart0", PB11MP_UART0, NULL); -AMBA_DEVICE(uart1, "dev:uart1", PB11MP_UART1, NULL); -AMBA_DEVICE(uart2, "dev:uart2", PB11MP_UART2, NULL); +AMBA_DEVICE(uart0, "dev:uart0", PB11MP_UART0, &uart0_plat_data); +AMBA_DEVICE(uart1, "dev:uart1", PB11MP_UART1, &uart1_plat_data); +AMBA_DEVICE(uart2, "dev:uart2", PB11MP_UART2, &uart2_plat_data); AMBA_DEVICE(ssp0, "dev:ssp0", PB11MP_SSP, &ssp0_plat_data); /* Primecells on the NEC ISSP chip */ AMBA_DEVICE(clcd, "issp:clcd", PB11MP_CLCD, &clcd_plat_data); -AMBA_DEVICE(dmac, "issp:dmac", DMAC, NULL); +AMBA_DEVICE(dmac, "issp:dmac", DMAC, &pl081_plat_data); static struct amba_device *amba_devs[] __initdata = { &dmac_device, diff --git a/arch/arm/mach-realview/realview_pba8.c b/arch/arm/mach-realview/realview_pba8.c index 6c37621..bafd457 100644 --- a/arch/arm/mach-realview/realview_pba8.c +++ b/arch/arm/mach-realview/realview_pba8.c @@ -23,6 +23,7 @@ #include <linux/platform_device.h> #include <linux/sysdev.h> #include <linux/amba/bus.h> +#include <linux/amba/pl08x.h> #include <linux/amba/pl061.h> #include <linux/amba/mmci.h> #include <linux/amba/pl022.h> @@ -191,7 +192,7 @@ AMBA_DEVICE(ssp0, "dev:ssp0", PBA8_SSP, &ssp0_plat_data); /* Primecells on the NEC ISSP chip */ AMBA_DEVICE(clcd, "issp:clcd", PBA8_CLCD, &clcd_plat_data); -AMBA_DEVICE(dmac, "issp:dmac", DMAC, NULL); +AMBA_DEVICE(dmac, "issp:dmac", DMAC, &pl081_plat_data); static struct amba_device *amba_devs[] __initdata = { &dmac_device, diff --git a/arch/arm/mach-realview/realview_pbx.c b/arch/arm/mach-realview/realview_pbx.c index 9428eff..20c7eae 100644 --- a/arch/arm/mach-realview/realview_pbx.c +++ b/arch/arm/mach-realview/realview_pbx.c @@ -22,6 +22,7 @@ #include <linux/platform_device.h> #include <linux/sysdev.h> #include <linux/amba/bus.h> +#include <linux/amba/pl08x.h> #include <linux/amba/pl061.h> #include <linux/amba/mmci.h> #include <linux/amba/pl022.h> @@ -213,7 +214,7 @@ AMBA_DEVICE(ssp0, "dev:ssp0", PBX_SSP, &ssp0_plat_data); /* Primecells on the NEC ISSP chip */ AMBA_DEVICE(clcd, "issp:clcd", PBX_CLCD, &clcd_plat_data); -AMBA_DEVICE(dmac, "issp:dmac", DMAC, NULL); +AMBA_DEVICE(dmac, "issp:dmac", DMAC, &pl081_plat_data); static struct amba_device *amba_devs[] __initdata = { &dmac_device, -- 1.6.3.3 ^ permalink raw reply related [flat|nested] 10+ messages in thread
* Re: [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 2010-09-01 15:24 ` [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 Linus Walleij 2010-09-01 15:24 ` [PATCH 2/6] ARM: add PrimeCell generic DMA to PL011 v10 Linus Walleij @ 2010-09-23 21:31 ` Dan Williams 2010-09-28 14:53 ` Linus Walleij 1 sibling, 1 reply; 10+ messages in thread From: Dan Williams @ 2010-09-23 21:31 UTC (permalink / raw) To: Linus Walleij; +Cc: linux-arm-kernel, yuanyabin1978, linux-kernel On Wed, Sep 1, 2010 at 8:24 AM, Linus Walleij <linus.walleij@stericsson.com> wrote: > This extends the PL022 SSP/SPI driver with generic DMA engine > support using the PrimeCell DMA engine interface. Also fix up the > test code for the U300 platform. > > Acked-by: Grant Likely <grant.likely@secretlab.ca> > Signed-off-by: Linus Walleij <linus.walleij@stericsson.com> > --- > As mentioned I have no clue to why this failed to compile for Grant, > please see if this tenth version is still problematic or if it was > something intermittent. > > Else I really need help in knowing what config to compile, this was > compiled for U300, U8500 and RealView with and without DMA enabled. Maybe it makes more sense for these filter_id functions to be defined in the arch code rather than the dma driver. Right now there seems to be a weird dependency of arch requires dma-driver, dma-driver requires arch, and slave-driver requires arch and dma-driver in order to dynamically select dma-driver with dma_request_channel(). It forces dma-driver and slave-driver to always be compiled in, if I am reading this correctly. -- Dan ^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 2010-09-23 21:31 ` [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 Dan Williams @ 2010-09-28 14:53 ` Linus Walleij 0 siblings, 0 replies; 10+ messages in thread From: Linus Walleij @ 2010-09-28 14:53 UTC (permalink / raw) To: Dan Williams Cc: linux-arm-kernel@lists.infradead.org, yuanyabin1978@sina.com, linux-kernel@vger.kernel.org Dan Williams wrote: > [Me] >> As mentioned I have no clue to why this failed to compile for Grant, >> please see if this tenth version is still problematic or if it was >> something intermittent. >> >> Else I really need help in knowing what config to compile, this was >> compiled for U300, U8500 and RealView with and without DMA enabled. > > Maybe it makes more sense for these filter_id functions to be defined > in the arch code rather than the dma driver. Right now there seems to > be a weird dependency of arch requires dma-driver, dma-driver requires > arch, and slave-driver requires arch and dma-driver in order to > dynamically select dma-driver with dma_request_channel(). It forces > dma-driver and slave-driver to always be compiled in, if I am reading > this correctly. I think what happened was two things: - First that I was switching on CONFIG_DMADEVICES rather than CONFIG_DMA_ENGINE which caused the immediate compile warnings - Second I had no dummy filter function for COH901318 and ste_dma40 in case the driver was not compiled in or available as module. I actually think it is OK to request that DMA drivers always be compiled in for slave transfer support, they are *really* infrastructure IMO. And that is why "my" drivers are Kconfig:ed bool. Yours, Linus Walleij ^ permalink raw reply [flat|nested] 10+ messages in thread
end of thread, other threads:[~2010-09-28 14:53 UTC | newest] Thread overview: 10+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2010-09-01 15:24 PrimeCell generic DMA v10 Linus Walleij 2010-09-01 15:24 ` [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 Linus Walleij 2010-09-01 15:24 ` [PATCH 2/6] ARM: add PrimeCell generic DMA to PL011 v10 Linus Walleij 2010-09-01 15:24 ` [PATCH 3/6] ARM: add PrimeCell generic DMA to MMCI/PL180 v10 Linus Walleij 2010-09-01 15:24 ` [PATCH 4/6] ARM: config U300 PL180 PL011 PL022 for DMA v10 Linus Walleij 2010-09-01 15:24 ` [PATCH 5/6] ARM: config Ux500 PL011 PL022 PL180 " Linus Walleij 2010-09-01 15:24 ` [PATCH 6/6] ARM: config RealViews PL011 PL022 " Linus Walleij 2010-09-01 15:24 ` Linus Walleij 2010-09-23 21:31 ` [PATCH 1/6] ARM: add PrimeCell generic DMA to PL022 v10 Dan Williams 2010-09-28 14:53 ` Linus Walleij
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox