orinoco: convert scanning to cfg80211 (c63cdbe8) · Commits · 戴 / test

drivers/net/wireless/orinoco/cfg.c

+20 −0

Original line number	Diff line number	Diff line
		@@ -137,6 +137,26 @@ static int orinoco_change_vif(struct wiphy wiphy, struct net_device dev,
		return err;
		}

		static int orinoco_scan(struct wiphy wiphy, struct net_device dev,
		struct cfg80211_scan_request *request)
		{
		struct orinoco_private *priv = wiphy_priv(wiphy);
		int err;

		if (!request)
		return -EINVAL;

		if (priv->scan_request && priv->scan_request != request)
		return -EBUSY;

		priv->scan_request = request;

		err = orinoco_hw_trigger_scan(priv, request->ssids);

		return err;
		}

		const struct cfg80211_ops orinoco_cfg_ops = {
		.change_virtual_intf = orinoco_change_vif,
		.scan = orinoco_scan,
		};

drivers/net/wireless/orinoco/hermes.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -342,7 +342,7 @@ struct agere_ext_scan_info {
		__le64 timestamp;
		__le16 beacon_interval;
		__le16 capabilities;
		u8 data[316];
		u8 data[0];
		} __attribute__ ((packed));

		#define HERMES_LINKSTATUS_NOT_CONNECTED (0x0000)

drivers/net/wireless/orinoco/hw.c

+85 −0

Original line number	Diff line number	Diff line
		@@ -1157,3 +1157,88 @@ int orinoco_hw_get_bitratelist(struct orinoco_private *priv,

		return 0;
		}

		int orinoco_hw_trigger_scan(struct orinoco_private *priv,
		const struct cfg80211_ssid *ssid)
		{
		struct net_device *dev = priv->ndev;
		hermes_t *hw = &priv->hw;
		unsigned long flags;
		int err = 0;

		if (orinoco_lock(priv, &flags) != 0)
		return -EBUSY;

		/* Scanning with port 0 disabled would fail */
		if (!netif_running(dev)) {
		err = -ENETDOWN;
		goto out;
		}

		/* In monitor mode, the scan results are always empty.
		* Probe responses are passed to the driver as received
		* frames and could be processed in software. */
		if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
		err = -EOPNOTSUPP;
		goto out;
		}

		if (priv->has_hostscan) {
		switch (priv->firmware_type) {
		case FIRMWARE_TYPE_SYMBOL:
		err = hermes_write_wordrec(hw, USER_BAP,
		HERMES_RID_CNFHOSTSCAN_SYMBOL,
		HERMES_HOSTSCAN_SYMBOL_ONCE \|
		HERMES_HOSTSCAN_SYMBOL_BCAST);
		break;
		case FIRMWARE_TYPE_INTERSIL: {
		__le16 req[3];

		req[0] = cpu_to_le16(0x3fff); /* All channels */
		req[1] = cpu_to_le16(0x0001); /* rate 1 Mbps */
		req[2] = 0; /* Any ESSID */
		err = HERMES_WRITE_RECORD(hw, USER_BAP,
		HERMES_RID_CNFHOSTSCAN, &req);
		break;
		}
		case FIRMWARE_TYPE_AGERE:
		if (ssid->ssid_len > 0) {
		struct hermes_idstring idbuf;
		size_t len = ssid->ssid_len;

		idbuf.len = cpu_to_le16(len);
		memcpy(idbuf.val, ssid->ssid, len);

		err = hermes_write_ltv(hw, USER_BAP,
		HERMES_RID_CNFSCANSSID_AGERE,
		HERMES_BYTES_TO_RECLEN(len + 2),
		&idbuf);
		} else
		err = hermes_write_wordrec(hw, USER_BAP,
		HERMES_RID_CNFSCANSSID_AGERE,
		0); /* Any ESSID */
		if (err)
		break;

		if (priv->has_ext_scan) {
		err = hermes_write_wordrec(hw, USER_BAP,
		HERMES_RID_CNFSCANCHANNELS2GHZ,
		0x7FFF);
		if (err)
		goto out;

		err = hermes_inquire(hw,
		HERMES_INQ_CHANNELINFO);
		} else
		err = hermes_inquire(hw, HERMES_INQ_SCAN);

		break;
		}
		} else
		err = hermes_inquire(hw, HERMES_INQ_SCAN);

		out:
		orinoco_unlock(priv, &flags);

		return err;
		}

