[aesthetic] Adjust parenthesis spacing on net80211.[ch] to fit gPXE style
authorJoshua Oreman <oremanj@xenon.get-linux.org>
Sun, 7 Jun 2009 05:28:50 +0000 (22:28 -0700)
committerJoshua Oreman <oremanj@xenon.get-linux.org>
Sun, 7 Jun 2009 05:28:50 +0000 (22:28 -0700)
src/include/gpxe/net80211.h
src/net/net80211.c

index c5d5086..74c3d0d 100644 (file)
@@ -30,7 +30,7 @@
  *   use of these.
  */
 
-FILE_LICENCE(GPL2_OR_LATER);
+FILE_LICENCE ( GPL2_OR_LATER );
 
 /* All 802.11 devices are handled using a generic "802.11 device"
    net_device, with a link in its `priv' field to a net80211_device
@@ -48,11 +48,11 @@ struct net80211_device;
 struct net80211_device_operations {
        /* These have the same semantics as they do in net_device. */
 
-       int (*open)(struct net80211_device *dev);
-       void (*close)(struct net80211_device *dev);
-       int (*transmit)(struct net80211_device *dev, struct io_buffer *iobuf);
-       void (*poll)(struct net80211_device *dev);
-       void (*irq)(struct net80211_device *dev, int enable);
+       int ( * open )( struct net80211_device *dev );
+       void ( * close )( struct net80211_device *dev );
+       int ( * transmit )( struct net80211_device *dev, struct io_buffer *iobuf );
+       void ( * poll )( struct net80211_device *dev );
+       void ( * irq )( struct net80211_device *dev, int enable );
 
        /* And these are specific to 802.11. */
 
