* that will sleep. See i2400m_net_wake_tx() for details.
  */
 static
-int i2400m_hard_start_xmit(struct sk_buff *skb,
-                          struct net_device *net_dev)
+netdev_tx_t i2400m_hard_start_xmit(struct sk_buff *skb,
+                                        struct net_device *net_dev)
 {
-       int result;
        struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
        struct device *dev = i2400m_dev(i2400m);
+       int result;
 
        d_fnstart(3, dev, "(skb %p net_dev %p)\n", skb, net_dev);
        if (i2400m->state == I2400M_SS_IDLE)
                net_dev->stats.tx_bytes += skb->len;
        }
        kfree_skb(skb);
-       result = NETDEV_TX_OK;
-       d_fnend(3, dev, "(skb %p net_dev %p) = %d\n", skb, net_dev, result);
-       return result;
+
+       d_fnend(3, dev, "(skb %p net_dev %p)\n", skb, net_dev);
+       return NETDEV_TX_OK;
 }
 
 
 
        return 0;
 }
 
-static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
+static netdev_tx_t mpi_start_xmit(struct sk_buff *skb,
+                                       struct net_device *dev)
+{
        int npacks, pending;
        unsigned long flags;
        struct airo_info *ai = dev->ml_priv;
        dev_kfree_skb(skb);
 }
 
-static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
+static netdev_tx_t airo_start_xmit(struct sk_buff *skb,
+                                        struct net_device *dev)
+{
        s16 len;
        int i, j;
        struct airo_info *priv = dev->ml_priv;
        dev_kfree_skb(skb);
 }
 
-static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
+static netdev_tx_t airo_start_xmit11(struct sk_buff *skb,
+                                          struct net_device *dev)
+{
        s16 len;
        int i, j;
        struct airo_info *priv = dev->ml_priv;
 
 static int arlans_found;
 
 static  int    arlan_open(struct net_device *dev);
-static  int    arlan_tx(struct sk_buff *skb, struct net_device *dev);
+static  netdev_tx_t arlan_tx(struct sk_buff *skb, struct net_device *dev);
 static  irqreturn_t arlan_interrupt(int irq, void *dev_id);
 static  int    arlan_close(struct net_device *dev);
 static  struct net_device_stats *
 }
 
 
