drivers: net: cpsw: remove child devices while driver detach

[cascardo/linux.git] / drivers / spi / spi-sh-msiof.c

diff --git a/drivers/spi/spi-sh-msiof.c b/drivers/spi/spi-sh-msiof.c
index 543075b..3f36540 100644 (file)
--- a/drivers/spi/spi-sh-msiof.c
+++ b/drivers/spi/spi-sh-msiof.c
@@ -642,18 +642,14 @@ static int sh_msiof_dma_once(struct sh_msiof_spi_priv *p, const void *tx,
                desc_rx = dmaengine_prep_slave_single(p->master->dma_rx,
                                        p->rx_dma_addr, len, DMA_FROM_DEVICE,
                                        DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-               if (!desc_rx) {
-                       ret = -EAGAIN;
-                       goto no_dma_rx;
-               }
+               if (!desc_rx)
+                       return -EAGAIN;
 
                desc_rx->callback = sh_msiof_dma_complete;
                desc_rx->callback_param = p;
                cookie = dmaengine_submit(desc_rx);
-               if (dma_submit_error(cookie)) {
-                       ret = cookie;
-                       goto no_dma_rx;
-               }
+               if (dma_submit_error(cookie))
+                       return cookie;
        }
 
        if (tx) {
@@ -738,7 +734,6 @@ no_dma_tx:
        if (rx)
                dmaengine_terminate_all(p->master->dma_rx);
        sh_msiof_write(p, IER, 0);
-no_dma_rx:
        return ret;
 }
 
@@ -933,6 +928,9 @@ static const struct of_device_id sh_msiof_match[] = {
        { .compatible = "renesas,sh-mobile-msiof", .data = &sh_data },
        { .compatible = "renesas,msiof-r8a7790",   .data = &r8a779x_data },
        { .compatible = "renesas,msiof-r8a7791",   .data = &r8a779x_data },
+       { .compatible = "renesas,msiof-r8a7792",   .data = &r8a779x_data },
+       { .compatible = "renesas,msiof-r8a7793",   .data = &r8a779x_data },
+       { .compatible = "renesas,msiof-r8a7794",   .data = &r8a779x_data },
        {},
 };
 MODULE_DEVICE_TABLE(of, sh_msiof_match);
@@ -977,20 +975,24 @@ static struct dma_chan *sh_msiof_request_dma_chan(struct device *dev,
        dma_cap_zero(mask);
        dma_cap_set(DMA_SLAVE, mask);
 
-       chan = dma_request_channel(mask, shdma_chan_filter,
-                                 (void *)(unsigned long)id);
+       chan = dma_request_slave_channel_compat(mask, shdma_chan_filter,
+                               (void *)(unsigned long)id, dev,
+                               dir == DMA_MEM_TO_DEV ? "tx" : "rx");
        if (!chan) {
-               dev_warn(dev, "dma_request_channel failed\n");
+               dev_warn(dev, "dma_request_slave_channel_compat failed\n");
                return NULL;
        }
 
        memset(&cfg, 0, sizeof(cfg));
        cfg.slave_id = id;
        cfg.direction = dir;
-       if (dir == DMA_MEM_TO_DEV)
+       if (dir == DMA_MEM_TO_DEV) {
                cfg.dst_addr = port_addr;
-       else
+               cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+       } else {
                cfg.src_addr = port_addr;
+               cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+       }
 
        ret = dmaengine_slave_config(chan, &cfg);
        if (ret) {
@@ -1007,12 +1009,22 @@ static int sh_msiof_request_dma(struct sh_msiof_spi_priv *p)
        struct platform_device *pdev = p->pdev;
        struct device *dev = &pdev->dev;
        const struct sh_msiof_spi_info *info = dev_get_platdata(dev);
+       unsigned int dma_tx_id, dma_rx_id;
        const struct resource *res;
        struct spi_master *master;
        struct device *tx_dev, *rx_dev;
 
-       if (!info || !info->dma_tx_id || !info->dma_rx_id)
-               return 0;       /* The driver assumes no error */
+       if (dev->of_node) {
+               /* In the OF case we will get the slave IDs from the DT */
+               dma_tx_id = 0;
+               dma_rx_id = 0;
+       } else if (info && info->dma_tx_id && info->dma_rx_id) {
+               dma_tx_id = info->dma_tx_id;
+               dma_rx_id = info->dma_rx_id;
+       } else {
+               /* The driver assumes no error */
+               return 0;
+       }
 
        /* The DMA engine uses the second register set, if present */
        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
@@ -1021,13 +1033,13 @@ static int sh_msiof_request_dma(struct sh_msiof_spi_priv *p)
 
        master = p->master;
        master->dma_tx = sh_msiof_request_dma_chan(dev, DMA_MEM_TO_DEV,
-                                                  info->dma_tx_id,
+                                                  dma_tx_id,
                                                   res->start + TFDR);
        if (!master->dma_tx)
                return -ENODEV;
 
        master->dma_rx = sh_msiof_request_dma_chan(dev, DMA_DEV_TO_MEM,
-                                                  info->dma_rx_id,
+                                                  dma_rx_id,
                                                   res->start + RFDR);
        if (!master->dma_rx)
                goto free_tx_chan;
@@ -1210,6 +1222,9 @@ static struct platform_device_id spi_driver_ids[] = {
        { "spi_sh_msiof",       (kernel_ulong_t)&sh_data },
        { "spi_r8a7790_msiof",  (kernel_ulong_t)&r8a779x_data },
        { "spi_r8a7791_msiof",  (kernel_ulong_t)&r8a779x_data },
+       { "spi_r8a7792_msiof",  (kernel_ulong_t)&r8a779x_data },
+       { "spi_r8a7793_msiof",  (kernel_ulong_t)&r8a779x_data },
+       { "spi_r8a7794_msiof",  (kernel_ulong_t)&r8a779x_data },
        {},
 };
 MODULE_DEVICE_TABLE(platform, spi_driver_ids);