* @clk: clock for the controller
  * @regs_base: pointer to ioremap()'d registers
  * @sspdr_phys: physical address of the SSPDR register
- * @irq: IRQ number used by the driver
  * @min_rate: minimum clock rate (in Hz) supported by the controller
  * @max_rate: maximum clock rate (in Hz) supported by the controller
  * @running: is the queue running
        struct clk                      *clk;
        void __iomem                    *regs_base;
        unsigned long                   sspdr_phys;
-       int                             irq;
        unsigned long                   min_rate;
        unsigned long                   max_rate;
        bool                            running;
        struct ep93xx_spi_info *info;
        struct ep93xx_spi *espi;
        struct resource *res;
+       int irq;
        int error;
 
        info = pdev->dev.platform_data;
        espi->min_rate = clk_get_rate(espi->clk) / (254 * 256);
        espi->pdev = pdev;
 
-       espi->irq = platform_get_irq(pdev, 0);
-       if (espi->irq < 0) {
+       irq = platform_get_irq(pdev, 0);
+       if (irq < 0) {
                error = -EBUSY;
                dev_err(&pdev->dev, "failed to get irq resources\n");
                goto fail_put_clock;
                goto fail_put_clock;
        }
 
-       res = request_mem_region(res->start, resource_size(res), pdev->name);
-       if (!res) {
-               dev_err(&pdev->dev, "unable to request iomem resources\n");
-               error = -EBUSY;
-               goto fail_put_clock;
-       }
-
        espi->sspdr_phys = res->start + SSPDR;
-       espi->regs_base = ioremap(res->start, resource_size(res));
+
+       espi->regs_base = devm_request_and_ioremap(&pdev->dev, res);
        if (!espi->regs_base) {
                dev_err(&pdev->dev, "failed to map resources\n");
                error = -ENODEV;
-               goto fail_free_mem;
+               goto fail_put_clock;
        }
 
-       error = request_irq(espi->irq, ep93xx_spi_interrupt, 0,
-                           "ep93xx-spi", espi);
+       error = devm_request_irq(&pdev->dev, irq, ep93xx_spi_interrupt,
+                               0, "ep93xx-spi", espi);
        if (error) {
                dev_err(&pdev->dev, "failed to request irq\n");
-               goto fail_unmap_regs;
+               goto fail_put_clock;
        }
 
        if (info->use_dma && ep93xx_spi_setup_dma(espi))
        }
 
        dev_info(&pdev->dev, "EP93xx SPI Controller at 0x%08lx irq %d\n",
-                (unsigned long)res->start, espi->irq);
+                (unsigned long)res->start, irq);
 
        return 0;
 
        destroy_workqueue(espi->wq);
 fail_free_dma:
        ep93xx_spi_release_dma(espi);
-       free_irq(espi->irq, espi);
-fail_unmap_regs:
-       iounmap(espi->regs_base);
-fail_free_mem:
-       release_mem_region(res->start, resource_size(res));
 fail_put_clock:
        clk_put(espi->clk);
 fail_release_master:
 {
        struct spi_master *master = platform_get_drvdata(pdev);
        struct ep93xx_spi *espi = spi_master_get_devdata(master);
-       struct resource *res;
 
        spin_lock_irq(&espi->lock);
        espi->running = false;
        spin_unlock_irq(&espi->lock);
 
        ep93xx_spi_release_dma(espi);
-       free_irq(espi->irq, espi);
-       iounmap(espi->regs_base);
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       release_mem_region(res->start, resource_size(res));
        clk_put(espi->clk);
        platform_set_drvdata(pdev, NULL);