struct mmc_command *cmd, u32 cmd_flags)
 {
        host->cmd = cmd;
-       dev_vdbg(&host->dev,
+       dev_vdbg(host->dev,
                 "start command: ARGR=0x%08x CMDR=0x%08x\n",
                 cmd->arg, cmd_flags);
 
 
        if (data)
                if (!data->host_cookie)
-                       dma_unmap_sg(&host->dev,
+                       dma_unmap_sg(host->dev,
                                     data->sg,
                                     data->sg_len,
                                     dw_mci_get_dma_dir(data));
 {
        struct mmc_data *data = host->data;
 
-       dev_vdbg(&host->dev, "DMA complete\n");
+       dev_vdbg(host->dev, "DMA complete\n");
 
        host->dma_ops->cleanup(host);
 
        dma_support = (mci_readl(host, HCON) >> 16) & 0x3;
 
        if (!dma_support || dma_support > 2) {
-               dev_err(&host->dev,
+               dev_err(host->dev,
                        "Host Controller does not support IDMA Tx.\n");
                host->dma_ops = NULL;
                return -ENODEV;
        }
 
-       dev_info(&host->dev, "Using internal DMA controller.\n");
+       dev_info(host->dev, "Using internal DMA controller.\n");
 
        /* Forward link the descriptor list */
        for (i = 0, p = host->sg_cpu; i < host->ring_size - 1; i++, p++)
                        return -EINVAL;
        }
 
-       sg_len = dma_map_sg(&host->dev,
+       sg_len = dma_map_sg(host->dev,
                            data->sg,
                            data->sg_len,
                            dw_mci_get_dma_dir(data));
                return;
 
        if (data->host_cookie)
-               dma_unmap_sg(&slot->host->dev,
+               dma_unmap_sg(slot->host->dev,
                             data->sg,
                             data->sg_len,
                             dw_mci_get_dma_dir(data));
 
        host->using_dma = 1;
 
-       dev_vdbg(&host->dev,
+       dev_vdbg(host->dev,
                 "sd sg_cpu: %#lx sg_dma: %#lx sg_len: %d\n",
                 (unsigned long)host->sg_cpu, (unsigned long)host->sg_dma,
                 sg_len);
                slot = list_entry(host->queue.next,
                                  struct dw_mci_slot, queue_node);
                list_del(&slot->queue_node);
-               dev_vdbg(&host->dev, "list not empty: %s is next\n",
+               dev_vdbg(host->dev, "list not empty: %s is next\n",
                         mmc_hostname(slot->mmc));
                host->state = STATE_SENDING_CMD;
                dw_mci_start_request(host, slot);
        } else {
-               dev_vdbg(&host->dev, "list empty\n");
+               dev_vdbg(host->dev, "list empty\n");
                host->state = STATE_IDLE;
        }
 
                                        data->bytes_xfered = 0;
                                        data->error = -ETIMEDOUT;
                                } else {
-                                       dev_err(&host->dev,
+                                       dev_err(host->dev,
                                                "data FIFO error "
                                                "(status=%08x)\n",
                                                status);
        struct mmc_host *mmc;
        struct dw_mci_slot *slot;
 
-       mmc = mmc_alloc_host(sizeof(struct dw_mci_slot), &host->dev);
+       mmc = mmc_alloc_host(sizeof(struct dw_mci_slot), host->dev);
        if (!mmc)
                return -ENOMEM;
 
 static void dw_mci_init_dma(struct dw_mci *host)
 {
        /* Alloc memory for sg translation */
-       host->sg_cpu = dma_alloc_coherent(&host->dev, PAGE_SIZE,
+       host->sg_cpu = dma_alloc_coherent(host->dev, PAGE_SIZE,
                                          &host->sg_dma, GFP_KERNEL);
        if (!host->sg_cpu) {
-               dev_err(&host->dev, "%s: could not alloc DMA memory\n",
+               dev_err(host->dev, "%s: could not alloc DMA memory\n",
                        __func__);
                goto no_dma;
        }
        if (host->dma_ops->init && host->dma_ops->start &&
            host->dma_ops->stop && host->dma_ops->cleanup) {
                if (host->dma_ops->init(host)) {
-                       dev_err(&host->dev, "%s: Unable to initialize "
+                       dev_err(host->dev, "%s: Unable to initialize "
                                "DMA Controller.\n", __func__);
                        goto no_dma;
                }
        } else {
-               dev_err(&host->dev, "DMA initialization not found.\n");
+               dev_err(host->dev, "DMA initialization not found.\n");
                goto no_dma;
        }
 
        return;
 
 no_dma:
-       dev_info(&host->dev, "Using PIO mode.\n");
+       dev_info(host->dev, "Using PIO mode.\n");
        host->use_dma = 0;
        return;
 }
        u32 fifo_size;
 
        if (!host->pdata || !host->pdata->init) {
-               dev_err(&host->dev,
+               dev_err(host->dev,
                        "Platform data must supply init function\n");
                return -ENODEV;
        }
 
        if (!host->pdata->select_slot && host->pdata->num_slots > 1) {
-               dev_err(&host->dev,
+               dev_err(host->dev,
                        "Platform data must supply select_slot function\n");
                return -ENODEV;
        }
 
        if (!host->pdata->bus_hz) {
-               dev_err(&host->dev,
+               dev_err(host->dev,
                        "Platform data must supply bus speed\n");
                return -ENODEV;
        }
        }
 
        /* Reset all blocks */
-       if (!mci_wait_reset(&host->dev, host))
+       if (!mci_wait_reset(host->dev, host))
                return -ENODEV;
 
        host->dma_ops = host->pdata->dma_ops;
         * Need to check the version-id and set data-offset for DATA register.
         */
        host->verid = SDMMC_GET_VERID(mci_readl(host, VERID));
-       dev_info(&host->dev, "Version ID is %04x\n", host->verid);
+       dev_info(host->dev, "Version ID is %04x\n", host->verid);
 
        if (host->verid < DW_MMC_240A)
                host->data_offset = DATA_OFFSET;
                   DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
        mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE); /* Enable mci interrupt */
 
-       dev_info(&host->dev, "DW MMC controller at irq %d, "
+       dev_info(host->dev, "DW MMC controller at irq %d, "
                 "%d bit host data width, "
                 "%u deep fifo\n",
                 host->irq, width, fifo_size);
        if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO)
-               dev_info(&host->dev, "Internal DMAC interrupt fix enabled.\n");
+               dev_info(host->dev, "Internal DMAC interrupt fix enabled.\n");
 
        return 0;
 
 err_dmaunmap:
        if (host->use_dma && host->dma_ops->exit)
                host->dma_ops->exit(host);
-       dma_free_coherent(&host->dev, PAGE_SIZE,
+       dma_free_coherent(host->dev, PAGE_SIZE,
                          host->sg_cpu, host->sg_dma);
 
        if (host->vmmc) {
        mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
 
        for (i = 0; i < host->num_slots; i++) {
-               dev_dbg(&host->dev, "remove slot %d\n", i);
+               dev_dbg(host->dev, "remove slot %d\n", i);
                if (host->slot[i])
                        dw_mci_cleanup_slot(host->slot[i], i);
        }
 
        free_irq(host->irq, host);
        destroy_workqueue(host->card_workqueue);
-       dma_free_coherent(&host->dev, PAGE_SIZE, host->sg_cpu, host->sg_dma);
+       dma_free_coherent(host->dev, PAGE_SIZE, host->sg_cpu, host->sg_dma);
 
        if (host->use_dma && host->dma_ops->exit)
                host->dma_ops->exit(host);
        if (host->vmmc)
                regulator_enable(host->vmmc);
 
-       if (!mci_wait_reset(&host->dev, host)) {
+       if (!mci_wait_reset(host->dev, host)) {
                ret = -ENODEV;
                return ret;
        }