compat/compat-2.6.23.c

   1 /*
   2  * Copyright 2007       Luis R. Rodriguez <mcgrof@winlab.rutgers.edu>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * Compatibility file for Linux wireless for kernels 2.6.23.
   9  */
  10
  11 #include <net/compat.h>
  12
  13 /* On net/core/dev.c as of 2.6.24 */
  14 int __dev_addr_delete(struct dev_addr_list **list, int *count,
  15                       void *addr, int alen, int glbl)
  16 {
  17         struct dev_addr_list *da;
  18
  19         for (; (da = *list) != NULL; list = &da->next) {
  20                 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
  21                         alen == da->da_addrlen) {
  22                         if (glbl) {
  23                                 int old_glbl = da->da_gusers;
  24                                 da->da_gusers = 0;
  25                                 if (old_glbl == 0)
  26                                         break;
  27                         }
  28                         if (--da->da_users)
  29                                 return 0;
  30
  31                         *list = da->next;
  32                         kfree(da);
  33                         (*count)--;
  34                         return 0;
  35                 }
  36         }
  37         return -ENOENT;
  38 }
  39 EXPORT_SYMBOL(__dev_addr_delete);
  40
  41 /* On net/core/dev.c as of 2.6.24. This is not yet used by mac80211 but
  42  * might as well add it */
  43 int __dev_addr_add(struct dev_addr_list **list, int *count,
  44                    void *addr, int alen, int glbl)
  45 {
  46         struct dev_addr_list *da;
  47
  48         for (da = *list; da != NULL; da = da->next) {
  49                 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
  50                         da->da_addrlen == alen) {
  51                         if (glbl) {
  52                                 int old_glbl = da->da_gusers;
  53                                 da->da_gusers = 1;
  54                                 if (old_glbl)
  55                                         return 0;
  56                         }
  57                         da->da_users++;
  58                         return 0;
  59                 }
  60         }
  61
  62         da = kmalloc(sizeof(*da), GFP_ATOMIC);
  63         if (da == NULL)
  64                 return -ENOMEM;
  65         memcpy(da->da_addr, addr, alen);
  66         da->da_addrlen = alen;
  67         da->da_users = 1;
  68         da->da_gusers = glbl ? 1 : 0;
  69         da->next = *list;
  70         *list = da;
  71         (*count)++;
  72         return 0;
  73 }
  74 EXPORT_SYMBOL(__dev_addr_add);
  75
  76
  77 /* Part of net/core/dev_mcast.c as of 2.6.23. This is a slightly different version.
  78  * Since da->da_synced is not part of 2.6.22 we need to take longer route when
  79  * syncing */
  80
  81 /**
  82  *      dev_mc_sync     - Synchronize device's multicast list to another device
  83  *      @to: destination device
  84  *      @from: source device
  85  *
  86  *      Add newly added addresses to the destination device and release
  87  *      addresses that have no users left. The source device must be
  88  *      locked by netif_tx_lock_bh.
  89  *
  90  *      This function is intended to be called from the dev->set_multicast_list
  91  *      function of layered software devices.
  92  */
  93 int dev_mc_sync(struct net_device *to, struct net_device *from)
  94 {
  95         struct dev_addr_list *da, *next, *da_to;
  96         int err = 0;
  97
  98         netif_tx_lock_bh(to);
  99         da = from->mc_list;
 100         while (da != NULL) {
 101                 int synced = 0;
 102                 next = da->next;
 103                 da_to = to->mc_list;
 104                 /* 2.6.22 does not have da->da_synced so lets take the long route */
 105                 while (da_to != NULL) {
 106                         if (memcmp(da_to->da_addr, da->da_addr, da_to->da_addrlen) == 0 &&
 107                                 da->da_addrlen == da_to->da_addrlen)
 108                                 synced = 1;
 109                                 break;
 110                 }
 111                 if (!synced) {
 112                         err = __dev_addr_add(&to->mc_list, &to->mc_count,
 113                                              da->da_addr, da->da_addrlen, 0);
 114                         if (err < 0)
 115                                 break;
 116                         da->da_users++;
 117                 } else if (da->da_users == 1) {
 118                         __dev_addr_delete(&to->mc_list, &to->mc_count,
 119                                           da->da_addr, da->da_addrlen, 0);
 120                         __dev_addr_delete(&from->mc_list, &from->mc_count,
 121                                           da->da_addr, da->da_addrlen, 0);
 122                 }
 123                 da = next;
 124         }
 125         if (!err)
 126                 __dev_set_rx_mode(to);
 127         netif_tx_unlock_bh(to);
 128
 129         return err;
 130 }
 131 EXPORT_SYMBOL(dev_mc_sync);
 132
 133
 134 /* Part of net/core/dev_mcast.c as of 2.6.23. This is a slighty different version.
 135  * Since da->da_synced is not part of 2.6.22 we need to take longer route when
 136  * unsyncing */
 137
 138 /**
 139  *      dev_mc_unsync   - Remove synchronized addresses from the destination
 140  *                        device
 141  *      @to: destination device
 142  *      @from: source device
 143  *
 144  *      Remove all addresses that were added to the destination device by
 145  *      dev_mc_sync(). This function is intended to be called from the
 146  *      dev->stop function of layered software devices.
 147  */
 148 void dev_mc_unsync(struct net_device *to, struct net_device *from)
 149 {
 150         struct dev_addr_list *da, *next, *da_to;
 151
 152         netif_tx_lock_bh(from);
 153         netif_tx_lock_bh(to);
 154
 155         da = from->mc_list;
 156         while (da != NULL) {
 157                 bool synced = false;
 158                 next = da->next;
 159                 da_to = to->mc_list;
 160                 /* 2.6.22 does not have da->da_synced so lets take the long route */
 161                 while (da_to != NULL) {
 162                         if (memcmp(da_to->da_addr, da->da_addr, da_to->da_addrlen) == 0 &&
 163                                 da->da_addrlen == da_to->da_addrlen)
 164                                 synced = true;
 165                                 break;
 166                 }
 167                 if (!synced) {
 168                         da = next;
 169                         continue;
 170                 }
 171                 __dev_addr_delete(&to->mc_list, &to->mc_count,
 172                         da->da_addr, da->da_addrlen, 0);
 173                 __dev_addr_delete(&from->mc_list, &from->mc_count,
 174                         da->da_addr, da->da_addrlen, 0);
 175                 da = next;
 176         }
 177         __dev_set_rx_mode(to);
 178
 179         netif_tx_unlock_bh(to);
 180         netif_tx_unlock_bh(from);
 181 }
 182 EXPORT_SYMBOL(dev_mc_unsync);
 183
 184 /* Added as of 2.6.23 on net/core/dev.c. Slightly modifed, no dev->set_rx_mode on
 185  * 2.6.22 so ignore that. */
 186
 187 /*
 188  *      Upload unicast and multicast address lists to device and
 189  *      configure RX filtering. When the device doesn't support unicast
 190  *      filtering it is put in promiscous mode while unicast addresses
 191  *      are present.
 192  */
 193 void __dev_set_rx_mode(struct net_device *dev)
 194 {
 195         /* dev_open will call this function so the list will stay sane. */
 196         if (!(dev->flags&IFF_UP))
 197                 return;
 198
 199         if (!netif_device_present(dev))
 200                 return;
 201
 202 /* This needs to be ported to 2.6.22 framework */
 203 #if 0
 204         /* Unicast addresses changes may only happen under the rtnl,
 205          * therefore calling __dev_set_promiscuity here is safe.
 206          */
 207         if (dev->uc_count > 0 && !dev->uc_promisc) {
 208                 __dev_set_promiscuity(dev, 1);
 209                 dev->uc_promisc = 1;
 210         } else if (dev->uc_count == 0 && dev->uc_promisc) {
 211                 __dev_set_promiscuity(dev, -1);
 212                 dev->uc_promisc = 0;
 213         }
 214 #endif
 215
 216         if (dev->set_multicast_list)
 217                 dev->set_multicast_list(dev);
 218 }
 219
 220 /**
 221  * pci_try_set_mwi - enables memory-write-invalidate PCI transaction
 222  * @dev: the PCI device for which MWI is enabled
 223  *
 224  * Enables the Memory-Write-Invalidate transaction in %PCI_COMMAND.
 225  * Callers are not required to check the return value.
 226  *
 227  * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
 228  */
 229 int pci_try_set_mwi(struct pci_dev *dev)
 230 {
 231         int rc = 0;
 232 #ifdef HAVE_PCI_SET_MWI
 233         rc = pci_set_mwi(dev);
 234 #endif
 235         return rc;
 236 }
 237 EXPORT_SYMBOL(pci_try_set_mwi);
 238 #endif
 239