tree 9114df4de0176b065b54aa63cb5860c716227dea
parent b0ba0b9b6b402d738f11f27eea6c94d97bf84cbf
author Fam Zheng <famz@redhat.com> 1436955544 +0800
committer Stefan Hajnoczi <stefanha@redhat.com> 1438002738 +0100

eepro100: Drop nic_can_receive

nic_receive already checks the conditions and drop packets if false.
Due to the new semantics since 6e99c63 ("net/socket: Drop
net_socket_can_send"), having .can_receive returning 0 requires us to
explicitly flush the queued packets when the conditions are becoming
true, but queuing the packets when guest driver is not ready doesn't
make much sense.

Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Jason Wang <jasowang@redhat.com>
Message-id: 1436955553-22791-4-git-send-email-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
