}
        napi_enable(&bgmac->napi);
  
 -      phy_start(bgmac->phy_dev);
 +      phy_start(net_dev->phydev);
  
-       netif_carrier_on(net_dev);
+       netif_start_queue(net_dev);
+ 
        return 0;
  }
  
 
  #include <linux/slab.h>
  #include <linux/of.h>
  #include <linux/gpio.h>
 +#include <linux/seqlock.h>
+ #include <linux/idr.h>
  
 -#define MII_REGS_NUM 29
 +#include "swphy.h"
  
  struct fixed_mdio_bus {
        struct mii_bus *mii_bus;
 
        ocp_data &= ~RCR_ACPT_ALL;
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
  
 -      r8153_hw_phy_cfg(tp);
 -
        rtl8152_nic_reset(tp);
+       rtl_reset_bmu(tp);
  
        ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
        ocp_data &= ~NOW_IS_OOB;
 
  
        rdsdebug("sock %p state_change to %d\n", tc->t_sock, sk->sk_state);
  
-       switch(sk->sk_state) {
-               /* ignore connecting sockets as they make progress */
-               case TCP_SYN_SENT:
-               case TCP_SYN_RECV:
-                       break;
-               case TCP_ESTABLISHED:
-                       rds_connect_path_complete(&conn->c_path[0],
-                                                 RDS_CONN_CONNECTING);
-                       break;
-               case TCP_CLOSE_WAIT:
-               case TCP_CLOSE:
-                       rds_conn_drop(conn);
-               default:
-                       break;
+       switch (sk->sk_state) {
+       /* ignore connecting sockets as they make progress */
+       case TCP_SYN_SENT:
+       case TCP_SYN_RECV:
+               break;
+       case TCP_ESTABLISHED:
 -              rds_connect_path_complete(conn, RDS_CONN_CONNECTING);
++              rds_connect_path_complete(&conn->c_path[0],
++                                        RDS_CONN_CONNECTING);
+               break;
+       case TCP_CLOSE_WAIT:
+       case TCP_CLOSE:
+               rds_conn_drop(conn);
+       default:
+               break;
        }
  out:
        read_unlock_bh(&sk->sk_callback_lock);
 
                        goto rst_nsk;
                } else {
                        rds_tcp_reset_callbacks(new_sock, conn);
 -                      conn->c_outgoing = 0;
 +                      conn->c_path[0].cp_outgoing = 0;
                        /* rds_connect_path_complete() marks RDS_CONN_UP */
 -                      rds_connect_path_complete(conn, RDS_CONN_RESETTING);
 +                      rds_connect_path_complete(&conn->c_path[0],
-                                                 RDS_CONN_DISCONNECTING);
++                                                RDS_CONN_RESETTING);
                }
        } else {
                rds_tcp_set_callbacks(new_sock, conn);
 
        if (likely(skb_queue_len(&sch->q) < sch->limit))
                return qdisc_enqueue_tail(skb, sch);
  
 -      return qdisc_reshape_fail(skb, sch);
 +      return qdisc_drop(skb, sch, to_free);
  }
  
 -static int pfifo_tail_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 +static int pfifo_tail_enqueue(struct sk_buff *skb, struct Qdisc *sch,
 +                            struct sk_buff **to_free)
  {
+       unsigned int prev_backlog;
+ 
        if (likely(skb_queue_len(&sch->q) < sch->limit))
                return qdisc_enqueue_tail(skb, sch);
  
+       prev_backlog = sch->qstats.backlog;
        /* queue full, remove one skb to fulfill the limit */
 -      __qdisc_queue_drop_head(sch, &sch->q);
 +      __qdisc_queue_drop_head(sch, &sch->q, to_free);
        qdisc_qstats_drop(sch);
        qdisc_enqueue_tail(skb, sch);
  
 
  #endif
  
                        if (q->qdisc) {
 -                              int err = qdisc_enqueue(skb, q->qdisc);
+                               unsigned int pkt_len = qdisc_pkt_len(skb);
 +                              struct sk_buff *to_free = NULL;
 +                              int err;
  
-                               if (unlikely(err != NET_XMIT_SUCCESS)) {
-                                       if (net_xmit_drop_count(err)) {
-                                               qdisc_qstats_drop(sch);
-                                               qdisc_tree_reduce_backlog(sch, 1,
-                                                                         qdisc_pkt_len(skb));
-                                       }
 +                              err = qdisc_enqueue(skb, q->qdisc, &to_free);
 +                              kfree_skb_list(to_free);
+                               if (err != NET_XMIT_SUCCESS &&
+                                   net_xmit_drop_count(err)) {
+                                       qdisc_qstats_drop(sch);
+                                       qdisc_tree_reduce_backlog(sch, 1,
+                                                                 pkt_len);
                                }
                                goto tfifo_dequeue;
                        }
 
  all:
  
- all: ring virtio_ring_0_9 virtio_ring_poll virtio_ring_inorder ptr_ring
 -all: ring virtio_ring_0_9 virtio_ring_poll virtio_ring_inorder noring
++all: ring virtio_ring_0_9 virtio_ring_poll virtio_ring_inorder ptr_ring noring
  
  CFLAGS += -Wall
  CFLAGS += -pthread -O2 -ggdb
  virtio_ring_0_9: virtio_ring_0_9.o main.o
  virtio_ring_poll: virtio_ring_poll.o main.o
  virtio_ring_inorder: virtio_ring_inorder.o main.o
 +ptr_ring: ptr_ring.o main.o
+ noring: noring.o main.o
  clean:
        -rm main.o
        -rm ring.o ring
        -rm virtio_ring_0_9.o virtio_ring_0_9
        -rm virtio_ring_poll.o virtio_ring_poll
        -rm virtio_ring_inorder.o virtio_ring_inorder
 +      -rm ptr_ring.o ptr_ring
+       -rm noring.o noring
  
  .PHONY: all clean