drivers/net/wireless/orinoco/hw.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -7,6 +7,7 @@

		#include <linux/types.h>
		#include <linux/wireless.h>
		#include <net/cfg80211.h>

		/* Hardware BAPs */
		#define USER_BAP 0
		@@ -47,5 +48,7 @@ int orinoco_hw_get_essid(struct orinoco_private priv, int active,
		int orinoco_hw_get_freq(struct orinoco_private *priv);
		int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
		int numrates, s32 rates, int max);
		int orinoco_hw_trigger_scan(struct orinoco_private *priv,
		const struct cfg80211_ssid *ssid);

		#endif /* _ORINOCO_HW_H_ */

drivers/net/wireless/orinoco/main.c

+116 −51

Original line number	Diff line number	Diff line
		@@ -206,6 +206,13 @@ struct orinoco_rx_data {
		struct list_head list;
		};

		struct orinoco_scan_data {
		void *buf;
		size_t len;
		int type;
		struct list_head list;
		};

		/********************************************************************/
		/* Function prototypes */
		/********************************************************************/
		@@ -1265,6 +1272,78 @@ static void orinoco_send_wevents(struct work_struct *work)
		orinoco_unlock(priv, &flags);
		}

		static void qbuf_scan(struct orinoco_private priv, void buf,
		int len, int type)
		{
		struct orinoco_scan_data *sd;
		unsigned long flags;

		sd = kmalloc(sizeof(*sd), GFP_ATOMIC);
		sd->buf = buf;
		sd->len = len;
		sd->type = type;

		spin_lock_irqsave(&priv->scan_lock, flags);
		list_add_tail(&sd->list, &priv->scan_list);
		spin_unlock_irqrestore(&priv->scan_lock, flags);

		schedule_work(&priv->process_scan);
		}

		static void qabort_scan(struct orinoco_private *priv)
		{
		struct orinoco_scan_data *sd;
		unsigned long flags;

		sd = kmalloc(sizeof(*sd), GFP_ATOMIC);
		sd->len = -1; /* Abort */

		spin_lock_irqsave(&priv->scan_lock, flags);
		list_add_tail(&sd->list, &priv->scan_list);
		spin_unlock_irqrestore(&priv->scan_lock, flags);

		schedule_work(&priv->process_scan);
		}

		static void orinoco_process_scan_results(struct work_struct *work)
		{
		struct orinoco_private *priv =
		container_of(work, struct orinoco_private, process_scan);
		struct orinoco_scan_data sd, temp;
		unsigned long flags;
		void *buf;
		int len;
		int type;

		spin_lock_irqsave(&priv->scan_lock, flags);
		list_for_each_entry_safe(sd, temp, &priv->scan_list, list) {
		spin_unlock_irqrestore(&priv->scan_lock, flags);

		buf = sd->buf;
		len = sd->len;
		type = sd->type;

		list_del(&sd->list);
		kfree(sd);

		if (len > 0) {
		if (type == HERMES_INQ_CHANNELINFO)
		orinoco_add_extscan_result(priv, buf, len);
		else
		orinoco_add_hostscan_results(priv, buf, len);

		kfree(buf);
		} else if (priv->scan_request) {
		/* Either abort or complete the scan */
		cfg80211_scan_done(priv->scan_request, (len < 0));
		priv->scan_request = NULL;
		}

		spin_lock_irqsave(&priv->scan_lock, flags);
		}
		spin_unlock_irqrestore(&priv->scan_lock, flags);
		}

		static void __orinoco_ev_info(struct net_device dev, hermes_t hw)
		{
		struct orinoco_private *priv = ndev_priv(dev);
		@@ -1351,7 +1430,7 @@ static void __orinoco_ev_info(struct net_device dev, hermes_t hw)
		* the hostscan frame can be requested. */
		if (newstatus == HERMES_LINKSTATUS_AP_OUT_OF_RANGE &&
		priv->firmware_type == FIRMWARE_TYPE_SYMBOL &&
		priv->has_hostscan && priv->scan_inprogress) {
		priv->has_hostscan && priv->scan_request) {
		hermes_inquire(hw, HERMES_INQ_HOSTSCAN_SYMBOL);
		break;
		}
		@@ -1377,7 +1456,7 @@ static void __orinoco_ev_info(struct net_device dev, hermes_t hw)
		}
		break;
		case HERMES_INQ_SCAN:
		if (!priv->scan_inprogress && priv->bssid_fixed &&
		if (!priv->scan_request && priv->bssid_fixed &&
		priv->firmware_type == FIRMWARE_TYPE_INTERSIL) {
		schedule_work(&priv->join_work);
		break;
		@@ -1387,30 +1466,30 @@ static void __orinoco_ev_info(struct net_device dev, hermes_t hw)
		case HERMES_INQ_HOSTSCAN_SYMBOL: {
		/* Result of a scanning. Contains information about
		* cells in the vicinity - Jean II */
		union iwreq_data wrqu;
		unsigned char *buf;

		/* Scan is no longer in progress */
		priv->scan_inprogress = 0;

		/* Sanity check */
		if (len > 4096) {
		printk(KERN_WARNING "%s: Scan results too large (%d bytes)\n",
		dev->name, len);
		qabort_scan(priv);
		break;
		}

		/* Allocate buffer for results */
		buf = kmalloc(len, GFP_ATOMIC);
		if (buf == NULL)
		if (buf == NULL) {
		/* No memory, so can't printk()... */
		qabort_scan(priv);
		break;
		}

		/* Read scan data */
		err = hermes_bap_pread(hw, IRQ_BAP, (void *) buf, len,
		infofid, sizeof(info));
		if (err) {
		kfree(buf);
		qabort_scan(priv);
		break;
		}

		@@ -1424,24 +1503,14 @@ static void __orinoco_ev_info(struct net_device dev, hermes_t hw)
		}
		#endif /* ORINOCO_DEBUG */

		if (orinoco_process_scan_results(priv, buf, len) == 0) {
		/* Send an empty event to user space.
		* We don't send the received data on the event because
		* it would require us to do complex transcoding, and
		* we want to minimise the work done in the irq handler
		* Use a request to extract the data - Jean II */
		wrqu.data.length = 0;
		wrqu.data.flags = 0;
		wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
		}
		kfree(buf);
		qbuf_scan(priv, buf, len, type);
		}
		break;
		case HERMES_INQ_CHANNELINFO:
		{
		struct agere_ext_scan_info *bss;

		if (!priv->scan_inprogress) {
		if (!priv->scan_request) {
		printk(KERN_DEBUG "%s: Got chaninfo without scan, "
		"len=%d\n", dev->name, len);
		break;
		@@ -1449,25 +1518,12 @@ static void __orinoco_ev_info(struct net_device dev, hermes_t hw)

		/* An empty result indicates that the scan is complete */
		if (len == 0) {
		union iwreq_data wrqu;

		/* Scan is no longer in progress */
		priv->scan_inprogress = 0;

		wrqu.data.length = 0;
		wrqu.data.flags = 0;
		wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
		qbuf_scan(priv, NULL, len, type);
		break;
		}

		/* Sanity check */
		else if (len > sizeof(*bss)) {
		printk(KERN_WARNING
		"%s: Ext scan results too large (%d bytes). "
		"Truncating results to %zd bytes.\n",
		dev->name, len, sizeof(*bss));
		len = sizeof(*bss);
		} else if (len < (offsetof(struct agere_ext_scan_info,
		else if (len < (offsetof(struct agere_ext_scan_info,
		data) + 2)) {
		/* Drop this result now so we don't have to
		* keep checking later */
		@@ -1477,21 +1533,18 @@ static void __orinoco_ev_info(struct net_device dev, hermes_t hw)
		break;
		}

		bss = kmalloc(sizeof(*bss), GFP_ATOMIC);
		bss = kmalloc(len, GFP_ATOMIC);
		if (bss == NULL)
		break;

		/* Read scan data */
		err = hermes_bap_pread(hw, IRQ_BAP, (void *) bss, len,
		infofid, sizeof(info));
		if (err) {
		if (err)
		kfree(bss);
		break;
		}

		orinoco_add_ext_scan_result(priv, bss);
		else
		qbuf_scan(priv, bss, len, type);

		kfree(bss);
		break;
		}
		case HERMES_INQ_SEC_STAT_AGERE:
		@@ -1506,6 +1559,8 @@ static void __orinoco_ev_info(struct net_device dev, hermes_t hw)
		/* We don't actually do anything about it */
		break;
		}

		return;
		}

		static void __orinoco_ev_infdrop(struct net_device dev, hermes_t hw)
		@@ -1649,9 +1704,11 @@ void orinoco_reset(struct work_struct *work)

		orinoco_unlock(priv, &flags);

		/* Scanning support: Cleanup of driver struct */
		orinoco_clear_scan_results(priv, 0);
		priv->scan_inprogress = 0;
		/* Scanning support: Notify scan cancellation */
		if (priv->scan_request) {
		cfg80211_scan_done(priv->scan_request, 1);
		priv->scan_request = NULL;
		}

		if (priv->hard_reset) {
		err = (*priv->hard_reset)(priv);
		@@ -1965,12 +2022,6 @@ int orinoco_init(struct orinoco_private *priv)
		}
		}

		/* Now we have the firmware capabilities, allocate appropiate
		* sized scan buffers */
		if (orinoco_bss_data_allocate(priv))
		goto out;
		orinoco_bss_data_init(priv);

		err = orinoco_hw_read_card_settings(priv, wiphy->perm_addr);
		if (err)
		goto out;
		@@ -2100,6 +2151,10 @@ struct orinoco_private
		tasklet_init(&priv->rx_tasklet, orinoco_rx_isr_tasklet,
		(unsigned long) priv);

		spin_lock_init(&priv->scan_lock);
		INIT_LIST_HEAD(&priv->scan_list);
		INIT_WORK(&priv->process_scan, orinoco_process_scan_results);

		priv->last_linkstatus = 0xffff;

		#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) \|\| defined(CONFIG_PM_SLEEP)
		@@ -2192,6 +2247,7 @@ void free_orinocodev(struct orinoco_private *priv)
		{
		struct wiphy *wiphy = priv_to_wiphy(priv);
		struct orinoco_rx_data rx_data, temp;
		struct orinoco_scan_data sd, sdtemp;

		wiphy_unregister(wiphy);

		@@ -2209,13 +2265,22 @@ void free_orinocodev(struct orinoco_private *priv)
		kfree(rx_data);
		}

		cancel_work_sync(&priv->process_scan);
		/* Explicitly drain priv->scan_list */
		list_for_each_entry_safe(sd, sdtemp, &priv->scan_list, list) {
		list_del(&sd->list);

		if ((sd->len > 0) && sd->buf)
		kfree(sd->buf);
		kfree(sd);
		}

		orinoco_unregister_pm_notifier(priv);
		orinoco_uncache_fw(priv);

		priv->wpa_ie_len = 0;
		kfree(priv->wpa_ie);
		orinoco_mic_free(priv);
		orinoco_bss_data_free(priv);
		wiphy_free(wiphy);
		}
		EXPORT_SYMBOL(free_orinocodev);

Admin message