dma_addr_t first_dma;
        dma_addr_t meta_dma;
        struct scatterlist *sg;
-       struct scatterlist inline_sg[0];
 };
 
 /*
        return true;
 }
 
-/*
- * Max size of iod being embedded in the request payload
- */
-#define NVME_INT_PAGES         2
-#define NVME_INT_BYTES(dev)    (NVME_INT_PAGES * (dev)->ctrl.page_size)
-
 /*
  * Will slightly overestimate the number of pages needed.  This is OK
  * as it only leads to a small amount of wasted memory for the lifetime of
        return alloc_size + sizeof(struct scatterlist) * nseg;
 }
 
-static unsigned int nvme_pci_cmd_size(struct nvme_dev *dev, bool use_sgl)
-{
-       unsigned int alloc_size = nvme_pci_iod_alloc_size(dev,
-                                   NVME_INT_BYTES(dev), NVME_INT_PAGES,
-                                   use_sgl);
-
-       return sizeof(struct nvme_iod) + alloc_size;
-}
-
 static int nvme_admin_init_hctx(struct blk_mq_hw_ctx *hctx, void *data,
                                unsigned int hctx_idx)
 {
                dma_addr = next_dma_addr;
        }
 
-       if (iod->sg != iod->inline_sg)
-               mempool_free(iod->sg, dev->iod_mempool);
+       mempool_free(iod->sg, dev->iod_mempool);
 }
 
 static void nvme_print_sgl(struct scatterlist *sgl, int nents)
        blk_status_t ret = BLK_STS_IOERR;
        int nr_mapped;
 
-       if (blk_rq_payload_bytes(req) > NVME_INT_BYTES(dev) ||
-           blk_rq_nr_phys_segments(req) > NVME_INT_PAGES) {
-               iod->sg = mempool_alloc(dev->iod_mempool, GFP_ATOMIC);
-               if (!iod->sg)
-                       return BLK_STS_RESOURCE;
-       } else {
-               iod->sg = iod->inline_sg;
-       }
+       iod->sg = mempool_alloc(dev->iod_mempool, GFP_ATOMIC);
+       if (!iod->sg)
+               return BLK_STS_RESOURCE;
 
        iod->use_sgl = nvme_pci_use_sgls(dev, req);
 
                dev->admin_tagset.queue_depth = NVME_AQ_MQ_TAG_DEPTH;
                dev->admin_tagset.timeout = ADMIN_TIMEOUT;
                dev->admin_tagset.numa_node = dev_to_node(dev->dev);
-               dev->admin_tagset.cmd_size = nvme_pci_cmd_size(dev, false);
+               dev->admin_tagset.cmd_size = sizeof(struct nvme_iod);
                dev->admin_tagset.flags = BLK_MQ_F_NO_SCHED;
                dev->admin_tagset.driver_data = dev;
 
                dev->tagset.numa_node = dev_to_node(dev->dev);
                dev->tagset.queue_depth =
                                min_t(int, dev->q_depth, BLK_MQ_MAX_DEPTH) - 1;
-               dev->tagset.cmd_size = nvme_pci_cmd_size(dev, false);
-               if ((dev->ctrl.sgls & ((1 << 0) | (1 << 1))) && sgl_threshold) {
-                       dev->tagset.cmd_size = max(dev->tagset.cmd_size,
-                                       nvme_pci_cmd_size(dev, true));
-               }
+               dev->tagset.cmd_size = sizeof(struct nvme_iod);
                dev->tagset.flags = BLK_MQ_F_SHOULD_MERGE;
                dev->tagset.driver_data = dev;