static int lbs_get_freq(struct net_device *dev, struct iw_request_info *info,
                         struct iw_freq *fwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct chan_freq_power *cfp;
 
        lbs_deb_enter(LBS_DEB_WEXT);
 static int lbs_get_wap(struct net_device *dev, struct iw_request_info *info,
                        struct sockaddr *awrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
 static int lbs_set_nick(struct net_device *dev, struct iw_request_info *info,
                         struct iw_point *dwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
 static int lbs_get_nick(struct net_device *dev, struct iw_request_info *info,
                         struct iw_point *dwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
 static int mesh_get_nick(struct net_device *dev, struct iw_request_info *info,
                         struct iw_point *dwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
                        struct iw_param *vwrq, char *extra)
 {
        int ret = 0;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        u32 val = vwrq->value;
 
        lbs_deb_enter(LBS_DEB_WEXT);
 static int lbs_get_rts(struct net_device *dev, struct iw_request_info *info,
                        struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        int ret = 0;
        u16 val = 0;
 
 static int lbs_set_frag(struct net_device *dev, struct iw_request_info *info,
                         struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        int ret = 0;
        u32 val = vwrq->value;
 
 static int lbs_get_frag(struct net_device *dev, struct iw_request_info *info,
                         struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        int ret = 0;
        u16 val = 0;
 
 static int lbs_get_mode(struct net_device *dev,
                         struct iw_request_info *info, u32 * uwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
                          struct iw_request_info *info,
                          struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        s16 curlevel = 0;
        int ret = 0;
 
 static int lbs_set_retry(struct net_device *dev, struct iw_request_info *info,
                          struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        int ret = 0;
        u16 slimit = 0, llimit = 0;
 
 static int lbs_get_retry(struct net_device *dev, struct iw_request_info *info,
                          struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        int ret = 0;
        u16 val = 0;
 
                          struct iw_point *dwrq, char *extra)
 {
        int i, j;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct iw_range *range = (struct iw_range *)extra;
        struct chan_freq_power *cfp;
        u8 rates[MAX_RATES + 1];
 static int lbs_set_power(struct net_device *dev, struct iw_request_info *info,
                          struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
 static int lbs_get_power(struct net_device *dev, struct iw_request_info *info,
                          struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
                EXCELLENT = 95,
                PERFECT = 100
        };
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        u32 rssi_qual;
        u32 tx_qual;
        u32 quality = 0;
                  struct iw_freq *fwrq, char *extra)
 {
        int ret = -EINVAL;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct chan_freq_power *cfp;
        struct assoc_request * assoc_req;
 
                             struct iw_request_info *info,
                             struct iw_freq *fwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct chan_freq_power *cfp;
        int ret = -EINVAL;
 
 static int lbs_set_rate(struct net_device *dev, struct iw_request_info *info,
                  struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        u8 new_rate = 0;
        int ret = -EINVAL;
        u8 rates[MAX_RATES + 1];
 static int lbs_get_rate(struct net_device *dev, struct iw_request_info *info,
                  struct iw_param *vwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
                  struct iw_request_info *info, u32 * uwrq, char *extra)
 {
        int ret = 0;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct assoc_request * assoc_req;
 
        lbs_deb_enter(LBS_DEB_WEXT);
                           struct iw_request_info *info,
                           struct iw_point *dwrq, u8 * extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
 
        lbs_deb_enter(LBS_DEB_WEXT);
                    struct iw_point *dwrq, char *extra)
 {
        int ret = 0;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct assoc_request * assoc_req;
        u16 is_default = 0, index = 0, set_tx_key = 0;
 
                              char *extra)
 {
        int ret = -EINVAL;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
        int index, max_key_len;
 
                              char *extra)
 {
        int ret = 0;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
        int alg = ext->alg;
        struct assoc_request * assoc_req;
                          struct iw_point *dwrq,
                          char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        int ret = 0;
        struct assoc_request * assoc_req;
 
                          char *extra)
 {
        int ret = 0;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
                         struct iw_param *dwrq,
                         char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct assoc_request * assoc_req;
        int ret = 0;
        int updated = 0;
                         char *extra)
 {
        int ret = 0;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
                   struct iw_param *vwrq, char *extra)
 {
        int ret = 0;
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        s16 dbm = (s16) vwrq->value;
 
        lbs_deb_enter(LBS_DEB_WEXT);
 static int lbs_get_essid(struct net_device *dev, struct iw_request_info *info,
                   struct iw_point *dwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
 static int lbs_set_essid(struct net_device *dev, struct iw_request_info *info,
                   struct iw_point *dwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        int ret = 0;
        u8 ssid[IW_ESSID_MAX_SIZE];
        u8 ssid_len = 0;
                              struct iw_request_info *info,
                              struct iw_point *dwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
                              struct iw_request_info *info,
                              struct iw_point *dwrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        int ret = 0;
 
        lbs_deb_enter(LBS_DEB_WEXT);
 static int lbs_set_wap(struct net_device *dev, struct iw_request_info *info,
                 struct sockaddr *awrq, char *extra)
 {
-       struct lbs_private *priv = dev->priv;
+       struct lbs_private *priv = netdev_priv(dev);
        struct assoc_request * assoc_req;
        int ret = 0;
 
 
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
        struct iw_range *range = (struct iw_range *)extra;
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
        int len, ret, i, j, num, has_80211g_rates;
        u8 rates[8];
 static int rndis_iw_get_name(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
 
        strcpy(wrqu->name, priv->name);
 {
        struct ndis_80211_ssid ssid;
        int length = wrqu->essid.length;
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
 
        devdbg(usbdev, "SIOCSIWESSID: [flags:%d,len:%d] '%.32s'",
                wrqu->essid.flags, wrqu->essid.length, essid);
     struct iw_request_info *info, union iwreq_data *wrqu, char *essid)
 {
        struct ndis_80211_ssid ssid;
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        int ret;
 
        ret = get_essid(usbdev, &ssid);
 static int rndis_iw_get_bssid(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        unsigned char bssid[ETH_ALEN];
        int ret;
 
 static int rndis_iw_set_bssid(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        u8 *bssid = (u8 *)wrqu->ap_addr.sa_data;
        int ret;
 
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
        struct iw_param *p = &wrqu->param;
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
        int ret = -ENOTSUPP;
 
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
        struct iw_param *p = &wrqu->param;
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
 
        switch (p->flags & IW_AUTH_INDEX) {
                                struct iw_request_info *info,
                                union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
 
        switch (priv->infra_mode) {
 static int rndis_iw_set_mode(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        int mode;
 
        devdbg(usbdev, "SIOCSIWMODE: %08x", wrqu->mode);
 static int rndis_iw_set_encode(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
        int ret, index, key_len;
        u8 *key;
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
        struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
        struct ndis_80211_key ndis_key;
        int keyidx, ret;
 static int rndis_iw_set_scan(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        union iwreq_data evt;
        int ret = -EINVAL;
        __le32 tmp;
                                  struct ndis_80211_bssid_ex *bssid)
 {
 #ifdef DEBUG
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
 #endif
        u8 *ie;
        char *current_val;
 static int rndis_iw_get_scan(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        void *buf = NULL;
        char *cev = extra;
        struct ndis_80211_bssid_list_ex *bssid_list;
 static int rndis_iw_set_genie(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
        int ret = 0;
 
 static int rndis_iw_get_genie(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
 
        devdbg(usbdev, "SIOCGIWGENIE");
 static int rndis_iw_set_rts(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        __le32 tmp;
        devdbg(usbdev, "SIOCSIWRTS");
 
 static int rndis_iw_get_rts(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        __le32 tmp;
        int len, ret;
 
 static int rndis_iw_set_frag(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        __le32 tmp;
 
        devdbg(usbdev, "SIOCSIWFRAG");
 static int rndis_iw_get_frag(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        __le32 tmp;
        int len, ret;
 
 static int rndis_iw_set_nick(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
 
        devdbg(usbdev, "SIOCSIWNICK");
 static int rndis_iw_get_nick(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
 
        wrqu->data.flags = 1;
 static int rndis_iw_set_freq(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct ndis_80211_conf config;
        unsigned int dsconfig;
        int len, ret;
 static int rndis_iw_get_freq(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct ndis_80211_conf config;
        int len, ret;
 
 static int rndis_iw_get_txpower(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
        __le32 tx_power;
        int ret = 0, len;
 static int rndis_iw_set_txpower(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
        __le32 tx_power = 0;
        int ret = 0;
 static int rndis_iw_get_rate(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        __le32 tmp;
        int ret, len;
 
 static int rndis_iw_set_mlme(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
        struct iw_mlme *mlme = (struct iw_mlme *)extra;
        unsigned char bssid[ETH_ALEN];
 
 static struct iw_statistics *rndis_get_wireless_stats(struct net_device *dev)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
        unsigned long flags;
 
 
 static void rndis_wext_set_multicast_list(struct net_device *dev)
 {
-       struct usbnet *usbdev = dev->priv;
+       struct usbnet *usbdev = netdev_priv(dev);
        struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
 
        if (test_bit(WORK_SET_MULTICAST_LIST, &priv->work_pending))
 
  */
 static inline void wv_ints_off(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        
        lp->hacr &= ~HACR_INTRON;
  */
 static inline void wv_ints_on(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
 
        lp->hacr |= HACR_INTRON;
  */
 static void wv_ack(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        u16 scb_cs;
        int i;
  */
 static int wv_synchronous_cmd(struct net_device * dev, const char *str)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        u16 scb_cmd;
        ach_t cb;
  */
 static void wv_82586_reconfig(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long flags;
 
        /* Arm the flag, will be cleard in wv_82586_config() */
 static void wv_mmc_show(struct net_device * dev)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        mmr_t m;
 
        /* Basic check */
  */
 static void wv_ru_show(struct net_device * dev)
 {
-       /* net_local *lp = (net_local *) dev->priv; */
-
        printk(KERN_DEBUG
               "##### WaveLAN i82586 receiver unit status: #####\n");
        printk(KERN_DEBUG "ru:");
  */
 static void wv_cu_show(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned int i;
        u16 p;
 
 {
        net_local *lp;
 
-       lp = (net_local *) dev->priv;
+       lp = netdev_priv(dev);
 
        printk(KERN_DEBUG "local:");
        printk(" tx_n_in_use=%d,", lp->tx_n_in_use);
 static void wv_init_info(struct net_device * dev)
 {
        short ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        psa_t psa;
 
        /* Read the parameter storage area */
        printk(KERN_DEBUG "%s: <>wavelan_get_stats()\n", dev->name);
 #endif
 
-       return (&((net_local *) dev->priv)->stats);
+       return &((net_local *)netdev_priv(dev))->stats;
 }
 
 /*------------------------------------------------------------------*/
  */
 static void wavelan_set_multicast_list(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
 
 #ifdef DEBUG_IOCTL_TRACE
        printk(KERN_DEBUG "%s: ->wavelan_set_multicast_list()\n",
  */
 static inline void wl_his_gather(struct net_device * dev, u8 * stats)
 {                              /* Statistics to gather */
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        u8 level = stats[0] & MMR_SIGNAL_LVL;
        int i;
 
                            char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        psa_t psa;
        mm_t m;
        unsigned long flags;
                            char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        psa_t psa;
        unsigned long flags;
        int ret = 0;
                            char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        unsigned long flags;
        int ret;
 
                            char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        psa_t psa;
        unsigned long flags;
        int ret = 0;
                            char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        psa_t psa;
        unsigned long flags;
        int ret = 0;
                            char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        psa_t psa;
        unsigned long flags;
        int ret = 0;
                              char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        unsigned long flags;
        psa_t psa;
        int ret = 0;
                              char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        psa_t psa;
        unsigned long flags;
        int ret = 0;
                             char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        struct iw_range *range = (struct iw_range *) extra;
        unsigned long flags;
        int ret = 0;
                            char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        psa_t psa;
        unsigned long flags;
 
                            char *extra)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
        psa_t psa;
        unsigned long flags;
 
                             union iwreq_data *wrqu,
                             char *extra)
 {
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
 
        /* Check the number of intervals. */
        if (wrqu->data.length > 16) {
                             union iwreq_data *wrqu,
                             char *extra)
 {
-       net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
+       net_local *lp = netdev_priv(dev);       /* lp is not unused */
 
        /* Set the number of intervals. */
        wrqu->data.length = lp->his_number;
 static iw_stats *wavelan_get_wireless_stats(struct net_device * dev)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        mmr_t m;
        iw_stats *wstats;
        unsigned long flags;
 static void
 wv_packet_read(struct net_device * dev, u16 buf_off, int sksize)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        struct sk_buff *skb;
 
 static void wv_receive(struct net_device * dev)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        fd_t fd;
        rbd_t rbd;
        int nreaped = 0;
  */
 static int wv_packet_write(struct net_device * dev, void *buf, short length)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        unsigned short txblock;
        unsigned short txpred;
  */
 static int wavelan_packet_xmit(struct sk_buff *skb, struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long flags;
        char data[ETH_ZLEN];
 
 static int wv_mmc_init(struct net_device * dev)
 {
        unsigned long ioaddr = dev->base_addr;
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        psa_t psa;
        mmw_t m;
        int configured;
  */
 static int wv_ru_start(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        u16 scb_cs;
        fd_t fd;
  */
 static int wv_cu_start(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        int i;
        u16 txblock;
  */
 static int wv_82586_start(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        scp_t scp;              /* system configuration pointer */
        iscp_t iscp;            /* intermediate scp */
  */
 static void wv_82586_config(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        unsigned short txblock;
        unsigned short txpred;
  */
 static void wv_82586_stop(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        u16 scb_cmd;
 
  */
 static int wv_hw_reset(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
 
 #ifdef DEBUG_CONFIG_TRACE
        printk(KERN_DEBUG "%s: ->wavelan_interrupt()\n", dev->name);
 #endif
 
-       lp = (net_local *) dev->priv;
+       lp = netdev_priv(dev);
        ioaddr = dev->base_addr;
 
 #ifdef DEBUG_INTERRUPT_INFO
  */
 static void wavelan_watchdog(struct net_device *       dev)
 {
-       net_local *     lp = (net_local *)dev->priv;
+       net_local *lp = netdev_priv(dev);
        u_long          ioaddr = dev->base_addr;
        unsigned long   flags;
        unsigned int    nreaped;
  */
 static int wavelan_open(struct net_device * dev)
 {
-       net_local *     lp = (net_local *)dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long   flags;
 
 #ifdef DEBUG_CALLBACK_TRACE
  */
 static int wavelan_close(struct net_device * dev)
 {
-       net_local *lp = (net_local *) dev->priv;
+       net_local *lp = netdev_priv(dev);
        unsigned long flags;
 
 #ifdef DEBUG_CALLBACK_TRACE
        dev->if_port = 0;
 
        /* Initialize device structures */
-       memset(dev->priv, 0, sizeof(net_local));
-       lp = (net_local *) dev->priv;
+       memset(netdev_priv(dev), 0, sizeof(net_local));
+       lp = netdev_priv(dev);
 
        /* Back link to the device structure. */
        lp->dev = dev;
 
 /* Request needed resources */
 static int znet_request_resources (struct net_device *dev)
 {
-       struct znet_private *znet = dev->priv;
+       struct znet_private *znet = netdev_priv(dev);
        unsigned long flags;
 
        if (request_irq (dev->irq, &znet_interrupt, 0, "ZNet", dev))
 
 static void znet_release_resources (struct net_device *dev)
 {
-       struct znet_private *znet = dev->priv;
+       struct znet_private *znet = netdev_priv(dev);
        unsigned long flags;
 
        release_region (znet->sia_base, znet->sia_size);
 /* Keep the magical SIA stuff in a single function... */
 static void znet_transceiver_power (struct net_device *dev, int on)
 {
-       struct znet_private *znet = dev->priv;
+       struct znet_private *znet = netdev_priv(dev);
        unsigned char v;
 
        /* Turn on/off the 82501 SIA, using zenith-specific magic. */
    Also used from hardware_init. */
 static void znet_set_multicast_list (struct net_device *dev)
 {
-       struct znet_private *znet = dev->priv;
+       struct znet_private *znet = netdev_priv(dev);
        short ioaddr = dev->base_addr;
        struct i82593_conf_block *cfblk = &znet->i593_init;
 
        if (!dev)
                return -ENOMEM;
 
-       znet = dev->priv;
+       znet = netdev_priv(dev);
 
        netinfo = (struct netidblk *)p;
        dev->base_addr = netinfo->iobase1;
 static int znet_send_packet(struct sk_buff *skb, struct net_device *dev)
 {
        int ioaddr = dev->base_addr;
-       struct znet_private *znet = dev->priv;
+       struct znet_private *znet = netdev_priv(dev);
        unsigned long flags;
        short length = skb->len;
 
 static irqreturn_t znet_interrupt(int irq, void *dev_id)
 {
        struct net_device *dev = dev_id;
-       struct znet_private *znet = dev->priv;
+       struct znet_private *znet = netdev_priv(dev);
        int ioaddr;
        int boguscnt = 20;
        int handled = 0;
 
 static void znet_rx(struct net_device *dev)
 {
-       struct znet_private *znet = dev->priv;
+       struct znet_private *znet = netdev_priv(dev);
        int ioaddr = dev->base_addr;
        int boguscount = 1;
        short next_frame_end_offset = 0;                /* Offset of next frame start. */
 {
        short ioaddr = dev->base_addr;
        unsigned char stat = inb (ioaddr);
-       struct znet_private *znet = dev->priv;
+       struct znet_private *znet = netdev_priv(dev);
        unsigned long flags;
        short dma_port = ((znet->tx_dma&3)<<2) + IO_DMA2_BASE;
        unsigned addr = inb(dma_port);
 {
        unsigned long flags;
        short ioaddr = dev->base_addr;
-       struct znet_private *znet = dev->priv;
+       struct znet_private *znet = netdev_priv(dev);
 
        znet->rx_cur = znet->rx_start;
        znet->tx_cur = znet->tx_start;
 static __exit void znet_cleanup (void)
 {
        if (znet_dev) {
-               struct znet_private *znet = znet_dev->priv;
+               struct znet_private *znet = netdev_priv(znet_dev);
 
                unregister_netdev (znet_dev);
                kfree (znet->rx_start);
 
        skb->dev   = dev;
        skb_reset_transport_header(skb);
 
-       stats = dev->priv;
+       stats = netdev_priv(dev);
        stats->rx_packets++;
        stats->rx_bytes += skb->len + 13;
        netif_rx(skb);  /* Send the SKB up to a higher place. */
 
 
 static inline struct br2684_dev *BRPRIV(const struct net_device *net_dev)
 {
-       return (struct br2684_dev *)net_dev->priv;
+       return (struct br2684_dev *)netdev_priv(net_dev);
 }
 
 static inline struct net_device *list_entry_brdev(const struct list_head *le)
 
                buff += 4;
                mesg->content.normal.flag = *buff & 0x01;       /* 0x01 is topology change */
 
-               priv = (struct lec_priv *)dev->priv;
+               priv = netdev_priv(dev);
                atm_force_charge(priv->lecd, skb2->truesize);
                sk = sk_atm(priv->lecd);
                skb_queue_tail(&sk->sk_receive_queue, skb2);
 
 static int lec_open(struct net_device *dev)
 {
-       struct lec_priv *priv = (struct lec_priv *)dev->priv;
+       struct lec_priv *priv = netdev_priv(dev);
 
        netif_start_queue(dev);
        memset(&priv->stats, 0, sizeof(struct net_device_stats));
 static int lec_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct sk_buff *skb2;
-       struct lec_priv *priv = (struct lec_priv *)dev->priv;
+       struct lec_priv *priv = netdev_priv(dev);
        struct lecdatahdr_8023 *lec_h;
        struct atm_vcc *vcc;
        struct lec_arp_table *entry;
  */
 static struct net_device_stats *lec_get_stats(struct net_device *dev)
 {
-       return &((struct lec_priv *)dev->priv)->stats;
+       return &((struct lec_priv *)netdev_priv(dev))->stats;
 }
 
 static int lec_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
 {
        unsigned long flags;
        struct net_device *dev = (struct net_device *)vcc->proto_data;
-       struct lec_priv *priv = (struct lec_priv *)dev->priv;
+       struct lec_priv *priv = netdev_priv(dev);
        struct atmlec_msg *mesg;
        struct lec_arp_table *entry;
        int i;
 {
        struct sk_buff *skb;
        struct net_device *dev = (struct net_device *)vcc->proto_data;
-       struct lec_priv *priv = (struct lec_priv *)dev->priv;
+       struct lec_priv *priv = netdev_priv(dev);
 
        priv->lecd = NULL;
        /* Do something needful? */
 {
        unsigned long flags;
        struct net_device *dev = (struct net_device *)vcc->proto_data;
-       struct lec_priv *priv = (struct lec_priv *)dev->priv;
+       struct lec_priv *priv = netdev_priv(dev);
 
 #if DUMP_PACKETS >0
        int i = 0;
        vpriv->old_pop = vcc->pop;
        vcc->user_back = vpriv;
        vcc->pop = lec_pop;
-       lec_vcc_added(dev_lec[ioc_data.dev_num]->priv,
+       lec_vcc_added(netdev_priv(dev_lec[ioc_data.dev_num]),
                      &ioc_data, vcc, vcc->push);
        vcc->proto_data = dev_lec[ioc_data.dev_num];
        vcc->push = lec_push;
        if (arg < 0 || arg >= MAX_LEC_ITF || !dev_lec[arg])
                return -EINVAL;
        vcc->proto_data = dev_lec[arg];
-       return (lec_mcast_make((struct lec_priv *)dev_lec[arg]->priv, vcc));
+       return lec_mcast_make((struct lec_priv *)netdev_priv(dev_lec[arg]),
+                               vcc);
 }
 
 /* Initialize device. */
                        return -EINVAL;
                }
 
-               priv = dev_lec[i]->priv;
+               priv = netdev_priv(dev_lec[i]);
                priv->is_trdev = is_trdev;
                lec_init(dev_lec[i]);
        } else {
-               priv = dev_lec[i]->priv;
+               priv = netdev_priv(dev_lec[i]);
                if (priv->lecd)
                        return -EADDRINUSE;
        }
        void *v;
 
        dev = state->dev ? state->dev : dev_lec[state->itf];
-       v = (dev && dev->priv) ? lec_priv_walk(state, l, dev->priv) : NULL;
+       v = (dev && netdev_priv(dev)) ?
+               lec_priv_walk(state, l, netdev_priv(dev)) : NULL;
        if (!v && dev) {
                dev_put(dev);
                /* Partial state reset for the next time we get called */
 
        for (i = 0; i < MAX_LEC_ITF; i++) {
                if (dev_lec[i] != NULL) {
-                       priv = (struct lec_priv *)dev_lec[i]->priv;
+                       priv = netdev_priv(dev_lec[i]);
                        unregister_netdev(dev_lec[i]);
                        free_netdev(dev_lec[i]);
                        dev_lec[i] = NULL;
                         u8 **tlvs, u32 *sizeoftlvs)
 {
        unsigned long flags;
-       struct lec_priv *priv = (struct lec_priv *)dev->priv;
+       struct lec_priv *priv = netdev_priv(dev);
        struct lec_arp_table *table;
        struct sk_buff *skb;
        int retval;
 {
        int retval;
        struct sk_buff *skb;
-       struct lec_priv *priv = (struct lec_priv *)dev->priv;
+       struct lec_priv *priv = netdev_priv(dev);
 
        if (compare_ether_addr(lan_dst, dev->dev_addr))
                return (0);     /* not our mac address */
 #if 0
        int i = 0;
 #endif
-       struct lec_priv *priv = (struct lec_priv *)dev->priv;
+       struct lec_priv *priv = netdev_priv(dev);
 #if 0                          /*
                                 * Why have the TLVs in LE_ARP entries
                                 * since we do not use them? When you
 
        }
 
        if (mpc->dev) { /* check if the lec is LANE2 capable */
-               priv = (struct lec_priv *)mpc->dev->priv;
+               priv = netdev_priv(mpc->dev);
                if (priv->lane_version < 2) {
                        dev_put(mpc->dev);
                        mpc->dev = NULL;
 
        mpc->mpoad_vcc = NULL;
        if (mpc->dev) {
-               struct lec_priv *priv = (struct lec_priv *)mpc->dev->priv;
+               struct lec_priv *priv = netdev_priv(mpc->dev);
                priv->lane2_ops->associate_indicator = NULL;
                stop_mpc(mpc);
                dev_put(mpc->dev);
 
        switch (event) {
        case NETDEV_REGISTER:       /* a new lec device was allocated */
-               priv = (struct lec_priv *)dev->priv;
+               priv = netdev_priv(dev);
                if (priv->lane_version < 2)
                        break;
                priv->lane2_ops->associate_indicator = lane2_assoc_ind;
        dprintk("\n");
 
        if (mpc->dev) {
-               priv = (struct lec_priv *)mpc->dev->priv;
+               priv = netdev_priv(mpc->dev);
                retval = priv->lane2_ops->associate_req(mpc->dev, mpc->dev->dev_addr, tlv, sizeof(tlv));
                if (retval == 0)
                        printk("mpoa: (%s) MPOA device type TLV association failed\n", mpc->dev->name);
                tmp = mpc->next;
                if (mpc->dev != NULL) {
                        stop_mpc(mpc);
-                       priv = (struct lec_priv *)mpc->dev->priv;
+                       priv = netdev_priv(mpc->dev);
                        if (priv->lane2_ops != NULL)
                                priv->lane2_ops->associate_indicator = NULL;
                }
 
                goto failed;
        }
 
-       s = dev->priv;
+       s = netdev_priv(dev);
 
        /* This is rx header therefore addresses are swapped.
         * ie eh.h_dest is our local address. */
 
 
 static struct net_device_stats *bnep_net_get_stats(struct net_device *dev)
 {
-       struct bnep_session *s = dev->priv;
+       struct bnep_session *s = netdev_priv(dev);
        return &s->stats;
 }
 
 static void bnep_net_set_mc_list(struct net_device *dev)
 {
 #ifdef CONFIG_BT_BNEP_MC_FILTER
-       struct bnep_session *s = dev->priv;
+       struct bnep_session *s = netdev_priv(dev);
        struct sock *sk = s->sock->sk;
        struct bnep_set_filter_req *r;
        struct sk_buff *skb;
 
 static int bnep_net_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-       struct bnep_session *s = dev->priv;
+       struct bnep_session *s = netdev_priv(dev);
        struct sock *sk = s->sock->sk;
 
        BT_DBG("skb %p, dev %p", skb, dev);
 
 restart:
        for_each_netdev(net, dev) {
                if (dev->priv_flags & IFF_EBRIDGE) {
-                       del_br(dev->priv);
+                       del_br(netdev_priv(dev));
                        goto restart;
                }
        }
 
 #include "br_private.h"
 
 #define to_dev(obj)    container_of(obj, struct device, kobj)
-#define to_bridge(cd)  ((struct net_bridge *)(to_net_dev(cd)->priv))
+#define to_bridge(cd)  ((struct net_bridge *)netdev_priv(to_net_dev(cd)))
 
 /*
  * Common code for storing bridge parameters.
 
        if (!dev)
                return NULL;
 
-       self = dev->priv;
+       self = netdev_priv(dev);
        self->dev = dev;
 
        /*