/******************************************************************************
- Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved.
+ Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
This program is free software; you can redistribute it and/or modify it
under the terms of version 2 of the GNU General Public License as
*/
#include <linux/compiler.h>
+#include <linux/config.h>
#include <linux/errno.h>
#include <linux/if_arp.h>
#include <linux/in6.h>
#include "ipw2100.h"
-#define IPW2100_VERSION "git-1.2.2"
+#define IPW2100_VERSION "1.1.3"
#define DRV_NAME "ipw2100"
#define DRV_VERSION IPW2100_VERSION
#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2100 Network Driver"
-#define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation"
+#define DRV_COPYRIGHT "Copyright(c) 2003-2005 Intel Corporation"
/* Debugging stuff */
#ifdef CONFIG_IPW2100_DEBUG
if (priv->status & STATUS_ENABLED)
return 0;
- mutex_lock(&priv->adapter_mutex);
+ down(&priv->adapter_sem);
if (rf_kill_active(priv)) {
IPW_DEBUG_HC("Command aborted due to RF kill active.\n");
}
fail_up:
- mutex_unlock(&priv->adapter_mutex);
+ up(&priv->adapter_sem);
return err;
}
*
* Sending the PREPARE_FOR_POWER_DOWN will restrict the
* hardware from going into standby mode and will transition
- * out of D0-standby if it is already in that state.
+ * out of D0-standy if it is already in that state.
*
* STATUS_PREPARE_POWER_DOWN_COMPLETE will be sent by the
* driver upon completion. Once received, the driver can
cancel_delayed_work(&priv->hang_check);
}
- mutex_lock(&priv->adapter_mutex);
+ down(&priv->adapter_sem);
err = ipw2100_hw_send_command(priv, &cmd);
if (err) {
IPW_DEBUG_INFO("TODO: implement scan state machine\n");
fail_up:
- mutex_unlock(&priv->adapter_mutex);
+ up(&priv->adapter_sem);
return err;
}
return err;
}
-static const struct ieee80211_geo ipw_geos[] = {
- { /* Restricted */
- "---",
- .bg_channels = 14,
- .bg = {{2412, 1}, {2417, 2}, {2422, 3},
- {2427, 4}, {2432, 5}, {2437, 6},
- {2442, 7}, {2447, 8}, {2452, 9},
- {2457, 10}, {2462, 11}, {2467, 12},
- {2472, 13}, {2484, 14}},
- },
-};
-
static int ipw2100_up(struct ipw2100_priv *priv, int deferred)
{
unsigned long flags;
goto exit;
}
- /* Initialize the geo */
- if (ieee80211_set_geo(priv->ieee, &ipw_geos[0])) {
- printk(KERN_WARNING DRV_NAME "Could not set geo\n");
- return 0;
- }
- priv->ieee->freq_band = IEEE80211_24GHZ_BAND;
-
lock = LOCK_NONE;
if (ipw2100_set_ordinal(priv, IPW_ORD_PERS_DB_LOCK, &lock, &ord_len)) {
printk(KERN_ERR DRV_NAME
priv->status |= STATUS_RESET_PENDING;
spin_unlock_irqrestore(&priv->low_lock, flags);
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
/* stop timed checks so that they don't interfere with reset */
priv->stop_hang_check = 1;
cancel_delayed_work(&priv->hang_check);
wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
ipw2100_up(priv, 0);
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
}
IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
return;
}
+#ifdef CONFIG_IPW2100_MONITOR
+ if (unlikely(priv->ieee->iw_mode == IW_MODE_MONITOR &&
+ priv->config & CFG_CRC_CHECK &&
+ status->flags & IPW_STATUS_FLAG_CRC_ERROR)) {
+ IPW_DEBUG_RX("CRC error in packet. Dropping.\n");
+ priv->ieee->stats.rx_errors++;
+ return;
+ }
+#endif
if (unlikely(priv->ieee->iw_mode != IW_MODE_MONITOR &&
!(priv->status & STATUS_ASSOCIATED))) {
priv->rx_queue.drv[i].host_addr = packet->dma_addr;
}
-#ifdef CONFIG_IPW2100_MONITOR
-
-static void isr_rx_monitor(struct ipw2100_priv *priv, int i,
- struct ieee80211_rx_stats *stats)
-{
- struct ipw2100_status *status = &priv->status_queue.drv[i];
- struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
-
- /* Magic struct that slots into the radiotap header -- no reason
- * to build this manually element by element, we can write it much
- * more efficiently than we can parse it. ORDER MATTERS HERE */
- struct ipw_rt_hdr {
- struct ieee80211_radiotap_header rt_hdr;
- s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
- } *ipw_rt;
-
- IPW_DEBUG_RX("Handler...\n");
-
- if (unlikely(status->frame_size > skb_tailroom(packet->skb) -
- sizeof(struct ipw_rt_hdr))) {
- IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
- " Dropping.\n",
- priv->net_dev->name,
- status->frame_size,
- skb_tailroom(packet->skb));
- priv->ieee->stats.rx_errors++;
- return;
- }
-
- if (unlikely(!netif_running(priv->net_dev))) {
- priv->ieee->stats.rx_errors++;
- priv->wstats.discard.misc++;
- IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
- return;
- }
-
- if (unlikely(priv->config & CFG_CRC_CHECK &&
- status->flags & IPW_STATUS_FLAG_CRC_ERROR)) {
- IPW_DEBUG_RX("CRC error in packet. Dropping.\n");
- priv->ieee->stats.rx_errors++;
- return;
- }
-
- pci_unmap_single(priv->pci_dev, packet->dma_addr,
- sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
- memmove(packet->skb->data + sizeof(struct ipw_rt_hdr),
- packet->skb->data, status->frame_size);
-
- ipw_rt = (struct ipw_rt_hdr *) packet->skb->data;
-
- ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
- ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
- ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total hdr+data */
-
- ipw_rt->rt_hdr.it_present = 1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL;
-
- ipw_rt->rt_dbmsignal = status->rssi + IPW2100_RSSI_TO_DBM;
-
- skb_put(packet->skb, status->frame_size + sizeof(struct ipw_rt_hdr));
-
- if (!ieee80211_rx(priv->ieee, packet->skb, stats)) {
- priv->ieee->stats.rx_errors++;
-
- /* ieee80211_rx failed, so it didn't free the SKB */
- dev_kfree_skb_any(packet->skb);
- packet->skb = NULL;
- }
-
- /* We need to allocate a new SKB and attach it to the RDB. */
- if (unlikely(ipw2100_alloc_skb(priv, packet))) {
- IPW_DEBUG_WARNING(
- "%s: Unable to allocate SKB onto RBD ring - disabling "
- "adapter.\n", priv->net_dev->name);
- /* TODO: schedule adapter shutdown */
- IPW_DEBUG_INFO("TODO: Shutdown adapter...\n");
- }
-
- /* Update the RDB entry */
- priv->rx_queue.drv[i].host_addr = packet->dma_addr;
-}
-
-#endif
-
static int ipw2100_corruption_check(struct ipw2100_priv *priv, int i)
{
struct ipw2100_status *status = &priv->status_queue.drv[i];
case P8023_DATA_VAL:
#ifdef CONFIG_IPW2100_MONITOR
if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
- isr_rx_monitor(priv, i, &stats);
+ isr_rx(priv, i, &stats);
break;
}
#endif
struct net_device *dev = priv->net_dev;
const char *p = buf;
- (void)dev; /* kill unused-var warning for debug-only code */
+ (void) dev; /* kill unused-var warning for debug-only code */
if (count < 1)
return count;
#ifdef CONFIG_IPW2100_MONITOR
case IW_MODE_MONITOR:
priv->last_mode = priv->ieee->iw_mode;
- priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
+ priv->net_dev->type = ARPHRD_IEEE80211;
break;
#endif /* CONFIG_IPW2100_MONITOR */
}
unsigned long val;
char *p = buffer;
- (void)dev; /* kill unused-var warning for debug-only code */
+ (void) dev; /* kill unused-var warning for debug-only code */
IPW_DEBUG_INFO("enter\n");
IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
disable_radio ? "OFF" : "ON");
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (disable_radio) {
priv->status |= STATUS_RF_KILL_SW;
schedule_reset(priv);
}
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return 1;
}
.host_command_length = 4
};
int err = 0;
- u32 tmp = tx_power;
if (tx_power != IPW_TX_POWER_DEFAULT)
- tmp = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 /
- (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM);
+ tx_power = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 /
+ (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM);
- cmd.host_command_parameters[0] = tmp;
+ cmd.host_command_parameters[0] = tx_power;
if (priv->ieee->iw_mode == IW_MODE_ADHOC)
err = ipw2100_hw_send_command(priv, &cmd);
idx, keylen, len);
/* NOTE: We don't check cached values in case the firmware was reset
- * or some other problem is occurring. If the user is setting the key,
+ * or some other problem is occuring. If the user is setting the key,
* then we push the change */
wep_key->idx = idx;
SEC_LEVEL_0, 0, 1);
} else {
auth_mode = IPW_AUTH_OPEN;
- if (priv->ieee->sec.flags & SEC_AUTH_MODE) {
- if (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)
- auth_mode = IPW_AUTH_SHARED;
- else if (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP)
- auth_mode = IPW_AUTH_LEAP_CISCO_ID;
- }
+ if ((priv->ieee->sec.flags & SEC_AUTH_MODE) &&
+ (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY))
+ auth_mode = IPW_AUTH_SHARED;
sec_level = SEC_LEVEL_0;
if (priv->ieee->sec.flags & SEC_LEVEL)
struct ipw2100_priv *priv = ieee80211_priv(dev);
int i, force_update = 0;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED))
goto done;
if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
ipw2100_configure_security(priv, 0);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
}
static int ipw2100_adapter_setup(struct ipw2100_priv *priv)
if (!is_valid_ether_addr(addr->sa_data))
return -EADDRNOTAVAIL;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
priv->config |= CFG_CUSTOM_MAC;
memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
goto done;
priv->reset_backoff = 0;
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
ipw2100_reset_adapter(priv);
return 0;
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
} else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
sec.auth_mode = WLAN_AUTH_OPEN;
ieee->open_wep = 1;
- } else if (value & IW_AUTH_ALG_LEAP) {
- sec.auth_mode = WLAN_AUTH_LEAP;
- ieee->open_wep = 1;
} else
return -EINVAL;
return ret;
}
-static void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv,
- char *wpa_ie, int wpa_ie_len)
+void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv,
+ char *wpa_ie, int wpa_ie_len)
{
struct ipw2100_wpa_assoc_frame frame;
strcpy(priv->nick, "ipw2100");
spin_lock_init(&priv->low_lock);
- mutex_init(&priv->action_mutex);
- mutex_init(&priv->adapter_mutex);
+ sema_init(&priv->action_sem, 1);
+ sema_init(&priv->adapter_sem, 1);
init_waitqueue_head(&priv->wait_command_queue);
ipw2100_queues_initialize(priv);
err = request_irq(pci_dev->irq,
- ipw2100_interrupt, IRQF_SHARED, dev->name, priv);
+ ipw2100_interrupt, SA_SHIRQ, dev->name, priv);
if (err) {
printk(KERN_WARNING DRV_NAME
"Error calling request_irq: %d.\n", pci_dev->irq);
* member to call a function that then just turns and calls ipw2100_up.
* net_dev->init is called after name allocation but before the
* notifier chain is called */
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
err = register_netdev(dev);
if (err) {
printk(KERN_WARNING DRV_NAME
priv->status |= STATUS_INITIALIZED;
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return 0;
fail_unlock:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
fail:
if (dev) {
struct net_device *dev;
if (priv) {
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
priv->status &= ~STATUS_INITIALIZED;
/* Take down the hardware */
ipw2100_down(priv);
- /* Release the mutex so that the network subsystem can
+ /* Release the semaphore so that the network subsystem can
* complete any needed calls into the driver... */
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
/* Unregister the device first - this results in close()
* being called if the device is open. If we free storage
IPW_DEBUG_INFO("%s: Going into suspend...\n", dev->name);
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (priv->status & STATUS_INITIALIZED) {
/* Take down the device; powers it off, etc. */
ipw2100_down(priv);
pci_disable_device(pci_dev);
pci_set_power_state(pci_dev, PCI_D3hot);
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return 0;
}
if (IPW2100_PM_DISABLED)
return 0;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
IPW_DEBUG_INFO("%s: Coming out of suspend...\n", dev->name);
if (!(priv->status & STATUS_RF_KILL_SW))
ipw2100_up(priv, 0);
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return 0;
}
if (priv->ieee->iw_mode == IW_MODE_INFRA)
return -EOPNOTSUPP;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
}
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
if (wrqu->mode == priv->ieee->iw_mode)
return 0;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
}
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
return -EINVAL;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
wrqu->ap_addr.sa_data[5] & 0xff);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
int length = 0;
int err = 0;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
err = ipw2100_set_essid(priv, essid, length, 0);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
u32 rate;
int err = 0;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
IPW_DEBUG_WX("SET Rate -> %04X \n", rate);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
return 0;
}
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
if (wrqu->rts.fixed == 0)
return -EINVAL;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
IPW_DEBUG_WX("SET RTS Threshold -> 0x%08X \n", value);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
value = wrqu->txpower.value;
}
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
IPW_DEBUG_WX("SET TX Power -> %d \n", value);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
return 0;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
IPW_DEBUG_WX("SET Both Retry Limits -> %d \n", wrqu->retry.value);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
struct ipw2100_priv *priv = ieee80211_priv(dev);
int err = 0;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
}
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
struct ipw2100_priv *priv = ieee80211_priv(dev);
int err = 0;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
int enable = (parms[0] > 0);
int err = 0;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
err = ipw2100_switch_mode(priv, priv->last_mode);
}
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
struct ipw2100_priv *priv = ieee80211_priv(dev);
int err = 0, mode = *(int *)extra;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
if (priv->power_mode != mode)
err = ipw2100_set_power_mode(priv, mode);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
struct ipw2100_priv *priv = ieee80211_priv(dev);
int err, mode = *(int *)extra;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
err = ipw2100_system_config(priv, 0);
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
struct ipw2100_priv *priv = ieee80211_priv(dev);
int err, mode = *(int *)extra;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
if (!(priv->status & STATUS_INITIALIZED)) {
err = -EIO;
goto done;
err = 0;
done:
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
return err;
}
if (priv->status & STATUS_STOPPING)
return;
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
IPW_DEBUG_WX("enter\n");
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
wrqu.ap_addr.sa_family = ARPHRD_ETHER;
if (!(priv->status & STATUS_ASSOCIATED)) {
IPW_DEBUG_WX("Configuring ESSID\n");
- mutex_lock(&priv->action_mutex);
+ down(&priv->action_sem);
/* This is a disassociation event, so kick the firmware to
* look for another AP */
if (priv->config & CFG_STATIC_ESSID)
0);
else
ipw2100_set_essid(priv, NULL, 0, 0);
- mutex_unlock(&priv->action_mutex);
+ up(&priv->action_sem);
}
wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
git://git.onelab.eu / linux-2.6.git / blobdiff