*/
        if ((msg->spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits & SPI_CS_WORD) ||
                                               spi_is_csgpiod(msg->spi))) {
-               ret = spi_split_transfers_maxwords(ctlr, msg, 1, GFP_KERNEL);
+               ret = spi_split_transfers_maxwords(ctlr, msg, 1);
                if (ret) {
                        msg->status = ret;
                        spi_finalize_current_message(ctlr);
                }
        } else {
                ret = spi_split_transfers_maxsize(ctlr, msg,
-                                                 spi_max_transfer_size(msg->spi),
-                                                 GFP_KERNEL | GFP_DMA);
+                                                 spi_max_transfer_size(msg->spi));
                if (ret) {
                        msg->status = ret;
                        spi_finalize_current_message(ctlr);
 static int __spi_split_transfer_maxsize(struct spi_controller *ctlr,
                                        struct spi_message *msg,
                                        struct spi_transfer **xferp,
-                                       size_t maxsize,
-                                       gfp_t gfp)
+                                       size_t maxsize)
 {
        struct spi_transfer *xfer = *xferp, *xfers;
        struct spi_replaced_transfers *srt;
        count = DIV_ROUND_UP(xfer->len, maxsize);
 
        /* Create replacement */
-       srt = spi_replace_transfers(msg, xfer, 1, count, NULL, 0, gfp);
+       srt = spi_replace_transfers(msg, xfer, 1, count, NULL, 0, GFP_KERNEL);
        if (IS_ERR(srt))
                return PTR_ERR(srt);
        xfers = srt->inserted_transfers;
  * @ctlr:    the @spi_controller for this transfer
  * @msg:   the @spi_message to transform
  * @maxsize:  the maximum when to apply this
- * @gfp: GFP allocation flags
  *
  * Return: status of transformation
  */
 int spi_split_transfers_maxsize(struct spi_controller *ctlr,
                                struct spi_message *msg,
-                               size_t maxsize,
-                               gfp_t gfp)
+                               size_t maxsize)
 {
        struct spi_transfer *xfer;
        int ret;
        list_for_each_entry(xfer, &msg->transfers, transfer_list) {
                if (xfer->len > maxsize) {
                        ret = __spi_split_transfer_maxsize(ctlr, msg, &xfer,
-                                                          maxsize, gfp);
+                                                          maxsize);
                        if (ret)
                                return ret;
                }
  * @ctlr:     the @spi_controller for this transfer
  * @msg:      the @spi_message to transform
  * @maxwords: the number of words to limit each transfer to
- * @gfp:      GFP allocation flags
  *
  * Return: status of transformation
  */
 int spi_split_transfers_maxwords(struct spi_controller *ctlr,
                                 struct spi_message *msg,
-                                size_t maxwords,
-                                gfp_t gfp)
+                                size_t maxwords)
 {
        struct spi_transfer *xfer;
 
                maxsize = maxwords * roundup_pow_of_two(BITS_TO_BYTES(xfer->bits_per_word));
                if (xfer->len > maxsize) {
                        ret = __spi_split_transfer_maxsize(ctlr, msg, &xfer,
-                                                          maxsize, gfp);
+                                                          maxsize);
                        if (ret)
                                return ret;
                }