int retries;
        /* Uplink tty if active */
        struct tty_port port;   /* The tty bound to this DLCI if there is one */
-       struct kfifo *fifo;     /* Queue fifo for the DLCI */
-       struct kfifo _fifo;     /* For new fifo API porting only */
+       struct kfifo fifo;      /* Queue fifo for the DLCI */
        int adaption;           /* Adaption layer in use */
        int prev_adaption;
        u32 modem_rx;           /* Our incoming virtual modem lines */
 
        total_size = 0;
        while (1) {
-               len = kfifo_len(dlci->fifo);
+               len = kfifo_len(&dlci->fifo);
                if (len == 0)
                        return total_size;
 
                        *dp++ = gsm_encode_modem(dlci);
                        break;
                }
-               WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
+               WARN_ON(kfifo_out_locked(&dlci->fifo, dp , len, &dlci->lock) != len);
                __gsm_data_queue(dlci, msg);
                total_size += size;
        }
        dlci->state = DLCI_CLOSED;
        if (dlci->addr != 0) {
                tty_port_tty_hangup(&dlci->port, false);
-               kfifo_reset(dlci->fifo);
+               kfifo_reset(&dlci->fifo);
        } else
                dlci->gsm->dead = 1;
        wake_up(&dlci->gsm->event);
                return NULL;
        spin_lock_init(&dlci->lock);
        mutex_init(&dlci->mutex);
-       dlci->fifo = &dlci->_fifo;
-       if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
+       if (kfifo_alloc(&dlci->fifo, 4096, GFP_KERNEL) < 0) {
                kfree(dlci);
                return NULL;
        }
 
        del_timer_sync(&dlci->t1);
        dlci->gsm->dlci[dlci->addr] = NULL;
-       kfifo_free(dlci->fifo);
+       kfifo_free(&dlci->fifo);
        while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
                dev_kfree_skb(dlci->skb);
        kfree(dlci);
        if (dlci->state == DLCI_CLOSED)
                return -EINVAL;
        /* Stuff the bytes into the fifo queue */
-       sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
+       sent = kfifo_in_locked(&dlci->fifo, buf, len, &dlci->lock);
        /* Need to kick the channel */
        gsm_dlci_data_kick(dlci);
        return sent;
        struct gsm_dlci *dlci = tty->driver_data;
        if (dlci->state == DLCI_CLOSED)
                return -EINVAL;
-       return TX_SIZE - kfifo_len(dlci->fifo);
+       return TX_SIZE - kfifo_len(&dlci->fifo);
 }
 
 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
        struct gsm_dlci *dlci = tty->driver_data;
        if (dlci->state == DLCI_CLOSED)
                return -EINVAL;
-       return kfifo_len(dlci->fifo);
+       return kfifo_len(&dlci->fifo);
 }
 
 static void gsmtty_flush_buffer(struct tty_struct *tty)
           then the data being transmitted can't simply be junked once
           it has first hit the stack. Until then we can just blow it
           away */
-       kfifo_reset(dlci->fifo);
+       kfifo_reset(&dlci->fifo);
        /* Need to unhook this DLCI from the transmit queue logic */
 }