-static int arlan_tx(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t arlan_tx(struct sk_buff *skb, struct net_device *dev)
 {
        short length;
        unsigned char *buf;
 
        priv->tx_free_mem -= len;
 }
 
-static int start_tx(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev)
 {
        static const u8 SNAP_RFC1024[6] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
        struct atmel_private *priv = netdev_priv(dev);
 
 
 #include <linux/types.h>
 #include <linux/skbuff.h>
+#include <linux/netdevice.h>
 
 struct hostap_ieee80211_mgmt {
        __le16 frame_control;
                          struct hostap_80211_rx_status *rx_stats);
 
 void hostap_dump_tx_80211(const char *name, struct sk_buff *skb);
-int hostap_data_start_xmit(struct sk_buff *skb, struct net_device *dev);
-int hostap_mgmt_start_xmit(struct sk_buff *skb, struct net_device *dev);
-int hostap_master_start_xmit(struct sk_buff *skb, struct net_device *dev);
+netdev_tx_t hostap_data_start_xmit(struct sk_buff *skb,
+                                  struct net_device *dev);
+netdev_tx_t hostap_mgmt_start_xmit(struct sk_buff *skb,
+                                  struct net_device *dev);
+netdev_tx_t hostap_master_start_xmit(struct sk_buff *skb,
+                                    struct net_device *dev);
 
 #endif /* HOSTAP_80211_H */
 
 /* hard_start_xmit function for data interfaces (wlan#, wlan#wds#, wlan#sta)
  * Convert Ethernet header into a suitable IEEE 802.11 header depending on
  * device configuration. */
-int hostap_data_start_xmit(struct sk_buff *skb, struct net_device *dev)
+netdev_tx_t hostap_data_start_xmit(struct sk_buff *skb,
+                                  struct net_device *dev)
 {
        struct hostap_interface *iface;
        local_info_t *local;
 
 
 /* hard_start_xmit function for hostapd wlan#ap interfaces */
-int hostap_mgmt_start_xmit(struct sk_buff *skb, struct net_device *dev)
+netdev_tx_t hostap_mgmt_start_xmit(struct sk_buff *skb,
+                                  struct net_device *dev)
 {
        struct hostap_interface *iface;
        local_info_t *local;
 /* hard_start_xmit function for master radio interface wifi#.
  * AP processing (TX rate control, power save buffering, etc.).
  * Use hardware TX function to send the frame. */
-int hostap_master_start_xmit(struct sk_buff *skb, struct net_device *dev)
+netdev_tx_t hostap_master_start_xmit(struct sk_buff *skb,
+                                    struct net_device *dev)
 {
        struct hostap_interface *iface;
        local_info_t *local;
-       int ret = NETDEV_TX_BUSY;
+       netdev_tx_t ret = NETDEV_TX_BUSY;
        u16 fc;
        struct hostap_tx_data tx;
        ap_tx_ret tx_ret;
 
        return IRQ_NONE;
 }
 
-static int ipw2100_tx(struct libipw_txb *txb, struct net_device *dev,
-                     int pri)
+static netdev_tx_t ipw2100_tx(struct libipw_txb *txb,
+                             struct net_device *dev, int pri)
 {
        struct ipw2100_priv *priv = libipw_priv(dev);
        struct list_head *element;
        ipw2100_tx_send_data(priv);
 
        spin_unlock_irqrestore(&priv->low_lock, flags);
-       return 0;
+       return NETDEV_TX_OK;
 
-      fail_unlock:
+fail_unlock:
        netif_stop_queue(dev);
        spin_unlock_irqrestore(&priv->low_lock, flags);
-       return 1;
+       return NETDEV_TX_BUSY;
 }
 
 static int ipw2100_msg_allocate(struct ipw2100_priv *priv)
 
 }
 #endif
 
-static int ipw_net_hard_start_xmit(struct libipw_txb *txb,
-                                  struct net_device *dev, int pri)
+static netdev_tx_t ipw_net_hard_start_xmit(struct libipw_txb *txb,
+                                          struct net_device *dev, int pri)
 {
        struct ipw_priv *priv = libipw_priv(dev);
        unsigned long flags;
-       int ret;
+       netdev_tx_t ret;
 
        IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
        spin_lock_irqsave(&priv->lock, flags);
        return 0;
 }
 
-static int ipw_prom_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t ipw_prom_hard_start_xmit(struct sk_buff *skb,
+                                           struct net_device *dev)
 {
        IPW_DEBUG_INFO("prom dev->xmit\n");
        dev_kfree_skb(skb);
 
        /* Callback functions */
        void (*set_security) (struct net_device * dev,
                              struct libipw_security * sec);
-       int (*hard_start_xmit) (struct libipw_txb * txb,
-                               struct net_device * dev, int pri);
+       netdev_tx_t (*hard_start_xmit) (struct libipw_txb * txb,
+                                       struct net_device * dev, int pri);
        int (*reset_port) (struct net_device * dev);
        int (*is_queue_full) (struct net_device * dev, int pri);
 
 extern int libipw_set_encryption(struct libipw_device *ieee);
 
 /* libipw_tx.c */
-extern int libipw_xmit(struct sk_buff *skb, struct net_device *dev);
+extern netdev_tx_t libipw_xmit(struct sk_buff *skb,
+                              struct net_device *dev);
 extern void libipw_txb_free(struct libipw_txb *);
 
 /* libipw_rx.c */
 
 
 /* Incoming skb is converted to a txb which consists of
  * a block of 802.11 fragment packets (stored as skbs) */
-int libipw_xmit(struct sk_buff *skb, struct net_device *dev)
+netdev_tx_t libipw_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct libipw_device *ieee = netdev_priv(dev);
        struct libipw_txb *txb = NULL;
        dev_kfree_skb_any(skb);
 
        if (txb) {
-               int ret = (*ieee->hard_start_xmit) (txb, dev, priority);
-               if (ret == 0) {
+               netdev_tx_t ret = (*ieee->hard_start_xmit)(txb, dev, priority);
+               if (ret == NETDEV_TX_OK) {
                        dev->stats.tx_packets++;
                        dev->stats.tx_bytes += txb->payload_size;
                        return NETDEV_TX_OK;
 
 #ifndef _LBS_DECL_H_
 #define _LBS_DECL_H_
 
-#include <linux/device.h>
+#include <linux/netdevice.h>
 
 #include "defs.h"
 
 int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len);
 void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
                          int result);
-int lbs_hard_start_xmit(struct sk_buff *skb, struct net_device *dev);
+netdev_tx_t lbs_hard_start_xmit(struct sk_buff *skb,
+                               struct net_device *dev);
 int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band);
 
 int lbs_process_rxed_packet(struct lbs_private *priv, struct sk_buff *);
 
        return 0;
 }
 
-static int lbs_rtap_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t lbs_rtap_hard_start_xmit(struct sk_buff *skb,
+                                           struct net_device *dev)
 {
        netif_stop_queue(dev);
        return NETDEV_TX_BUSY;
 
  *  @param skb     A pointer to skb which includes TX packet
  *  @return       0 or -1
  */
-int lbs_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
+netdev_tx_t lbs_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        unsigned long flags;
        struct lbs_private *priv = dev->ml_priv;
        struct txpd *txpd;
        char *p802x_hdr;
        uint16_t pkt_len;
-       int ret;
+       netdev_tx_t ret = NETDEV_TX_OK;
 
        lbs_deb_enter(LBS_DEB_TX);
 
-       ret = NETDEV_TX_OK;
-
        /* We need to protect against the queues being restarted before
           we get round to stopping them */
        spin_lock_irqsave(&priv->driver_lock, flags);
 
 } __attribute__ ((packed));
 
 
-static int hwsim_mon_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
+                                       struct net_device *dev)
 {
        /* TODO: allow packet injection */
        dev_kfree_skb(skb);
 
 static int netwave_close(struct net_device *dev); /* Close the device */
 
 /* Packet transmission and Packet reception */
-static int netwave_start_xmit( struct sk_buff *skb, struct net_device *dev);
+static netdev_tx_t netwave_start_xmit( struct sk_buff *skb,
+                                            struct net_device *dev);
 static int netwave_rx( struct net_device *dev);
 
 /* Interrupt routines */
     return 0;
 }
 
-static int netwave_start_xmit(struct sk_buff *skb, struct net_device *dev) {
+static netdev_tx_t netwave_start_xmit(struct sk_buff *skb,
+                                           struct net_device *dev) {
        /* This flag indicate that the hardware can't perform a transmission.
         * Theoritically, NET3 check it before sending a packet to the driver,
         * but in fact it never do that and pool continuously.
 
 /* Tx path                                                          */
 /********************************************************************/
 
-static int orinoco_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t orinoco_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct orinoco_private *priv = ndev_priv(dev);
        struct net_device_stats *stats = &priv->stats;
 
        }
 }
 
-int
+netdev_tx_t
 islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev)
 {
        islpci_private *priv = netdev_priv(ndev);
 
 };
 
 void islpci_eth_cleanup_transmit(islpci_private *, isl38xx_control_block *);
-int islpci_eth_transmit(struct sk_buff *, struct net_device *);
+netdev_tx_t islpci_eth_transmit(struct sk_buff *, struct net_device *);
 int islpci_eth_receive(islpci_private *);
 void islpci_eth_tx_timeout(struct net_device *);
 void islpci_do_reset_and_wake(struct work_struct *);
 
 static const struct ethtool_ops netdev_ethtool_ops;
 
 static int ray_open(struct net_device *dev);
-static int ray_dev_start_xmit(struct sk_buff *skb, struct net_device *dev);
+static netdev_tx_t ray_dev_start_xmit(struct sk_buff *skb,
+                                           struct net_device *dev);
 static void set_multicast_list(struct net_device *dev);
 static void ray_update_multi_list(struct net_device *dev, int all);
 static int translate_frame(ray_dev_t *local, struct tx_msg __iomem *ptx,
 }
 
 /*===========================================================================*/
-static int ray_dev_start_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t ray_dev_start_xmit(struct sk_buff *skb,
+                                           struct net_device *dev)
 {
        ray_dev_t *local = netdev_priv(dev);
        struct pcmcia_device *link = local->finder;
        short length = skb->len;
 
-       if (!(pcmcia_dev_present(link))) {
+       if (!pcmcia_dev_present(link)) {
                DEBUG(2, "ray_dev_start_xmit - device not present\n");
-               return NETDEV_TX_LOCKED;
+               dev_kfree_skb(skb);
+               return NETDEV_TX_OK;
        }
+
        DEBUG(3, "ray_dev_start_xmit(skb=%p, dev=%p)\n", skb, dev);
        if (local->authentication_state == NEED_TO_AUTH) {
                DEBUG(0, "ray_cs Sending authentication request.\n");
        default:
                dev->trans_start = jiffies;
                dev_kfree_skb(skb);
-               return NETDEV_TX_OK;
        }
+
        return NETDEV_TX_OK;
 } /* ray_dev_start_xmit */
 
 
 }
 
 /* Encapsulate a datagram and kick it into a TTY queue. */
-static int strip_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t strip_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct strip *strip_info = netdev_priv(dev);
 
 
  * the packet.  We also prevent reentrance.  Then we call the function
  * to send the packet.
  */
-static int wavelan_packet_xmit(struct sk_buff *skb, struct net_device * dev)
+static netdev_tx_t wavelan_packet_xmit(struct sk_buff *skb,
+                                            struct net_device * dev)
 {
        net_local *lp = netdev_priv(dev);
        unsigned long flags;
 
        wv_packet_write(struct net_device *,    /* Write a packet to the Tx buffer. */
                        void *,
                        short);
-static int
+static netdev_tx_t
        wavelan_packet_xmit(struct sk_buff *,   /* Send a packet. */
                            struct net_device *);
 /* -------------------- HARDWARE CONFIGURATION -------------------- */
 
  * the packet. We also prevent reentrance. Then, we call the function
  * to send the packet...
  */
-static int
+static netdev_tx_t
 wavelan_packet_xmit(struct sk_buff *   skb,
                    struct net_device *         dev)
 {
 
        wv_packet_write(struct net_device *,    /* Write a packet to the Tx buffer */
                        void *,
                        short);
-static int
+static netdev_tx_t
        wavelan_packet_xmit(struct sk_buff *,   /* Send a packet */
                            struct net_device *);
 /* -------------------- HARDWARE CONFIGURATION -------------------- */
 
  *         1 - Could not transmit (dev_queue_xmit will queue it)
  *             and try to sent it later
  */
-static int wl3501_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t wl3501_hard_start_xmit(struct sk_buff *skb,
+                                               struct net_device *dev)
 {
        int enabled, rc;
        struct wl3501_card *this = netdev_priv(dev);
 
                                (llc+snap+type+payload)
                zd              1 null byte, zd1201 packet type
  */
-static int zd1201_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t zd1201_hard_start_xmit(struct sk_buff *skb,
+                                               struct net_device *dev)
 {
        struct zd1201 *zd = netdev_priv(dev);
        unsigned char *txbuf = zd->txdata;
 
 /* tx handling */
 void ieee80211_clear_tx_pending(struct ieee80211_local *local);
 void ieee80211_tx_pending(unsigned long data);
-int ieee80211_monitor_start_xmit(struct sk_buff *skb, struct net_device *dev);
-int ieee80211_subif_start_xmit(struct sk_buff *skb, struct net_device *dev);
+netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb,
+                                        struct net_device *dev);
+netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
+                                      struct net_device *dev);
 
 /* HT */
 void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_supported_band *sband,
 
        dev_put(sdata->dev);
 }
 
-int ieee80211_monitor_start_xmit(struct sk_buff *skb,
-                                struct net_device *dev)
+netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb,
+                                        struct net_device *dev)
 {
        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
        struct ieee80211_channel *chan = local->hw.conf.channel;
  * encapsulated packet will then be passed to master interface, wlan#.11, for
  * transmission (through low-level driver).
  */
-int ieee80211_subif_start_xmit(struct sk_buff *skb,
-                              struct net_device *dev)
+netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
+                                   struct net_device *dev)
 {
        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
        struct ieee80211_local *local = sdata->local;