@@ -60,7 +60,7 @@ struct net80211_device_operations {
            net80211_device with respect to `changed', a bitwise OR of
            NET80211_CFG_* indicating what's changed. Only called when
            the device is open. */
-       int (*config)(struct net80211_device *dev, int changed);
+       int ( * config )( struct net80211_device *dev, int changed );
 };
 
 #define NET80211_BAND_2GHZ  (1 << 0)   /* the 2.4 GHz ISM band */
@@ -188,19 +188,20 @@ struct net80211_crypto
        short type;
 
        /** Initialize crypto algorithm using the given key. */
-       void (*initialize)(struct net80211_device *dev, u8 *key, int keylen);
+       void ( * initialize )( struct net80211_device *dev, u8 *key,
+                              int keylen );
 
        /** Encrypt the given frame into a newly allocated io_buffer
            with all frame headers intact. Returns NULL if out of
            memory. */
-       struct io_buffer *(*encrypt)(struct net80211_device *dev,
-                                    struct io_buffer *iob);
+       struct io_buffer * ( * encrypt )( struct net80211_device *dev,
+                                         struct io_buffer *iob );
        
        /** Decrypt the given frame into a newly allocated io_buffer
            with all frame headers intact. Returns NULL if decryption
            fails. */
-       struct io_buffer *(*decrypt)(struct net80211_device *dev,
-                                    struct io_buffer *iob);
+       struct io_buffer * ( * decrypt )( struct net80211_device *dev,
+                                         struct io_buffer *iob );
 
        /** Private data for the crypto algorithm to store key and
            state information. */
@@ -357,51 +358,52 @@ struct net80211_wlan
 
 /** Scans the area, returning a list of net80211_wlan structures
     corresponding to each of the reachable wireless networks. */
-struct list_head *net80211_scan(struct net80211_device *dev);
+struct list_head * net80211_scan ( struct net80211_device *dev );
 
 /** Frees the list returned from a scan call. */
-void net80211_free_wlanlist(struct list_head *netlist);
+void net80211_free_wlanlist ( struct list_head *netlist );
 
 /** Scans for the given ESSID specifically. Can be used to associate
     with "hidden" networks on the 2.4GHz band. */
-struct net80211_wlan *net80211_probe(struct net80211_device *dev,
-                                    const char *essid, int active);
+struct net80211_wlan * net80211_probe ( struct net80211_device *dev,
+                                       const char *essid, int active );
 
 /** Frees a single net80211_wlan structure. */
-void net80211_free_wlan(struct net80211_wlan *wlan);
+void net80211_free_wlan ( struct net80211_wlan *wlan );
 
 /** Does scan/probe as appropriate given configured settings, and
     associates. Operates as a background process; this function
     returns immediately, before the association has been performed. */
-void net80211_autoassociate(struct net80211_device *dev);
+void net80211_autoassociate ( struct net80211_device *dev );
 
 /* -- general-use net80211 API: -- */
 
 /** If the passed net_device wraps a net80211_device, returns the
     net80211_device. If not, returns NULL. */
-struct net80211_device *net80211_get(struct net_device *netdev);
+struct net80211_device * net80211_get ( struct net_device *netdev );
 
 /* - association steps: -   [normally performed by autoassociate] */
 
 /** Sets up the device's regulatory parameters to a sane default for
     passive scanning or active 2.4GHz scanning. */
-int net80211_prepare_default(struct net80211_device *dev, int band,
-                            int active);
+int net80211_prepare_default ( struct net80211_device *dev, int band,
+                              int active );
 
 /** Sets up the device's regulatory parameters as the provided beacon
     or probe response frame tells us to. Must be called before
     associating. */
-int net80211_prepare(struct net80211_device *dev, struct net80211_wlan *wlan);
+int net80211_prepare ( struct net80211_device *dev,
+                      struct net80211_wlan *wlan );
 
 /** Performs an authentication sequence using the specified
     method. Returns immediately, sets state variables. */
-int net80211_send_auth(struct net80211_device *dev, struct net80211_wlan *wlan,
-                      int method);
+int net80211_send_auth ( struct net80211_device *dev,
+                        struct net80211_wlan *wlan, int method );
 
 /** Performs the actual association with the network described by
     `wlan'. Requires authentication to have previously succeeded. */
-int net80211_send_assoc(struct net80211_device *dev,
-                       struct net80211_wlan *wlan);
+int net80211_send_assoc ( struct net80211_device *dev,
+                         struct net80211_wlan *wlan );
 
 /* - management frame handling: - */
 
@@ -411,7 +413,7 @@ int net80211_send_assoc(struct net80211_device *dev,
     up and waste memory. Keeping management packets is disabled by
     default. Returns the setting of keeping management packets that
     preceded the function call. */
-int net80211_keep_mgmt(struct net80211_device *dev, int enable);
+int net80211_keep_mgmt ( struct net80211_device *dev, int enable );
 
 /** Returns the next packet from the device's received management
     packet queue, or NULL if the queue is empty. You must have called
@@ -419,8 +421,8 @@ int net80211_keep_mgmt(struct net80211_device *dev, int enable);
     returned io_buffer passes to the calling function. If `signal' is
     non-NULL it is filled with the signal strength of the received
     frame in device units. */
-struct io_buffer *net80211_mgmt_dequeue(struct net80211_device *dev,
-                                       int *signal);
+struct io_buffer * net80211_mgmt_dequeue ( struct net80211_device *dev,
+                                          int *signal );
 
 /** Sends an 802.11 management packet. The passed io_buffer must have
     at least IEEE80211_TYP_FRAME_HEADER_LEN = 24 bytes of headroom for
@@ -428,8 +430,8 @@ struct io_buffer *net80211_mgmt_dequeue(struct net80211_device *dev,
     sent to the AP of the network identified by `bssid'; it is not
     possible to use this function to send management frames that are
     not directed at APs. The frame is encrypted if fc & PROTECTED. */
-int net80211_tx_mgmt(struct net80211_device *dev, u16 fc, u8 bssid[6],
-                    struct io_buffer *iob);
+int net80211_tx_mgmt ( struct net80211_device *dev, u16 fc, u8 bssid[6],
+                      struct io_buffer *iob );
 
 /* -- Driver API: -- */
 
@@ -440,44 +442,44 @@ int net80211_tx_mgmt(struct net80211_device *dev, u16 fc, u8 bssid[6],
 /** Allocates a new 802.11 device with priv_size bytes of
     driver-private data behind its `priv' pointer. This also allocates
     the gPXE net_device and sets up its operations. */
-struct net80211_device *net80211_alloc(size_t priv_size);
+struct net80211_device *net80211_alloc ( size_t priv_size );
 
 /** Set up an 802.11 device to use the provided operations and
     hardware information, and register it with the network stack. The
     hw info will be copied into a dynamically allocated structure that
     the 802.11 layer takes ownership of; the ops are simply pointed
     at, and should be defined statically. */
-int net80211_register(struct net80211_device *dev,
-                     struct net80211_device_operations *ops,
-                     struct net80211_hw_info *hw);
+int net80211_register ( struct net80211_device *dev,
+                       struct net80211_device_operations *ops,
+                       struct net80211_hw_info *hw );
 
 /** Indicate receipt of a raw packet from the network interface. Takes
     ownership of the iob. `signal' is signal strength in device
     units. */
-void net80211_rx(struct net80211_device *dev, struct io_buffer *iob,
-                int signal);
+void net80211_rx ( struct net80211_device *dev, struct io_buffer *iob,
+                  int signal );
 
 /** Indicate an error in receiving a packet. Pass iob if you want it
     freed. */
-static inline void net80211_rx_err(struct net80211_device *dev,
-                                  struct io_buffer *iob, int rc) 
+static inline void net80211_rx_err ( struct net80211_device *dev,
+                                    struct io_buffer *iob, int rc )
 {
-       netdev_rx_err(dev->netdev, iob, rc);
+       netdev_rx_err ( dev->netdev, iob, rc );
 }
 
 /** Indicate the completed transmission of a packet passed to
     (*transmit)(), successfully if rc == 0 and unsuccessfully if
     not. In either case this function takes ownership of the iob. */
-static inline void net80211_tx_complete(struct net80211_device *dev,
-                                       struct io_buffer *iob, int rc) 
+static inline void net80211_tx_complete ( struct net80211_device *dev,
+                                         struct io_buffer *iob, int rc )
 {
-       netdev_tx_complete_err(dev->netdev, iob, rc);
+       netdev_tx_complete_err ( dev->netdev, iob, rc );
 }
 
 /** Removes the registration of an 802.11 device. */
-void net80211_unregister(struct net80211_device *dev);
+void net80211_unregister ( struct net80211_device *dev );
 
 /** Frees all memory allocated by the 802.11 layer for a device. */
-void net80211_free(struct net80211_device *dev);
+void net80211_free ( struct net80211_device *dev );
 
 #endif
index af3b160..21fb1f6 100644 (file)
@@ -34,7 +34,7 @@ FILE_LICENCE ( GPL2_OR_LATER );
 #include <errno.h>
 
 /** List of 802.11 devices */
-static struct list_head net80211_devices = LIST_HEAD_INIT(net80211_devices);
+static struct list_head net80211_devices = LIST_HEAD_INIT ( net80211_devices );
 
 /** The network name to associate with
  *
@@ -67,65 +67,65 @@ void net80211_step_associate ( struct process *proc );
 
 /** Structure for keeping a queue of saved management packet signal
     strengths in parallel to the saved iobs. */
-struct net80211_rx_info
-{
+struct net80211_rx_info {
        int signal;
        struct list_head list;
 };
 
 /* ---------- net_device wrapper ---------- */
 
-int net80211_netdev_open(struct net_device *netdev) 
+int net80211_netdev_open ( struct net_device *netdev )
 {
        struct net80211_device *dev = netdev->priv;
 
-       if (dev->op->open)
-               return dev->op->open(dev);
+       if ( dev->op->open )
+               return dev->op->open ( dev );
 
-       net80211_autoassociate(dev);
+       net80211_autoassociate ( dev );
        return 0;
 }
 
-void net80211_netdev_close(struct net_device *netdev)
+void net80211_netdev_close ( struct net_device *netdev )
 {
        struct net80211_device *dev = netdev->priv;
 
-       if (dev->op->close)
-               dev->op->close(dev);
+       if ( dev->op->close )
+               dev->op->close ( dev );
 }
 
-int net80211_netdev_transmit(struct net_device *netdev, struct io_buffer *iobuf)
+int net80211_netdev_transmit ( struct net_device *netdev,
+                              struct io_buffer *iobuf )
 {
        struct net80211_device *dev = netdev->priv;
-       
-       if (dev->crypto) {
-               struct io_buffer *niob = dev->crypto->encrypt(dev, iobuf);
-               if (!niob)
+
+       if ( dev->crypto ) {
+               struct io_buffer *niob = dev->crypto->encrypt ( dev, iobuf );
+               if ( ! niob )
                        return -ENOMEM; /* only reason encryption could fail */
 
-               free_iob(iobuf);
+               free_iob ( iobuf );
                iobuf = niob;
        }
-       
-       if (dev->op->transmit)
-               return dev->op->transmit(dev, iobuf);
+
+       if ( dev->op->transmit )
+               return dev->op->transmit ( dev, iobuf );
        return -ENOSYS;
 }
 
-void net80211_netdev_poll(struct net_device *netdev)
+void net80211_netdev_poll ( struct net_device *netdev )
 {
        struct net80211_device *dev = netdev->priv;
-       
-       if (dev->op->poll)
-               dev->op->poll(dev);
+
+       if ( dev->op->poll )
+               dev->op->poll ( dev );
 }
 
-void net80211_netdev_irq(struct net_device *netdev, int enable)
+void net80211_netdev_irq ( struct net_device *netdev, int enable )
 {
        struct net80211_device *dev = netdev->priv;
-       
-       if (dev->op->irq)
-               dev->op->irq(dev, enable);
+
+       if ( dev->op->irq )
+               dev->op->irq ( dev, enable );
 }
 
 struct net_device_operations net80211_netdev_ops = {
@@ -138,111 +138,114 @@ struct net_device_operations net80211_netdev_ops = {
 
 /* ---------- 802.11 link-layer protocol ---------- */
 
-static u8 net80211_ll_broadcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+static u8 net80211_ll_broadcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 
 /* Returns the time taken to transmit a packet of length `bytes' using
    the current PHY parameters of `dev', measured in microseconds
    starting immediately after reception of the previous packet is
    complete. */
-static u16 net80211_duration(struct net80211_device *dev, int bytes) 
+static u16 net80211_duration ( struct net80211_device *dev, int bytes )
 {
        struct net80211_channel *chan = &dev->channels[dev->channel];
        u16 ratecode = dev->rates[dev->rate];
-       u32 kbps = NET80211_RATE_VALUE(ratecode) * 100;
-       
-       if (chan->band == NET80211_BAND_5GHZ || ratecode & NET80211_RATE_ERP) {
+       u32 kbps = NET80211_RATE_VALUE ( ratecode ) * 100;
+
+       if ( chan->band == NET80211_BAND_5GHZ || ratecode & NET80211_RATE_ERP ) {
                /* OFDM encoding (802.11a/g) */
-               int bits_per_symbol = (kbps * 4) / 1000; /* 4us/symbol */
-               int bits = 22 + (bytes << 3); /* 22-bit PLCP */
-               int symbols = (bits + bits_per_symbol - 1) / bits_per_symbol;
-               return 16 + 20 + (symbols * 4); /* 16us SIFS, 20us preamble */
+               int bits_per_symbol = ( kbps * 4 ) / 1000;      /* 4us/symbol */
+               int bits = 22 + ( bytes << 3 ); /* 22-bit PLCP */
+               int symbols = ( bits + bits_per_symbol - 1 ) / bits_per_symbol;
+               return 16 + 20 + ( symbols * 4 ); /* 16us SIFS, 20us preamble */
        } else {
                /* CCK encoding (802.11b) */
-               int phy_time = 144 + 48; /* preamble + PLCP */
-               if (dev->erp_flags & NET80211_ERP_USE_SHORT_PREAMBLE)
+               int phy_time = 144 + 48;        /* preamble + PLCP */
+               if ( dev->erp_flags & NET80211_ERP_USE_SHORT_PREAMBLE )
                        phy_time >>= 1;
                int bits = bytes << 3;
-               int data_time = (bits * 1000) / kbps;
+               int data_time = ( bits * 1000 ) / kbps;
                return 10 + phy_time + data_time; /* 10us SIFS */
        }
 }
 
-static int net80211_ll_push(struct net_device *netdev, struct io_buffer *iobuf,
-                           const void *ll_dest, const void *ll_source,
-                           uint16_t net_proto)
+static int net80211_ll_push ( struct net_device *netdev,
+                             struct io_buffer *iobuf, const void *ll_dest,
+                             const void *ll_source, uint16_t net_proto )
 {
        struct net80211_device *dev = netdev->priv;
-       struct ieee80211_frame *hdr = iob_push(iobuf, IEEE80211_LLC_HEADER_LEN +
-                                              IEEE80211_TYP_FRAME_HEADER_LEN);
-       struct ieee80211_llc_snap_header *lhdr = (struct ieee80211_llc_snap_header *)
-               ((u8 *)hdr + IEEE80211_TYP_FRAME_HEADER_LEN);
+       struct ieee80211_frame *hdr = iob_push ( iobuf,
+                                                IEEE80211_LLC_HEADER_LEN +
+                                                IEEE80211_TYP_FRAME_HEADER_LEN );
+       struct ieee80211_llc_snap_header *lhdr =
+               ( void * ) hdr + IEEE80211_TYP_FRAME_HEADER_LEN;
 
        hdr->fc = IEEE80211_THIS_VERSION | IEEE80211_TYPE_DATA |
-                 IEEE80211_STYPE_DATA | IEEE80211_FC_TODS;
+           IEEE80211_STYPE_DATA | IEEE80211_FC_TODS;
 
        /* We don't send fragmented frames, so duration is the time
           for an SIFS + 10-byte ACK. */
-       hdr->duration = net80211_duration(dev, 10);
+       hdr->duration = net80211_duration ( dev, 10 );
 
-       memcpy(hdr->addr1, dev->bssid, ETH_ALEN);
-       memcpy(hdr->addr2, ll_source, ETH_ALEN);
-       memcpy(hdr->addr3, ll_dest, ETH_ALEN);
+       memcpy ( hdr->addr1, dev->bssid, ETH_ALEN );
+       memcpy ( hdr->addr2, ll_source, ETH_ALEN );
+       memcpy ( hdr->addr3, ll_dest, ETH_ALEN );
 
-       hdr->seq = ++dev->last_tx_seqnr & 0x0FFF; /* fragment 0 */
+       hdr->seq = ++dev->last_tx_seqnr & 0x0FFF;       /* fragment 0 */
 
        lhdr->dsap = IEEE80211_LLC_DSAP;
        lhdr->ssap = IEEE80211_LLC_SSAP;
        lhdr->ctrl = IEEE80211_LLC_CTRL;
-       memset(lhdr->oui, 0x00, 3);
+       memset ( lhdr->oui, 0x00, 3 );
        lhdr->ethertype = net_proto;
 
        return 0;
 }
 
-static int net80211_ll_pull(struct net_device *netdev __unused,
-                           struct io_buffer *iobuf, const void **ll_dest,
-                           const void **ll_source, uint16_t *net_proto)
+static int net80211_ll_pull ( struct net_device *netdev __unused,
+                             struct io_buffer *iobuf,
+                             const void **ll_dest, const void **ll_source,
+                             uint16_t * net_proto )
 {
        struct ieee80211_frame *hdr = iobuf->data;
-       struct ieee80211_llc_snap_header *lhdr = (struct ieee80211_llc_snap_header *)
-               ((u8 *)hdr + IEEE80211_TYP_FRAME_HEADER_LEN);
+       struct ieee80211_llc_snap_header *lhdr =
+               ( void * ) hdr + IEEE80211_TYP_FRAME_HEADER_LEN;
 
        /* Bunch of sanity checks */
-       if (iob_len(iobuf) < IEEE80211_TYP_FRAME_HEADER_LEN +
-                               IEEE80211_LLC_HEADER_LEN) {
-               DBG("802.11 packet too short (%zd bytes)\n", iob_len(iobuf));
+       if ( iob_len ( iobuf ) < IEEE80211_TYP_FRAME_HEADER_LEN +
+            IEEE80211_LLC_HEADER_LEN ) {
+               DBG ( "802.11 packet too short (%zd bytes)\n",
+                     iob_len ( iobuf ) );
                return -EINVAL;
        }
 
-       if ((hdr->fc & IEEE80211_FC_VERSION) != IEEE80211_THIS_VERSION) {
-               DBG("802.11 packet invalid version %04x\n",
-                   hdr->fc & IEEE80211_FC_VERSION);
+       if ( ( hdr->fc & IEEE80211_FC_VERSION ) != IEEE80211_THIS_VERSION ) {
+               DBG ( "802.11 packet invalid version %04x\n",
+                     hdr->fc & IEEE80211_FC_VERSION );
                return -EINVAL;
        }
 
-       if ((hdr->fc & IEEE80211_FC_TYPE) != IEEE80211_TYPE_DATA ||
-           (hdr->fc & IEEE80211_FC_SUBTYPE) != IEEE80211_STYPE_DATA) {
-               DBG("802.11 packet not data/data (fc=%04x)\n", hdr->fc);
+       if ( ( hdr->fc & IEEE80211_FC_TYPE ) != IEEE80211_TYPE_DATA ||
+            ( hdr->fc & IEEE80211_FC_SUBTYPE ) != IEEE80211_STYPE_DATA ) {
+               DBG ( "802.11 packet not data/data (fc=%04x)\n", hdr->fc );
                return -EINVAL;
        }
 
-       if ((hdr->fc & (IEEE80211_FC_TODS|IEEE80211_FC_FROMDS)) !=
-           IEEE80211_FC_FROMDS) {
-               DBG("802.11 packet not from DS (fc=%04x)\n", hdr->fc);
+       if ( ( hdr->fc & ( IEEE80211_FC_TODS | IEEE80211_FC_FROMDS ) ) !=
+            IEEE80211_FC_FROMDS ) {
+               DBG ( "802.11 packet not from DS (fc=%04x)\n", hdr->fc );
                return -EINVAL;
        }
 
-       if (lhdr->dsap != IEEE80211_LLC_DSAP || lhdr->ssap != IEEE80211_LLC_SSAP ||
-           lhdr->ctrl != IEEE80211_LLC_CTRL || lhdr->oui[0] || lhdr->oui[1] ||
-           lhdr->oui[2]) {
-               DBG("802.11 LLC header is not plain EtherType encapsulator: "
-                   "%02x->%02x [%02x] %02x:%02x:%02x %04x\n",
-                   lhdr->dsap, lhdr->ssap, lhdr->ctrl, lhdr->oui[0],
-                   lhdr->oui[1], lhdr->oui[2], lhdr->ethertype);
+       if ( lhdr->dsap != IEEE80211_LLC_DSAP || lhdr->ssap != IEEE80211_LLC_SSAP ||
+            lhdr->ctrl != IEEE80211_LLC_CTRL || lhdr->oui[0] || lhdr->oui[1] ||
+            lhdr->oui[2] ) {
+               DBG ( "802.11 LLC header is not plain EtherType encapsulator: "
+                     "%02x->%02x [%02x] %02x:%02x:%02x %04x\n",
+                     lhdr->dsap, lhdr->ssap, lhdr->ctrl, lhdr->oui[0],
+                     lhdr->oui[1], lhdr->oui[2], lhdr->ethertype );
                return -EINVAL;
        }
 
-       iob_pull(iobuf, sizeof(*hdr) + sizeof(*lhdr));
+       iob_pull ( iobuf, sizeof ( *hdr ) + sizeof ( *lhdr ) );
 
        *ll_dest = hdr->addr1;
        *ll_source = hdr->addr3;
@@ -250,148 +253,151 @@ static int net80211_ll_pull(struct net_device *netdev __unused,
        return 0;
 }
 
-static int net80211_ll_mc_hash(unsigned int af __unused,
-                              const void *net_addr __unused,
-                              void *ll_addr __unused) 
+static int net80211_ll_mc_hash ( unsigned int af __unused,
+                                const void *net_addr __unused,
+                                void *ll_addr __unused )
 {
        return -ENOTSUP;
 }
 
 static struct ll_protocol net80211_ll_protocol __ll_protocol = {
-       .name           = "802.11",
-       .push           = net80211_ll_push,
-       .pull           = net80211_ll_pull,
-       .ntoa           = eth_ntoa,
-       .mc_hash        = net80211_ll_mc_hash,
-       .ll_proto       = htons(ARPHRD_ETHER), /* it's "encapsulated Ethernet" */
-       .ll_addr_len    = ETH_ALEN,
-       .ll_header_len  = IEEE80211_TYP_FRAME_HEADER_LEN +
-                         IEEE80211_LLC_HEADER_LEN,
-       .ll_broadcast   = net80211_ll_broadcast,
+       .name = "802.11",
+       .push = net80211_ll_push,
+       .pull = net80211_ll_pull,
+       .ntoa = eth_ntoa,
+       .mc_hash = net80211_ll_mc_hash,
+       .ll_proto = htons ( ARPHRD_ETHER ),     /* it's "encapsulated Ethernet" */
+       .ll_addr_len = ETH_ALEN,
+       .ll_header_len = IEEE80211_TYP_FRAME_HEADER_LEN +
+                               IEEE80211_LLC_HEADER_LEN,
+       .ll_broadcast = net80211_ll_broadcast,
 };
 
 /* ---------- 802.11 network management API ---------- */
 
-struct net80211_device *net80211_get(struct net_device *netdev) 
+struct net80211_device * net80211_get ( struct net_device *netdev )
 {
        struct net80211_device *dev;
-       
-       list_for_each_entry(dev, &net80211_devices, list) {
-               if (netdev->priv == dev)
+
+       list_for_each_entry ( dev, &net80211_devices, list ) {
+               if ( netdev->priv == dev )
                        return netdev->priv;
        }
 
        return NULL;
 }
 
-int net80211_keep_mgmt(struct net80211_device *dev, int enable) 
+int net80211_keep_mgmt ( struct net80211_device *dev, int enable )
 {
        int oldenab = dev->keep_mgmt;
+
        dev->keep_mgmt = enable;
        return oldenab;
 }
 
-struct io_buffer *net80211_mgmt_dequeue(struct net80211_device *dev,
-                                       int *signal)
+struct io_buffer * net80211_mgmt_dequeue ( struct net80211_device *dev,
+                                          int *signal )
 {
        struct io_buffer *iobuf;
        struct net80211_rx_info *rxi;
 
-       list_for_each_entry(rxi, &dev->mgmt_info_queue, list) {
-               list_del(&rxi->list);
-               if (signal)
+       list_for_each_entry ( rxi, &dev->mgmt_info_queue, list ) {
+               list_del ( &rxi->list );
+               if ( signal )
                        *signal = rxi->signal;
                break;
        }
-       list_for_each_entry(iobuf, &dev->mgmt_queue, list) {
-               list_del(&iobuf->list);
+
+       list_for_each_entry ( iobuf, &dev->mgmt_queue, list ) {
+               list_del ( &iobuf->list );
                return iobuf;
        }
        return NULL;
 }
 
-int net80211_tx_mgmt(struct net80211_device *dev, u16 fc, u8 dest[6],
-                    struct io_buffer *iob) 
+int net80211_tx_mgmt ( struct net80211_device *dev, u16 fc, u8 dest[6],
+                      struct io_buffer *iob )
 {
-       struct ieee80211_frame *hdr = iob_push(iob,
-                                              IEEE80211_TYP_FRAME_HEADER_LEN);
-       
+       struct ieee80211_frame *hdr = iob_push ( iob,
+                                                IEEE80211_TYP_FRAME_HEADER_LEN );
+
        hdr->fc = IEEE80211_THIS_VERSION | IEEE80211_TYPE_MGMT |
-                 (fc & ~IEEE80211_FC_PROTECTED);
-       hdr->duration = net80211_duration(dev, 10);
+           ( fc & ~IEEE80211_FC_PROTECTED );
+       hdr->duration = net80211_duration ( dev, 10 );
        hdr->seq = ++dev->last_tx_seqnr & 0x0FFF;
 
-       memcpy(hdr->addr1, dest, ETH_ALEN); /* DA = RA */
-       memcpy(hdr->addr2, dev->netdev->ll_addr, ETH_ALEN); /* SA = TA */
-       memcpy(hdr->addr3, dest, ETH_ALEN); /* BSSID */
+       memcpy ( hdr->addr1, dest, ETH_ALEN );  /* DA = RA */
+       memcpy ( hdr->addr2, dev->netdev->ll_addr, ETH_ALEN );  /* SA = TA */
+       memcpy ( hdr->addr3, dest, ETH_ALEN );  /* BSSID */
 
-       if (fc & IEEE80211_FC_PROTECTED) {
-               if (!dev->crypto)
+       if ( fc & IEEE80211_FC_PROTECTED ) {
+               if ( ! dev->crypto )
                        return -EINVAL;
-               
-               struct io_buffer *eiob = dev->crypto->encrypt(dev, iob);
-               free_iob(iob);
+
+               struct io_buffer *eiob = dev->crypto->encrypt ( dev, iob );
+               free_iob ( iob );
                iob = eiob;
        }
 
-       return netdev_tx(dev->netdev, iob);
+       return netdev_tx ( dev->netdev, iob );
 }
 
 
 /* ---------- driver API ---------- */
 
-struct net80211_device *net80211_alloc(size_t priv_size) 
+struct net80211_device * net80211_alloc ( size_t priv_size )
 {
        struct net80211_device *dev;
-       struct net_device *netdev = alloc_netdev(sizeof(*dev) + priv_size);
+       struct net_device *netdev =
+               alloc_netdev ( sizeof ( *dev ) + priv_size );
 
-       if (!netdev)
+       if ( ! netdev )
                return NULL;
 
        netdev->ll_protocol = &net80211_ll_protocol;
        netdev->max_pkt_len = IEEE80211_MAX_DATA_LEN;
-       netdev_init(netdev, &net80211_netdev_ops);
+       netdev_init ( netdev, &net80211_netdev_ops );
 
        dev = netdev->priv;
        dev->netdev = netdev;
-       dev->priv = (u8 *)dev + sizeof(*dev);
+       dev->priv = ( u8 * ) dev + sizeof ( *dev );
        dev->op = &net80211_null_ops;
        dev->last_rx_seq = -1;
 
        dev->proc_assoc.step = net80211_step_associate;
-       INIT_LIST_HEAD(&dev->mgmt_queue);
+       INIT_LIST_HEAD ( &dev->mgmt_queue );
 
        return dev;
 }
 
-int net80211_register(struct net80211_device *dev,
-                     struct net80211_device_operations *ops,
-                     struct net80211_hw_info *hw) 
+int net80211_register ( struct net80211_device *dev,
+                       struct net80211_device_operations *ops,
+                       struct net80211_hw_info *hw )
 {
        dev->op = ops;
-       dev->hw = malloc(sizeof(*hw));
-       if (!dev->hw)
+       dev->hw = malloc ( sizeof ( *hw ) );
+       if ( ! dev->hw )
                return -ENOMEM;
 
-       memcpy(dev->hw, hw, sizeof(*hw));
-       memcpy(dev->netdev->ll_addr, hw->hwaddr, ETH_ALEN);
-       
-       list_add_tail(&dev->list, &net80211_devices);
-       return register_netdev(dev->netdev);
+       memcpy ( dev->hw, hw, sizeof ( *hw ) );
+       memcpy ( dev->netdev->ll_addr, hw->hwaddr, ETH_ALEN );
+
+       list_add_tail ( &dev->list, &net80211_devices );
+       return register_netdev ( dev->netdev );
 }
 
-void net80211_unregister(struct net80211_device *dev) 
+void net80211_unregister ( struct net80211_device *dev )
 {
-       unregister_netdev(dev->netdev);
-       list_del(&dev->list);
+       unregister_netdev ( dev->netdev );
+       list_del ( &dev->list );
        dev->op = &net80211_null_ops;
 }
 
-void net80211_free(struct net80211_device *dev) 
+void net80211_free ( struct net80211_device *dev )
 {
-       free(dev->hw);
-       netdev_nullify(dev->netdev);
-       netdev_put(dev->netdev);
+       free ( dev->hw );
+       netdev_nullify ( dev->netdev );
+       netdev_put ( dev->netdev );
 }
 
 /* ---------- 802.11 network management workhorse code ---------- */
@@ -401,47 +407,49 @@ void net80211_free(struct net80211_device *dev)
    when association is cleared, but not set when association is set -
    that's left to the association task to do after it checks
    everything's OK. */
-static inline void net80211_set_state(struct net80211_device *dev,
-                                     short clear, short set, u16 status) 
+static inline void net80211_set_state ( struct net80211_device *dev,
+                                       short clear, short set,
+                                       u16 status )
 {
        /* The conditions in this function are deliberately formulated
           to be decidable at compile-time. */
 
-       if (clear & NET80211_AUTHENTICATED)
+       if ( clear & NET80211_AUTHENTICATED )
                clear |= NET80211_ASSOCIATED;
-       if (clear & NET80211_ASSOCIATED)
+       if ( clear & NET80211_ASSOCIATED )
                clear |= NET80211_CRYPTO_SYNCED;
 
-       dev->state = (dev->state & ~clear) | set;
-       dev->state = (dev->state & ~NET80211_STATUS_MASK) |
-               (status & NET80211_STATUS_MASK);
+       dev->state = ( dev->state & ~clear ) | set;
+       dev->state = ( dev->state & ~NET80211_STATUS_MASK ) |
+               ( status & NET80211_STATUS_MASK );
 
-       if (clear & NET80211_ASSOCIATED)
+       if ( clear & NET80211_ASSOCIATED )
                dev->netdev->state &= ~NETDEV_LINK_UP;
 
-       if ((clear | set) & NET80211_ASSOCIATED)
-               dev->op->config(dev, NET80211_CFG_ASSOC);
+       if ( ( clear | set ) & NET80211_ASSOCIATED )
+               dev->op->config ( dev, NET80211_CFG_ASSOC );
 }
 
-static void net80211_add_channels(struct net80211_device *dev, int start,
-                                 int len, int txpower) 
+static void net80211_add_channels ( struct net80211_device *dev, int start,
+                                   int len, int txpower )
 {
        int i, chan = start;
 
-       for (i = dev->nr_channels; len-- && i < NET80211_MAX_CHANNELS; i++) {
+       for ( i = dev->nr_channels; len-- && i < NET80211_MAX_CHANNELS;
+             i++ ) {
                dev->channels[i].channel_nr = chan;
                dev->channels[i].maxpower = txpower;
 
-               if (chan >= 1 && chan <= 14) {
+               if ( chan >= 1 && chan <= 14 ) {
                        dev->channels[i].band = NET80211_BAND_2GHZ;
-                       if (chan == 14)
+                       if ( chan == 14 )
                                dev->channels[i].center_freq = 2484;
                        else
-                               dev->channels[i].center_freq = 2407 + 5*chan;
+                               dev->channels[i].center_freq = 2407 + 5 * chan;
                        chan++;
                } else {
                        dev->channels[i].band = NET80211_BAND_5GHZ;
-                       dev->channels[i].center_freq = 5000 + 5*chan;
+                       dev->channels[i].center_freq = 5000 + 5 * chan;
                        chan += 4;
                }
        }
@@ -449,81 +457,86 @@ static void net80211_add_channels(struct net80211_device *dev, int start,
        dev->nr_channels = i;
 }
 
-static int net80211_process_capab(struct net80211_device *dev, u16 capab)
+static int net80211_process_capab ( struct net80211_device *dev,
+                                   u16 capab )
 {
        u16 old_erp = dev->erp_flags;
 
-       if ((capab & (IEEE80211_CAPAB_MANAGED | IEEE80211_CAPAB_ADHOC)) !=
-           IEEE80211_CAPAB_MANAGED) {
-               DBG("802.11 cannot handle IBSS network\n");
+       if ( ( capab & ( IEEE80211_CAPAB_MANAGED | IEEE80211_CAPAB_ADHOC ) ) !=
+            IEEE80211_CAPAB_MANAGED ) {
+               DBG ( "802.11 cannot handle IBSS network\n" );
                return -ENOSYS;
        }
 
-       if (capab & IEEE80211_CAPAB_SPECTRUM_MGMT) {
-               DBG("802.11 cannot handle spectrum managed network\n");
+       if ( capab & IEEE80211_CAPAB_SPECTRUM_MGMT ) {
+               DBG ( "802.11 cannot handle spectrum managed network\n" );
                return -ENOSYS;
        }
 
-       dev->erp_flags &= ~(NET80211_ERP_USE_SHORT_PREAMBLE |
-                           NET80211_ERP_USE_SHORT_SLOT);
+       dev->erp_flags &= ~( NET80211_ERP_USE_SHORT_PREAMBLE |
+                            NET80211_ERP_USE_SHORT_SLOT );
 
-       if (capab & IEEE80211_CAPAB_SHORT_PMBL)
+       if ( capab & IEEE80211_CAPAB_SHORT_PMBL )
                dev->erp_flags |= NET80211_ERP_USE_SHORT_PREAMBLE;
 
-       if (capab & IEEE80211_CAPAB_SHORT_SLOT)
+       if ( capab & IEEE80211_CAPAB_SHORT_SLOT )
                dev->erp_flags |= NET80211_ERP_USE_SHORT_SLOT;
 
-       if (old_erp != dev->erp_flags)
-               dev->op->config(dev, NET80211_CFG_ERP_PARAMS);
+       if ( old_erp != dev->erp_flags )
+               dev->op->config ( dev, NET80211_CFG_ERP_PARAMS );
 
        return 0;
 }
 
-static int net80211_process_ie(struct net80211_device *dev,
-                              struct ieee80211_ie *ie, int len)
+static int net80211_process_ie ( struct net80211_device *dev,
+                                struct ieee80211_ie *ie, int len )
 {
-       void *ie_byte = (u8 *)ie;
+       void *ie_byte = ie;
        void *ie_byte_end = ie_byte + len;
-       u16 old_rate = NET80211_RATE_VALUE(dev->rates[dev->rate]);
+       u16 old_rate = NET80211_RATE_VALUE ( dev->rates[dev->rate] );
        u16 old_erp = dev->erp_flags;
        int have_rates = 0, i;
        int ds_channel = 0;
        int changed = 0;
 
-       for (ie = ie_byte; ie_byte < ie_byte_end;
-            ie_byte += ie->len + 2, ie = ie_byte) {
-               switch (ie->id) {
+       for ( ie = ie_byte; ie_byte < ie_byte_end;
+             ie_byte += ie->len + 2, ie = ie_byte ) {
+               switch ( ie->id ) {
                case IEEE80211_IE_SSID:
-                       if (ie->len <= 32) {
-                               memcpy(dev->essid, ie->ssid, ie->len);
+                       if ( ie->len <= 32 ) {
+                               memcpy ( dev->essid, ie->ssid, ie->len );
                                dev->essid[ie->len] = 0;
                        }
                        break;
 
                case IEEE80211_IE_RATES:
                case IEEE80211_IE_EXT_RATES:
-                       if (!have_rates) {
+                       if ( ! have_rates ) {
                                dev->nr_rates = 0;
                                dev->basic_rates = 0;
                                have_rates = 1;
                        }
-                       for (i = 0; i < ie->len &&
-                                    dev->nr_rates < NET80211_MAX_RATES; i++) {
+                       for ( i = 0; i < ie->len &&
+                             dev->nr_rates < NET80211_MAX_RATES; i++ ) {
                                u8 rid = ie->rates[i];
-                               u16 rate = (rid & 0x7f) * 5;
-                               if (rid & 0x80)
-                                       dev->basic_rates |= (1 << dev->nr_rates);
-                               if (rate != 10 && rate != 20 && rate != 55 &&
-                                   rate != 110) /* 802.11b rates */
+                               u16 rate = ( rid & 0x7f ) * 5;
+
+                               if ( rid & 0x80 )
+                                       dev->basic_rates |=
+                                               ( 1 << dev->nr_rates );
+
+                               if ( rate != 10 && rate != 20 && rate != 55 &&
+                                    rate != 110 )      /* 802.11b rates */
                                        rate |= NET80211_RATE_ERP;
+
                                dev->rates[dev->nr_rates++] = rate;
                        }
-                       
+
                        break;
 
                case IEEE80211_IE_DS_PARAM:
-                       if (dev->channel < dev->nr_channels &&
-                           dev->channels[dev->channel].channel_nr == ds_channel)
+                       if ( dev->channel < dev->nr_channels && ds_channel ==
+                            dev->channels[dev->channel].channel_nr )
                                break;
                        ds_channel = ie->ds_param.current_channel;
                        changed |= NET80211_CFG_CHANNEL;
@@ -532,94 +545,97 @@ static int net80211_process_ie(struct net80211_device *dev,
                case IEEE80211_IE_COUNTRY:
                        dev->nr_channels = 0;
 
-                       DBG("802.11 setting country regulations for %c%c\n",
-                           ie->country.name[0], ie->country.name[1]);
-                       for (i = 0; i < (ie->len - 3) / 3; i++) {
-                               if (ie->country.triplet[i].ext.reg_ext_id > 200) {
-                                       DBG("802.11 don't know how to parse "
-                                           "regulatory extension information\n");
+                       DBG ( "802.11 setting country regulations for %c%c\n",
+                             ie->country.name[0], ie->country.name[1] );
+                       for ( i = 0; i < ( ie->len - 3 ) / 3; i++ ) {
+                               if ( ie->country.triplet[i].ext.
+                                    reg_ext_id > 200 ) {
+                                       DBG ( "802.11 don't know how to parse "
+                                             "regulatory extension information\n" );
                                } else {
-                                       net80211_add_channels(dev,
+                                       net80211_add_channels ( dev,
                                          ie->country.triplet[i].band.first_channel,
                                          ie->country.triplet[i].band.nr_channels,
-                                         ie->country.triplet[i].band.max_txpower);
+                                         ie->country.triplet[i].band.max_txpower );
                                }
                        }
                        break;
-                       
+
                case IEEE80211_IE_ERP_INFO:
-                       dev->erp_flags &= ~(NET80211_ERP_USE_PROTECTION |
-                                           NET80211_ERP_USE_SHORT_PREAMBLE);
-                       if (ie->erp_info & IEEE80211_ERP_USE_PROTECTION)
+                       dev->erp_flags &= ~( NET80211_ERP_USE_PROTECTION |
+                                            NET80211_ERP_USE_SHORT_PREAMBLE );
+                       if ( ie->erp_info & IEEE80211_ERP_USE_PROTECTION )
                                dev->erp_flags |= NET80211_ERP_USE_PROTECTION;
-                       if (!(ie->erp_info & IEEE80211_ERP_BARKER_LONG))
+                       if ( ! ( ie->erp_info & IEEE80211_ERP_BARKER_LONG ) )
                                dev->erp_flags |= NET80211_ERP_USE_SHORT_PREAMBLE;
                        break;
-                       
+
                case IEEE80211_IE_RSN:
                        /* XXX need to implement WPA stuff */
                        break;
                }
        }
 
-       if (have_rates) {
+       if ( have_rates ) {
                /* Allow only those rates that are also supported by
                   the hardware. */
                int delta = 0, j;
 
                dev->rate = 0;
-               for (i = 0; i < dev->nr_rates; i++) {
+               for ( i = 0; i < dev->nr_rates; i++ ) {
                        int ok = 0;
-                       for (j = 0; j < dev->hw->nr_supported_rates; j++) {
-                               if (dev->hw->supported_rates[i] ==
-                                   dev->rates[i]) {                                    
+                       for ( j = 0; j < dev->hw->nr_supported_rates; j++ ) {
+                               if ( dev->hw->supported_rates[i] ==
+                                    dev->rates[i] ) {
                                        ok = 1;
                                        break;
                                }
                        }
 
-                       if (!ok)
+                       if ( ! ok )
                                delta++;
                        else {
                                dev->rates[i - delta] = dev->rates[i];
-                               if (old_rate == dev->rates[i])
+                               if ( old_rate == dev->rates[i] )
                                        dev->rate = i - delta;
                        }
                }
 
                dev->nr_rates -= delta;
 
-               if (dev->rates[dev->rate] != old_rate)
+               if ( dev->rates[dev->rate] != old_rate )
                        changed |= NET80211_CFG_RATE;
        }
 
-       if (ds_channel) {
-               for (i = 0; i < dev->nr_channels; i++) {
-                       if (dev->channels[i].channel_nr == ds_channel) {
+       if ( ds_channel ) {
+               for ( i = 0; i < dev->nr_channels; i++ ) {
+                       if ( dev->channels[i].channel_nr == ds_channel ) {
                                dev->channel = i;
                                break;
                        }
                }
        }
 
-       if (dev->hw->flags & NET80211_HW_NO_SHORT_PREAMBLE)
+       if ( dev->hw->flags & NET80211_HW_NO_SHORT_PREAMBLE )
                dev->erp_flags &= ~NET80211_ERP_USE_SHORT_PREAMBLE;
-       if (dev->hw->flags & NET80211_HW_NO_SHORT_SLOT)
+       if ( dev->hw->flags & NET80211_HW_NO_SHORT_SLOT )
                dev->erp_flags &= ~NET80211_ERP_USE_SHORT_SLOT;
 
-       if (old_erp != dev->erp_flags)
+       if ( old_erp != dev->erp_flags )
                changed |= NET80211_CFG_ERP_PARAMS;
 
-       if (changed)
-               dev->op->config(dev, changed);
+       if ( changed )
+               dev->op->config ( dev, changed );
 
        return 0;
 }
 
-struct net80211_wlan *net80211_probe(struct net80211_device *dev,
-                                    const char *essid, int active) 
+struct net80211_wlan *net80211_probe ( struct net80211_device *dev,
+                                      const char *essid, int active )
 {
-       (void)dev; (void)essid; (void)active;
+       ( void ) dev;
+       ( void ) essid;
+       ( void ) active;
        return NULL;
 }
 
@@ -632,7 +648,7 @@ void net80211_free_wlan ( struct net80211_wlan *wlan )
 void net80211_step_associate ( struct process *proc )
 {
        struct net80211_device *dev =
-               container_of ( proc, struct net80211_device, proc_assoc );
+           container_of ( proc, struct net80211_device, proc_assoc );
        int rc = 0;
        int status = dev->state & NET80211_STATUS_MASK;
 
@@ -656,7 +672,8 @@ void net80211_step_associate ( struct process *proc )
                if ( ! dev->associating )
                        goto fail;
 
-               DBG ( "802.11 found network %s (%s)\n", dev->associating->essid,
+               DBG ( "802.11 found network %s (%s)\n",
+                     dev->associating->essid,
                      eth_ntoa ( dev->associating->bssid ) );
 
                dev->associating->method = IEEE80211_AUTH_OPEN_SYSTEM;
@@ -696,7 +713,7 @@ void net80211_step_associate ( struct process *proc )
 
        if ( ! ( dev->state & NET80211_ASSOCIATED ) ) {
                /* state: associate */
-               DBG ( "802.11 associating\n");
+               DBG ( "802.11 associating\n" );
 
                if ( status != IEEE80211_STATUS_SUCCESS )
                        goto fail;
@@ -747,134 +764,145 @@ void net80211_autoassociate ( struct net80211_device *dev )
        dev->associating = NULL;
 }
 
-int net80211_prepare_default(struct net80211_device *dev, int band, int active)
+int net80211_prepare_default ( struct net80211_device *dev, int band,
+                              int active )
 {
-       if (active && band != NET80211_BAND_2GHZ) {
-               DBG("802.11 cannot perform active scanning on 5GHz band\n");
+       if ( active && band != NET80211_BAND_2GHZ ) {
+               DBG ( "802.11 cannot perform active scanning on 5GHz band\n" );
                return -EINVAL;
        }
 
        dev->nr_channels = 0;
 
-       if (active)
-               net80211_add_channels(dev, 1, 11, NET80211_REG_TXPOWER);
+       if ( active )
+               net80211_add_channels ( dev, 1, 11, NET80211_REG_TXPOWER );
        else {
-               if (band & NET80211_BAND_2GHZ)
-                       net80211_add_channels(dev, 1, 14, NET80211_REG_TXPOWER);
-               if (band & NET80211_BAND_5GHZ)
-                       net80211_add_channels(dev, 36, 8, NET80211_REG_TXPOWER);
+               if ( band & NET80211_BAND_2GHZ )
+                       net80211_add_channels ( dev, 1, 14,
+                                               NET80211_REG_TXPOWER );
+               if ( band & NET80211_BAND_5GHZ )
+                       net80211_add_channels ( dev, 36, 8,
+                                               NET80211_REG_TXPOWER );
        }
 
        dev->channel = 0;
-       dev->op->config(dev, NET80211_CFG_CHANNEL);
+       dev->op->config ( dev, NET80211_CFG_CHANNEL );
        return 0;
 }
 
-int net80211_prepare(struct net80211_device *dev, struct net80211_wlan *wlan)
+int net80211_prepare ( struct net80211_device *dev,
+                      struct net80211_wlan *wlan )
 {
        struct ieee80211_frame *hdr = wlan->beacon->data;
-       struct ieee80211_beacon *beacon = (struct ieee80211_beacon *)hdr->data;
+       struct ieee80211_beacon *beacon =
+               ( struct ieee80211_beacon * ) hdr->data;
        int rc;
 
-       net80211_set_state(dev, NET80211_ASSOCIATED, 0, 0);
-       memcpy(dev->bssid, wlan->bssid, ETH_ALEN);
-       strcpy(dev->essid, wlan->essid);
+       net80211_set_state ( dev, NET80211_ASSOCIATED, 0, 0 );
+       memcpy ( dev->bssid, wlan->bssid, ETH_ALEN );
+       strcpy ( dev->essid, wlan->essid );
 
        /* do crypto setup here */
-       
-       rc = net80211_process_capab(dev, beacon->capability);
-       if (rc)
+
+       rc = net80211_process_capab ( dev, beacon->capability );
+       if ( rc )
                return rc;
 
-       rc = net80211_process_ie(dev, beacon->info_element,
-                                iob_len(wlan->beacon) - sizeof(*hdr));
-       if (rc)
+       rc = net80211_process_ie ( dev, beacon->info_element,
+                                  iob_len ( wlan->beacon ) -
+                                  sizeof ( *hdr ) );
+       if ( rc )
                return rc;
 
        return 0;
 }
 
-int net80211_send_auth(struct net80211_device *dev, struct net80211_wlan *wlan,
-                      int method) 
+int net80211_send_auth ( struct net80211_device *dev,
+                        struct net80211_wlan *wlan, int method )
 {
-       struct io_buffer *iob = alloc_iob(64);
+       struct io_buffer *iob = alloc_iob ( 64 );
        struct ieee80211_auth *auth;
 
-       iob_reserve(iob, IEEE80211_TYP_FRAME_HEADER_LEN);
+       iob_reserve ( iob, IEEE80211_TYP_FRAME_HEADER_LEN );
        auth = iob->data;
        auth->algorithm = method;
        auth->tx_seq = 1;
        auth->status = 0;
 
-       return net80211_tx_mgmt(dev, IEEE80211_STYPE_AUTH, wlan->bssid, iob);
+       return net80211_tx_mgmt ( dev, IEEE80211_STYPE_AUTH, wlan->bssid, iob );
 }
 
-static void net80211_handle_auth(struct net80211_device *dev,
-                                struct io_buffer *iob) 
+static void net80211_handle_auth ( struct net80211_device *dev,
+                                  struct io_buffer *iob )
 {
        struct ieee80211_frame *hdr = iob->data;
-       struct ieee80211_auth *auth = (struct ieee80211_auth *)hdr->data;
-
-       if (auth->tx_seq & 1) {
-               DBG("%s: 802.11 authentication received improperly directed "
-                   "frame (sequence %d)\n", dev->netdev->name, auth->tx_seq);
-               net80211_set_state(dev, NET80211_WAITING, 0,
-                                  IEEE80211_STATUS_FAILURE);
+       struct ieee80211_auth *auth =
+           ( struct ieee80211_auth * ) hdr->data;
+
+       if ( auth->tx_seq & 1 ) {
+               DBG ( "%s: 802.11 authentication received improperly directed "
+                     "frame (seq. %d)\n", dev->netdev->name, auth->tx_seq );
+               net80211_set_state ( dev, NET80211_WAITING, 0,
+                                    IEEE80211_STATUS_FAILURE );
                return;
        }
 
-       if (auth->status != IEEE80211_STATUS_SUCCESS) {
-               DBG("%s: 802.11 authentication failed: status %d\n",
-                   dev->netdev->name, auth->status);
-               net80211_set_state(dev, NET80211_WAITING, 0, auth->status);
+       if ( auth->status != IEEE80211_STATUS_SUCCESS ) {
+               DBG ( "%s: 802.11 authentication failed: status %d\n",
+                     dev->netdev->name, auth->status );
+               net80211_set_state ( dev, NET80211_WAITING, 0,
+                                    auth->status );
                return;
        }
 
-       if (auth->algorithm == IEEE80211_AUTH_SHARED_KEY && !dev->crypto) {
-               DBG("%s: 802.11 can't perform shared-key authentication without "
-                   "a cryptosystem\n", dev->netdev->name);
-               net80211_set_state(dev, NET80211_WAITING, 0,
-                                  IEEE80211_STATUS_FAILURE);
+       if ( auth->algorithm == IEEE80211_AUTH_SHARED_KEY && ! dev->crypto ) {
+               DBG ( "%s: 802.11 can't perform shared-key authentication without "
+                     "a cryptosystem\n", dev->netdev->name );
+               net80211_set_state ( dev, NET80211_WAITING, 0,
+                                    IEEE80211_STATUS_FAILURE );
                return;
        }
 
-       if (auth->algorithm == IEEE80211_AUTH_SHARED_KEY && auth->tx_seq == 2) {
+       if ( auth->algorithm == IEEE80211_AUTH_SHARED_KEY &&
+            auth->tx_seq == 2 ) {
                /* Since the iob we got is going to be freed as soon
                   as we return, we can do some in-place
                   modification. */
                auth->tx_seq = 3;
                auth->status = 0;
 
-               memcpy(hdr->addr2, hdr->addr1, ETH_ALEN);
-               memcpy(hdr->addr1, hdr->addr3, ETH_ALEN);
+               memcpy ( hdr->addr2, hdr->addr1, ETH_ALEN );
+               memcpy ( hdr->addr1, hdr->addr3, ETH_ALEN );
 
-               netdev_tx(dev->netdev, dev->crypto->encrypt(dev, iob));
+               netdev_tx ( dev->netdev,
+                           dev->crypto->encrypt ( dev, iob ) );
                return;
        }
 
-       net80211_set_state(dev, NET80211_WAITING, NET80211_AUTHENTICATED,
-                          IEEE80211_STATUS_SUCCESS);
+       net80211_set_state ( dev, NET80211_WAITING, NET80211_AUTHENTICATED,
+                            IEEE80211_STATUS_SUCCESS );
 
        return;
 }
 
-int net80211_send_assoc(struct net80211_device *dev, struct net80211_wlan *wlan)
+int net80211_send_assoc ( struct net80211_device *dev,
+                         struct net80211_wlan *wlan )
 {
-       struct io_buffer *iob = alloc_iob(128);
+       struct io_buffer *iob = alloc_iob ( 128 );
        struct ieee80211_assoc_req *assoc;
        struct ieee80211_ie *ie;
        void *ie_byte;
        int i;
 
-       iob_reserve(iob, IEEE80211_TYP_FRAME_HEADER_LEN);
+       iob_reserve ( iob, IEEE80211_TYP_FRAME_HEADER_LEN );
        assoc = iob->data;
 
        assoc->capability = IEEE80211_CAPAB_MANAGED;
-       if (!(dev->hw->flags & NET80211_HW_NO_SHORT_PREAMBLE))
+       if ( ! ( dev->hw->flags & NET80211_HW_NO_SHORT_PREAMBLE ) )
                assoc->capability |= IEEE80211_CAPAB_SHORT_PMBL;
-       if (!(dev->hw->flags & NET80211_HW_NO_SHORT_SLOT))
+       if ( ! ( dev->hw->flags & NET80211_HW_NO_SHORT_SLOT ) )
                assoc->capability |= IEEE80211_CAPAB_SHORT_SLOT;
-       if (wlan->security)
+       if ( wlan->security )
                assoc->capability |= IEEE80211_CAPAB_PRIVACY;
 
        assoc->listen_interval = 1;
@@ -883,27 +911,27 @@ int net80211_send_assoc(struct net80211_device *dev, struct net80211_wlan *wlan)
        ie_byte = ie;
 
        ie->id = IEEE80211_IE_SSID;
-       ie->len = strlen(wlan->essid);
-       strcpy(ie->ssid, wlan->essid);
+       ie->len = strlen ( wlan->essid );
+       strcpy ( ie->ssid, wlan->essid );
 
        ie_byte += ie->len;
        ie = ie_byte;
 
        ie->id = IEEE80211_IE_RATES;
        ie->len = dev->hw->nr_supported_rates;
-       if (ie->len > 8)
+       if ( ie->len > 8 )
                ie->len = 8;
-       for (i = 0; i < ie->len; i++) {
+       for ( i = 0; i < ie->len; i++ ) {
                ie->rates[i] = dev->hw->supported_rates[i] / 5;
        }
 
        ie_byte += ie->len;
        ie = ie_byte;
 
-       if (i < dev->hw->nr_supported_rates) {
+       if ( i < dev->hw->nr_supported_rates ) {
                ie->id = IEEE80211_IE_EXT_RATES;
                ie->len = dev->hw->nr_supported_rates - i;
-               for (; i < ie->len; i++) {
+               for ( ; i < ie->len; i++ ) {
                        ie->rates[i - 8] = dev->hw->supported_rates[i] / 5;
                }
 
@@ -913,70 +941,71 @@ int net80211_send_assoc(struct net80211_device *dev, struct net80211_wlan *wlan)
 
        /* XXX add RSN ie for WPA support */
 
-       return net80211_tx_mgmt(dev, IEEE80211_STYPE_ASSOC_REQ, wlan->bssid,
-                               iob);
+       return net80211_tx_mgmt ( dev, IEEE80211_STYPE_ASSOC_REQ,
+                                 wlan->bssid, iob );
 }
 
-static void net80211_handle_assoc_reply(struct net80211_device *dev,
-                                       struct io_buffer *iob) 
+static void net80211_handle_assoc_reply ( struct net80211_device *dev,
+                                         struct io_buffer *iob )
 {
        struct ieee80211_frame *hdr = iob->data;
        struct ieee80211_assoc_resp *assoc =
-               (struct ieee80211_assoc_resp *)hdr->data;
+               ( struct ieee80211_assoc_resp * ) hdr->data;
 
-       net80211_process_capab(dev, assoc->capability);
-       net80211_process_ie(dev, assoc->info_element,
-                           iob_len(iob) - sizeof(*hdr));
+       net80211_process_capab ( dev, assoc->capability );
+       net80211_process_ie ( dev, assoc->info_element,
+                             iob_len ( iob ) - sizeof ( *hdr ) );
 
-       if (assoc->status != IEEE80211_STATUS_SUCCESS) {
-               DBG("%s: 802.11 association failed: status %d\n",
-                   dev->netdev->name, assoc->status);
-               net80211_set_state(dev, NET80211_WAITING, 0, assoc->status);
+       if ( assoc->status != IEEE80211_STATUS_SUCCESS ) {
+               DBG ( "%s: 802.11 association failed: status %d\n",
+                     dev->netdev->name, assoc->status );
+               net80211_set_state ( dev, NET80211_WAITING, 0,
+                                    assoc->status );
                return;
        }
 
        /* ESSID was filled before the association request was sent */
-       memcpy(dev->bssid, hdr->addr3, ETH_ALEN);
+       memcpy ( dev->bssid, hdr->addr3, ETH_ALEN );
        dev->aid = assoc->aid;
 
-       net80211_set_state(dev, NET80211_WAITING, NET80211_ASSOCIATED,
-                          IEEE80211_STATUS_SUCCESS);
+       net80211_set_state ( dev, NET80211_WAITING, NET80211_ASSOCIATED,
+                            IEEE80211_STATUS_SUCCESS );
 }
 
-static void net80211_handle_mgmt(struct net80211_device *dev,
-                                struct io_buffer *iob, int signal) 
+static void net80211_handle_mgmt ( struct net80211_device *dev,
+                                  struct io_buffer *iob, int signal )
 {
        struct ieee80211_frame *hdr = iob->data;
        u16 stype = hdr->fc & IEEE80211_FC_SUBTYPE;
        int keep = 0;
 
-       if ((hdr->fc & IEEE80211_FC_TYPE) != IEEE80211_TYPE_MGMT) {
-               free_iob(iob);
+       if ( ( hdr->fc & IEEE80211_FC_TYPE ) != IEEE80211_TYPE_MGMT ) {
+               free_iob ( iob );
                return;         /* only handle management frames */
        }
 
-       switch (stype) {
+       switch ( stype ) {
        case IEEE80211_STYPE_DEAUTH:
-               net80211_set_state(dev, NET80211_AUTHENTICATED, 0, 0);
-               DBG("%s: 802.11 deauthenticated\n", dev->netdev->name);
-               net80211_autoassociate(dev);
+               net80211_set_state ( dev, NET80211_AUTHENTICATED, 0, 0 );
+               DBG ( "%s: 802.11 deauthenticated\n", dev->netdev->name );
+               net80211_autoassociate ( dev );
                break;
        case IEEE80211_STYPE_DISASSOC:
-               net80211_set_state(dev, NET80211_ASSOCIATED, 0, 0);
-               DBG("%s: 802.11 disassociated\n", dev->netdev->name);
-               net80211_autoassociate(dev);
+               net80211_set_state ( dev, NET80211_ASSOCIATED, 0, 0 );
+               DBG ( "%s: 802.11 disassociated\n", dev->netdev->name );
+               net80211_autoassociate ( dev );
                break;
 
                /* We handle authentication and association. */
        case IEEE80211_STYPE_AUTH:
-               if (!(dev->state & NET80211_AUTHENTICATED))
-                       net80211_handle_auth(dev, iob);
+               if ( ! ( dev->state & NET80211_AUTHENTICATED ) )
+                       net80211_handle_auth ( dev, iob );
                break;
 
        case IEEE80211_STYPE_ASSOC_RESP:
        case IEEE80211_STYPE_REASSOC_RESP:
-               if (!(dev->state & NET80211_ASSOCIATED))
-                       net80211_handle_assoc_reply(dev, iob);
+               if ( ! ( dev->state & NET80211_ASSOCIATED ) )
+                       net80211_handle_assoc_reply ( dev, iob );
                break;
 
                /* We pass probes and beacons onto network scanning
@@ -984,16 +1013,17 @@ static void net80211_handle_mgmt(struct net80211_device *dev,
        case IEEE80211_STYPE_PROBE_RESP:
        case IEEE80211_STYPE_BEACON:
        case IEEE80211_STYPE_ACTION:
-               if (dev->keep_mgmt) {
+               if ( dev->keep_mgmt ) {
                        struct net80211_rx_info *rxinf;
-                       rxinf = zalloc(sizeof(*rxinf));
-                       if (!rxinf) {
-                               DBG("No memory for rxinf structure\n");
+                       rxinf = zalloc ( sizeof ( *rxinf ) );
+                       if ( ! rxinf ) {
+                               DBG ( "No memory for rxinf structure\n" );
                                break;
                        }
                        rxinf->signal = signal;
-                       list_add_tail(&iob->list, &dev->mgmt_queue);
-                       list_add_tail(&rxinf->list, &dev->mgmt_info_queue);
+                       list_add_tail ( &iob->list, &dev->mgmt_queue );
+                       list_add_tail ( &rxinf->list,
+                                       &dev->mgmt_info_queue );
                        keep = 1;
                }
                break;
@@ -1002,28 +1032,29 @@ static void net80211_handle_mgmt(struct net80211_device *dev,
        case IEEE80211_STYPE_REASSOC_REQ:
        case IEEE80211_STYPE_PROBE_REQ:
                /* We should never receive these, only send them. */
-               DBG("Received strange management request (%04x)\n", stype);
+               DBG ( "Received strange management request (%04x)\n", stype );
                break;
        default:
-               DBG("Received unimplemented management packet (%04x)\n", stype);
+               DBG ( "Received unimplemented management packet (%04x)\n",
+                     stype );
                break;
        }
 
-       if (!keep)
-               free_iob(iob);
+       if ( ! keep )
+               free_iob ( iob );
 }
 
 /* ---------- Packet handling functions ---------- */
 
 /* Free the iob's for frag cache entry fcid and mark it unused. */
-static void net80211_free_frags(struct net80211_device *dev, int fcid) 
+static void net80211_free_frags ( struct net80211_device *dev, int fcid )
 {
        int j;
        struct net80211_frag_cache *frag = &dev->frags[fcid];
 
-       for (j = 0; j < 16; j++) {
-               if (frag->iob[j]) {
-                       free_iob(frag->iob[j]);
+       for ( j = 0; j < 16; j++ ) {
+               if ( frag->iob[j] ) {
+                       free_iob ( frag->iob[j] );
                        frag->iob[j] = NULL;
                }
        }
@@ -1036,25 +1067,26 @@ static void net80211_free_frags(struct net80211_device *dev, int fcid)
 
 /* Accumulate fragments from frag cache entry fcid, of total size
    `size' (headers included), into one iob and return it. */
-static struct io_buffer *net80211_accum_frags(struct net80211_device *dev,
-                                             int fcid, int size)
+static struct io_buffer *net80211_accum_frags ( struct net80211_device
+                                               *dev, int fcid, int size )
 {
        struct net80211_frag_cache *frag = &dev->frags[fcid];
        int hdrsize = IEEE80211_TYP_FRAME_HEADER_LEN;
        int nfrags = frag->nfrags;
-       int nsize = size - hdrsize * (nfrags - 1);
+       int nsize = size - hdrsize * ( nfrags - 1 );
        int i;
 
-       struct io_buffer *niob = alloc_iob(nsize);
+       struct io_buffer *niob = alloc_iob ( nsize );
        struct ieee80211_frame *hdr;
 
        /* Add the header from the first one... */
-       memcpy(iob_put(niob, hdrsize), frag->iob[0]->data, hdrsize);
+       memcpy ( iob_put ( niob, hdrsize ), frag->iob[0]->data, hdrsize );
 
        /* ... and all the data from all of them. */
-       for (i = 0; i < frag->nfrags; i++) {
-               int len = iob_len(frag->iob[i]) - hdrsize;
-               memcpy(iob_put(niob, len), frag->iob[i]->data + hdrsize, len);
+       for ( i = 0; i < frag->nfrags; i++ ) {
+               int len = iob_len ( frag->iob[i] ) - hdrsize;
+               memcpy ( iob_put ( niob, len ),
+                        frag->iob[i]->data + hdrsize, len );
        }
 
        /* Turn off the fragment bit. */
@@ -1064,27 +1096,29 @@ static struct io_buffer *net80211_accum_frags(struct net80211_device *dev,
        return niob;
 }
 
-static void net80211_rx_frag(struct net80211_device *dev, struct io_buffer *iob,
-                            int signal)
+static void net80211_rx_frag ( struct net80211_device *dev,
+                              struct io_buffer *iob, int signal )
 {
        struct ieee80211_frame *hdr = iob->data;
 
-       if (IEEE80211_FRAG(hdr->seq) == 0 && (hdr->fc & IEEE80211_FC_MORE_FRAG)) {
+       if ( IEEE80211_FRAG ( hdr->seq ) == 0 &&
+            ( hdr->fc & IEEE80211_FC_MORE_FRAG ) ) {
                /* start a frag cache entry */
                int i, newest = -1;
                u32 curr_ticks = currticks(), newest_ticks = 0;
                u32 timeout = ticks_per_sec() * NET80211_FRAG_TIMEOUT;
 
-               for (i = 0; i < NET80211_NR_CONCURRENT_FRAGS; i++) {
-                       if (dev->frags[i].state == NET80211_FRAG_AVAIL)
+               for ( i = 0; i < NET80211_NR_CONCURRENT_FRAGS; i++ ) {
+                       if ( dev->frags[i].state == NET80211_FRAG_AVAIL )
                                break;
 
-                       if (dev->frags[i].start_ticks + timeout >= curr_ticks) {
-                               net80211_free_frags(dev, i);
+                       if ( dev->frags[i].start_ticks + timeout >=
+                            curr_ticks ) {
+                               net80211_free_frags ( dev, i );
                                break;
                        }
 
-                       if (dev->frags[i].start_ticks > newest_ticks) {
+                       if ( dev->frags[i].start_ticks > newest_ticks ) {
                                newest = i;
                                newest_ticks = dev->frags[i].start_ticks;
                        }
@@ -1093,112 +1127,116 @@ static void net80211_rx_frag(struct net80211_device *dev, struct io_buffer *iob,
                /* If we're being sent more concurrent fragmented
                   packets than we can handle, drop the newest so the
                   oldest has time to complete. */
-               if (i == NET80211_NR_CONCURRENT_FRAGS) {
+               if ( i == NET80211_NR_CONCURRENT_FRAGS ) {
                        i = newest;
-                       net80211_free_frags(dev, i);
+                       net80211_free_frags ( dev, i );
                }
 
                dev->frags[i].state = NET80211_FRAG_WAITING;
-               dev->frags[i].seqnr = IEEE80211_SEQNR(hdr->seq);
+               dev->frags[i].seqnr = IEEE80211_SEQNR ( hdr->seq );
                dev->frags[i].start_ticks = currticks();
                dev->frags[i].iob[0] = iob;
                return;
        } else {
                int i;
-               for (i = 0; i < NET80211_NR_CONCURRENT_FRAGS; i++) {
-                       if (dev->frags[i].state != NET80211_FRAG_AVAIL &&
-                           dev->frags[i].seqnr == IEEE80211_SEQNR(hdr->seq))
+               for ( i = 0; i < NET80211_NR_CONCURRENT_FRAGS; i++ ) {
+                       if ( dev->frags[i].state != NET80211_FRAG_AVAIL &&
+                            dev->frags[i].seqnr == IEEE80211_SEQNR ( hdr->seq ) )
                                break;
                }
-               if (i == NET80211_NR_CONCURRENT_FRAGS) {
+               if ( i == NET80211_NR_CONCURRENT_FRAGS ) {
                        /* drop non-first not-in-cache fragments */
-                       DBG2("802.11 dropped fragment fc=%04x seq=%04x\n",
-                            hdr->fc, hdr->seq);
-                       free_iob(iob);
+                       DBG2 ( "802.11 dropped fragment fc=%04x seq=%04x\n",
+                              hdr->fc, hdr->seq );
+                       free_iob ( iob );
                        return;
                }
 
-               dev->frags[i].iob[IEEE80211_FRAG(hdr->seq)] = iob;
+               dev->frags[i].iob[IEEE80211_FRAG ( hdr->seq )] = iob;
 
-               if (dev->frags[i].state == NET80211_FRAG_WAITING &&
-                   !(hdr->fc & IEEE80211_FC_MORE_FRAG)) {
+               if ( dev->frags[i].state == NET80211_FRAG_WAITING &&
+                    ! ( hdr->fc & IEEE80211_FC_MORE_FRAG ) ) {
                        dev->frags[i].state = NET80211_FRAG_FINISHING;
-                       dev->frags[i].nfrags = IEEE80211_FRAG(hdr->seq) + 1;
+                       dev->frags[i].nfrags =
+                           IEEE80211_FRAG ( hdr->seq ) + 1;
                }
-               
-               if (dev->frags[i].state == NET80211_FRAG_FINISHING) {
+
+               if ( dev->frags[i].state == NET80211_FRAG_FINISHING ) {
                        int j, size = 0;
-                       for (j = 0; j < dev->frags[i].nfrags; j++) {
-                               size += iob_len(dev->frags[i].iob[j]);
-                               if (dev->frags[i].iob[j] == NULL)
+                       for ( j = 0; j < dev->frags[i].nfrags; j++ ) {
+                               size += iob_len ( dev->frags[i].iob[j] );
+                               if ( dev->frags[i].iob[j] == NULL )
                                        break;
                        }
-                       if (j == dev->frags[i].nfrags) {
+                       if ( j == dev->frags[i].nfrags ) {
                                /* we've got everything! */
                                struct io_buffer *niob =
-                                       net80211_accum_frags(dev, i, size);
-                               net80211_free_frags(dev, i);
-                               net80211_rx(dev, niob, signal);
+                                   net80211_accum_frags ( dev, i, size );
+                               net80211_free_frags ( dev, i );
+                               net80211_rx ( dev, niob, signal );
                        }
                }
        }
 }
 
-void net80211_rx(struct net80211_device *dev, struct io_buffer *iob, int signal)
+void net80211_rx ( struct net80211_device *dev, struct io_buffer *iob,
+                  int signal )
 {
        struct ieee80211_frame *hdr = iob->data;
        u16 type = hdr->fc & IEEE80211_FC_TYPE;
-       if ((hdr->fc & IEEE80211_FC_VERSION) != IEEE80211_THIS_VERSION)
+       if ( ( hdr->fc & IEEE80211_FC_VERSION ) != IEEE80211_THIS_VERSION )
                goto drop;      /* drop invalid-version packets */
 
-       if (type == IEEE80211_TYPE_CTRL)
+       if ( type == IEEE80211_TYPE_CTRL )
                goto drop;      /* we don't handle control packets,
                                   the hardware does */
 
-       if (dev->last_rx_seq == hdr->seq)
+       if ( dev->last_rx_seq == hdr->seq )
                goto drop;      /* avoid duplicate packet */
        dev->last_rx_seq = hdr->seq;
 
-       if (dev->hw->flags & NET80211_HW_RX_HAS_FCS) {
+       if ( dev->hw->flags & NET80211_HW_RX_HAS_FCS ) {
                /* discard the FCS */
-               iob_unput(iob, 4);
+               iob_unput ( iob, 4 );
        }
 
-       if (hdr->fc & IEEE80211_FC_PROTECTED) {
+       if ( hdr->fc & IEEE80211_FC_PROTECTED ) {
                struct io_buffer *niob;
-               if (!dev->crypto)
+               if ( ! dev->crypto )
                        goto drop;      /* can't decrypt packets on an open network */
 
-               niob = dev->crypto->decrypt(dev, iob);
-               if (!niob)
+               niob = dev->crypto->decrypt ( dev, iob );
+               if ( ! niob )
                        goto drop;      /* drop failed decryption */
-               free_iob(iob);
+               free_iob ( iob );
                iob = niob;
        }
 
        /* Fragments go into the frag cache or get dropped. */
-       if (IEEE80211_FRAG(hdr->seq) != 0 || (hdr->fc & IEEE80211_FC_MORE_FRAG)) {
-               net80211_rx_frag(dev, iob, signal);
+       if ( IEEE80211_FRAG ( hdr->seq ) != 0
+            || ( hdr->fc & IEEE80211_FC_MORE_FRAG ) ) {
+               net80211_rx_frag ( dev, iob, signal );
                return;
        }
 
        /* Management frames get handled, enqueued, or dropped. */
-       if (type == IEEE80211_TYPE_MGMT) {
-               net80211_handle_mgmt(dev, iob, signal);
+       if ( type == IEEE80211_TYPE_MGMT ) {
+               net80211_handle_mgmt ( dev, iob, signal );
                return;
        }
 
        /* Data frames get dropped or sent to the net_device. */
-       if ((hdr->fc & IEEE80211_FC_SUBTYPE) != IEEE80211_STYPE_DATA)
+       if ( ( hdr->fc & IEEE80211_FC_SUBTYPE ) != IEEE80211_STYPE_DATA )
                goto drop;      /* drop QoS, CFP, or null data packets */
 
-       if (dev->netdev->state & NETDEV_LINK_UP) {
-               netdev_rx(dev->netdev, iob);
+       if ( dev->netdev->state & NETDEV_LINK_UP ) {
+               netdev_rx ( dev->netdev, iob );
                return;
        }
 
  drop:
-       DBG2("802.11 dropped packet fc=%04x seq=%04x\n", hdr->fc, hdr->seq);
-       free_iob(iob);
+       DBG2 ( "802.11 dropped packet fc=%04x seq=%04x\n", hdr->fc,
+              hdr->seq );
+       free_iob ( iob );
        return;
 }