Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/linville/wireless-next-2.6 (28f49d8f) · Commits · EulixOS / Software / Kernel

Documentation/rfkill.txt

+493 −54

File changed.

Preview size limit exceeded, changes collapsed.

MAINTAINERS

+0 −4

Original line number	Diff line number	Diff line
		@@ -3854,10 +3854,6 @@ P: Ion Badulescu
		M: ionut@cs.columbia.edu
		S: Maintained

		STARMODE RADIO IP (STRIP) PROTOCOL DRIVER
		W: http://mosquitonet.Stanford.EDU/strip.html
		S: Unsupported ?

		STRADIS MPEG-2 DECODER DRIVER
		P: Nathan Laredo
		M: laredo@gnu.org

drivers/net/b44.c

+71 −69

Original line number	Diff line number	Diff line
		@@ -148,7 +148,7 @@ static inline void b44_sync_dma_desc_for_device(struct ssb_device *sdev,
		unsigned long offset,
		enum dma_data_direction dir)
		{
		dma_sync_single_range_for_device(sdev->dma_dev, dma_base,
		ssb_dma_sync_single_range_for_device(sdev, dma_base,
		offset & dma_desc_align_mask,
		dma_desc_sync_size, dir);
		}
		@@ -158,7 +158,7 @@ static inline void b44_sync_dma_desc_for_cpu(struct ssb_device *sdev,
		unsigned long offset,
		enum dma_data_direction dir)
		{
		dma_sync_single_range_for_cpu(sdev->dma_dev, dma_base,
		ssb_dma_sync_single_range_for_cpu(sdev, dma_base,
		offset & dma_desc_align_mask,
		dma_desc_sync_size, dir);
		}
		@@ -613,7 +613,7 @@ static void b44_tx(struct b44 *bp)

		BUG_ON(skb == NULL);

		dma_unmap_single(bp->sdev->dma_dev,
		ssb_dma_unmap_single(bp->sdev,
		rp->mapping,
		skb->len,
		DMA_TO_DEVICE);
		@@ -653,29 +653,29 @@ static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
		if (skb == NULL)
		return -ENOMEM;

		mapping = dma_map_single(bp->sdev->dma_dev, skb->data,
		mapping = ssb_dma_map_single(bp->sdev, skb->data,
		RX_PKT_BUF_SZ,
		DMA_FROM_DEVICE);

		/* Hardware bug work-around, the chip is unable to do PCI DMA
		to/from anything above 1GB :-( */
		if (dma_mapping_error(mapping) \|\|
		if (ssb_dma_mapping_error(bp->sdev, mapping) \|\|
		mapping + RX_PKT_BUF_SZ > DMA_30BIT_MASK) {
		/* Sigh... */
		if (!dma_mapping_error(mapping))
		dma_unmap_single(bp->sdev->dma_dev, mapping,
		if (!ssb_dma_mapping_error(bp->sdev, mapping))
		ssb_dma_unmap_single(bp->sdev, mapping,
		RX_PKT_BUF_SZ, DMA_FROM_DEVICE);
		dev_kfree_skb_any(skb);
		skb = __netdev_alloc_skb(bp->dev, RX_PKT_BUF_SZ, GFP_ATOMIC\|GFP_DMA);
		if (skb == NULL)
		return -ENOMEM;
		mapping = dma_map_single(bp->sdev->dma_dev, skb->data,
		mapping = ssb_dma_map_single(bp->sdev, skb->data,
		RX_PKT_BUF_SZ,
		DMA_FROM_DEVICE);
		if (dma_mapping_error(mapping) \|\|
		if (ssb_dma_mapping_error(bp->sdev, mapping) \|\|
		mapping + RX_PKT_BUF_SZ > DMA_30BIT_MASK) {
		if (!dma_mapping_error(mapping))
		dma_unmap_single(bp->sdev->dma_dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE);
		if (!ssb_dma_mapping_error(bp->sdev, mapping))
		ssb_dma_unmap_single(bp->sdev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE);
		dev_kfree_skb_any(skb);
		return -ENOMEM;
		}
		@@ -750,7 +750,7 @@ static void b44_recycle_rx(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
		dest_idx * sizeof(dest_desc),
		DMA_BIDIRECTIONAL);

		dma_sync_single_for_device(bp->sdev->dma_dev, le32_to_cpu(src_desc->addr),
		ssb_dma_sync_single_for_device(bp->sdev, le32_to_cpu(src_desc->addr),
		RX_PKT_BUF_SZ,
		DMA_FROM_DEVICE);
		}
		@@ -772,7 +772,7 @@ static int b44_rx(struct b44 *bp, int budget)
		struct rx_header *rh;
		u16 len;

		dma_sync_single_for_cpu(bp->sdev->dma_dev, map,
		ssb_dma_sync_single_for_cpu(bp->sdev, map,
		RX_PKT_BUF_SZ,
		DMA_FROM_DEVICE);
		rh = (struct rx_header *) skb->data;
		@@ -806,7 +806,7 @@ static int b44_rx(struct b44 *bp, int budget)
		skb_size = b44_alloc_rx_skb(bp, cons, bp->rx_prod);
		if (skb_size < 0)
		goto drop_it;
		dma_unmap_single(bp->sdev->dma_dev, map,
		ssb_dma_unmap_single(bp->sdev, map,
		skb_size, DMA_FROM_DEVICE);
		/* Leave out rx_header */
		skb_put(skb, len + RX_PKT_OFFSET);
		@@ -966,24 +966,24 @@ static int b44_start_xmit(struct sk_buff skb, struct net_device dev)
		goto err_out;
		}

		mapping = dma_map_single(bp->sdev->dma_dev, skb->data, len, DMA_TO_DEVICE);
		if (dma_mapping_error(mapping) \|\| mapping + len > DMA_30BIT_MASK) {
		mapping = ssb_dma_map_single(bp->sdev, skb->data, len, DMA_TO_DEVICE);
		if (ssb_dma_mapping_error(bp->sdev, mapping) \|\| mapping + len > DMA_30BIT_MASK) {
		struct sk_buff *bounce_skb;

		/* Chip can't handle DMA to/from >1GB, use bounce buffer */
		if (!dma_mapping_error(mapping))
		dma_unmap_single(bp->sdev->dma_dev, mapping, len,
		if (!ssb_dma_mapping_error(bp->sdev, mapping))
		ssb_dma_unmap_single(bp->sdev, mapping, len,
		DMA_TO_DEVICE);

		bounce_skb = __dev_alloc_skb(len, GFP_ATOMIC \| GFP_DMA);
		if (!bounce_skb)
		goto err_out;

		mapping = dma_map_single(bp->sdev->dma_dev, bounce_skb->data,
		mapping = ssb_dma_map_single(bp->sdev, bounce_skb->data,
		len, DMA_TO_DEVICE);
		if (dma_mapping_error(mapping) \|\| mapping + len > DMA_30BIT_MASK) {
		if (!dma_mapping_error(mapping))
		dma_unmap_single(bp->sdev->dma_dev, mapping,
		if (ssb_dma_mapping_error(bp->sdev, mapping) \|\| mapping + len > DMA_30BIT_MASK) {
		if (!ssb_dma_mapping_error(bp->sdev, mapping))
		ssb_dma_unmap_single(bp->sdev, mapping,
		len, DMA_TO_DEVICE);
		dev_kfree_skb_any(bounce_skb);
		goto err_out;
		@@ -1082,7 +1082,7 @@ static void b44_free_rings(struct b44 *bp)

		if (rp->skb == NULL)
		continue;
		dma_unmap_single(bp->sdev->dma_dev, rp->mapping, RX_PKT_BUF_SZ,
		ssb_dma_unmap_single(bp->sdev, rp->mapping, RX_PKT_BUF_SZ,
		DMA_FROM_DEVICE);
		dev_kfree_skb_any(rp->skb);
		rp->skb = NULL;
		@@ -1094,7 +1094,7 @@ static void b44_free_rings(struct b44 *bp)

		if (rp->skb == NULL)
		continue;
		dma_unmap_single(bp->sdev->dma_dev, rp->mapping, rp->skb->len,
		ssb_dma_unmap_single(bp->sdev, rp->mapping, rp->skb->len,
		DMA_TO_DEVICE);
		dev_kfree_skb_any(rp->skb);
		rp->skb = NULL;
		@@ -1117,12 +1117,12 @@ static void b44_init_rings(struct b44 *bp)
		memset(bp->tx_ring, 0, B44_TX_RING_BYTES);

		if (bp->flags & B44_FLAG_RX_RING_HACK)
		dma_sync_single_for_device(bp->sdev->dma_dev, bp->rx_ring_dma,
		ssb_dma_sync_single_for_device(bp->sdev, bp->rx_ring_dma,
		DMA_TABLE_BYTES,
		DMA_BIDIRECTIONAL);

		if (bp->flags & B44_FLAG_TX_RING_HACK)
		dma_sync_single_for_device(bp->sdev->dma_dev, bp->tx_ring_dma,
		ssb_dma_sync_single_for_device(bp->sdev, bp->tx_ring_dma,
		DMA_TABLE_BYTES,
		DMA_TO_DEVICE);

		@@ -1144,25 +1144,27 @@ static void b44_free_consistent(struct b44 *bp)
		bp->tx_buffers = NULL;
		if (bp->rx_ring) {
		if (bp->flags & B44_FLAG_RX_RING_HACK) {
		dma_unmap_single(bp->sdev->dma_dev, bp->rx_ring_dma,
		ssb_dma_unmap_single(bp->sdev, bp->rx_ring_dma,
		DMA_TABLE_BYTES,
		DMA_BIDIRECTIONAL);
		kfree(bp->rx_ring);
		} else
		dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES,
		bp->rx_ring, bp->rx_ring_dma);
		ssb_dma_free_consistent(bp->sdev, DMA_TABLE_BYTES,
		bp->rx_ring, bp->rx_ring_dma,
		GFP_KERNEL);
		bp->rx_ring = NULL;
		bp->flags &= ~B44_FLAG_RX_RING_HACK;
		}
		if (bp->tx_ring) {
		if (bp->flags & B44_FLAG_TX_RING_HACK) {
		dma_unmap_single(bp->sdev->dma_dev, bp->tx_ring_dma,
		ssb_dma_unmap_single(bp->sdev, bp->tx_ring_dma,
		DMA_TABLE_BYTES,
		DMA_TO_DEVICE);
		kfree(bp->tx_ring);
		} else
		dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES,
		bp->tx_ring, bp->tx_ring_dma);
		ssb_dma_free_consistent(bp->sdev, DMA_TABLE_BYTES,
		bp->tx_ring, bp->tx_ring_dma,
		GFP_KERNEL);
		bp->tx_ring = NULL;
		bp->flags &= ~B44_FLAG_TX_RING_HACK;
		}
		@@ -1187,7 +1189,7 @@ static int b44_alloc_consistent(struct b44 *bp, gfp_t gfp)
		goto out_err;

		size = DMA_TABLE_BYTES;
		bp->rx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size, &bp->rx_ring_dma, gfp);
		bp->rx_ring = ssb_dma_alloc_consistent(bp->sdev, size, &bp->rx_ring_dma, gfp);
		if (!bp->rx_ring) {
		/* Allocation may have failed due to pci_alloc_consistent
		insisting on use of GFP_DMA, which is more restrictive
		@@ -1199,11 +1201,11 @@ static int b44_alloc_consistent(struct b44 *bp, gfp_t gfp)
		if (!rx_ring)
		goto out_err;

		rx_ring_dma = dma_map_single(bp->sdev->dma_dev, rx_ring,
		rx_ring_dma = ssb_dma_map_single(bp->sdev, rx_ring,
		DMA_TABLE_BYTES,
		DMA_BIDIRECTIONAL);

		if (dma_mapping_error(rx_ring_dma) \|\|
		if (ssb_dma_mapping_error(bp->sdev, rx_ring_dma) \|\|
		rx_ring_dma + size > DMA_30BIT_MASK) {
		kfree(rx_ring);
		goto out_err;
		@@ -1214,9 +1216,9 @@ static int b44_alloc_consistent(struct b44 *bp, gfp_t gfp)
		bp->flags \|= B44_FLAG_RX_RING_HACK;
		}

		bp->tx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size, &bp->tx_ring_dma, gfp);
		bp->tx_ring = ssb_dma_alloc_consistent(bp->sdev, size, &bp->tx_ring_dma, gfp);
		if (!bp->tx_ring) {
		/* Allocation may have failed due to dma_alloc_coherent
		/* Allocation may have failed due to ssb_dma_alloc_consistent
		insisting on use of GFP_DMA, which is more restrictive
		than necessary... */
		struct dma_desc *tx_ring;
		@@ -1226,11 +1228,11 @@ static int b44_alloc_consistent(struct b44 *bp, gfp_t gfp)
		if (!tx_ring)
		goto out_err;

		tx_ring_dma = dma_map_single(bp->sdev->dma_dev, tx_ring,
		tx_ring_dma = ssb_dma_map_single(bp->sdev, tx_ring,
		DMA_TABLE_BYTES,
		DMA_TO_DEVICE);

		if (dma_mapping_error(tx_ring_dma) \|\|
		if (ssb_dma_mapping_error(bp->sdev, tx_ring_dma) \|\|
		tx_ring_dma + size > DMA_30BIT_MASK) {
		kfree(tx_ring);
		goto out_err;

drivers/net/ps3_gelic_wireless.c

+16 −14

Original line number	Diff line number	Diff line
		@@ -571,6 +571,7 @@ static void gelic_wl_parse_ie(u8 *data, size_t len,
		* independent format
		*/
		static char gelic_wl_translate_scan(struct net_device netdev,
		struct iw_request_info *info,
		char *ev,
		char *stop,
		struct gelic_wl_scan_info *network)
		@@ -588,26 +589,26 @@ static char gelic_wl_translate_scan(struct net_device netdev,
		iwe.cmd = SIOCGIWAP;
		iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
		memcpy(iwe.u.ap_addr.sa_data, &scan->bssid[2], ETH_ALEN);
		ev = iwe_stream_add_event(ev, stop, &iwe, IW_EV_ADDR_LEN);
		ev = iwe_stream_add_event(info, ev, stop, &iwe, IW_EV_ADDR_LEN);

		/* ESSID */
		iwe.cmd = SIOCGIWESSID;
		iwe.u.data.flags = 1;
		iwe.u.data.length = strnlen(scan->essid, 32);
		ev = iwe_stream_add_point(ev, stop, &iwe, scan->essid);
		ev = iwe_stream_add_point(info, ev, stop, &iwe, scan->essid);

		/* FREQUENCY */
		iwe.cmd = SIOCGIWFREQ;
		iwe.u.freq.m = be16_to_cpu(scan->channel);
		iwe.u.freq.e = 0; /* table value in MHz */
		iwe.u.freq.i = 0;
		ev = iwe_stream_add_event(ev, stop, &iwe, IW_EV_FREQ_LEN);
		ev = iwe_stream_add_event(info, ev, stop, &iwe, IW_EV_FREQ_LEN);

		/* RATES */
		iwe.cmd = SIOCGIWRATE;
		iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
		/* to stuff multiple values in one event */
		tmp = ev + IW_EV_LCP_LEN;
		tmp = ev + iwe_stream_lcp_len(info);
		/* put them in ascendant order (older is first) */
		i = 0;
		j = 0;
		@@ -620,16 +621,16 @@ static char gelic_wl_translate_scan(struct net_device netdev,
		else
		rate = scan->rate[i++] & 0x7f;
		iwe.u.bitrate.value = rate * 500000; /* 500kbps unit */
		tmp = iwe_stream_add_value(ev, tmp, stop, &iwe,
		tmp = iwe_stream_add_value(info, ev, tmp, stop, &iwe,
		IW_EV_PARAM_LEN);
		}
		while (j < network->rate_ext_len) {
		iwe.u.bitrate.value = (scan->ext_rate[j++] & 0x7f) * 500000;
		tmp = iwe_stream_add_value(ev, tmp, stop, &iwe,
		tmp = iwe_stream_add_value(info, ev, tmp, stop, &iwe,
		IW_EV_PARAM_LEN);
		}
		/* Check if we added any rate */
		if (IW_EV_LCP_LEN < (tmp - ev))
		if (iwe_stream_lcp_len(info) < (tmp - ev))
		ev = tmp;

		/* ENCODE */
		@@ -639,7 +640,7 @@ static char gelic_wl_translate_scan(struct net_device netdev,
		else
		iwe.u.data.flags = IW_ENCODE_DISABLED;
		iwe.u.data.length = 0;
		ev = iwe_stream_add_point(ev, stop, &iwe, scan->essid);
		ev = iwe_stream_add_point(info, ev, stop, &iwe, scan->essid);

		/* MODE */
		iwe.cmd = SIOCGIWMODE;
		@@ -649,7 +650,7 @@ static char gelic_wl_translate_scan(struct net_device netdev,
		iwe.u.mode = IW_MODE_MASTER;
		else
		iwe.u.mode = IW_MODE_ADHOC;
		ev = iwe_stream_add_event(ev, stop, &iwe, IW_EV_UINT_LEN);
		ev = iwe_stream_add_event(info, ev, stop, &iwe, IW_EV_UINT_LEN);
		}

		/* QUAL */
		@@ -659,7 +660,7 @@ static char gelic_wl_translate_scan(struct net_device netdev,
		iwe.u.qual.level = be16_to_cpu(scan->rssi);
		iwe.u.qual.qual = be16_to_cpu(scan->rssi);
		iwe.u.qual.noise = 0;
		ev = iwe_stream_add_event(ev, stop, &iwe, IW_EV_QUAL_LEN);
		ev = iwe_stream_add_event(info, ev, stop, &iwe, IW_EV_QUAL_LEN);

		/* RSN */
		memset(&iwe, 0, sizeof(iwe));
		@@ -669,7 +670,7 @@ static char gelic_wl_translate_scan(struct net_device netdev,
		if (len) {
		iwe.cmd = IWEVGENIE;
		iwe.u.data.length = len;
		ev = iwe_stream_add_point(ev, stop, &iwe, buf);
		ev = iwe_stream_add_point(info, ev, stop, &iwe, buf);
		}
		} else {
		/* this scan info has IE data */
		@@ -684,7 +685,7 @@ static char gelic_wl_translate_scan(struct net_device netdev,
		memcpy(buf, ie_info.wpa.data, ie_info.wpa.len);
		iwe.cmd = IWEVGENIE;
		iwe.u.data.length = ie_info.wpa.len;
		ev = iwe_stream_add_point(ev, stop, &iwe, buf);
		ev = iwe_stream_add_point(info, ev, stop, &iwe, buf);
		}

		if (ie_info.rsn.len && (ie_info.rsn.len <= sizeof(buf))) {
		@@ -692,7 +693,7 @@ static char gelic_wl_translate_scan(struct net_device netdev,
		memcpy(buf, ie_info.rsn.data, ie_info.rsn.len);
		iwe.cmd = IWEVGENIE;
		iwe.u.data.length = ie_info.rsn.len;
		ev = iwe_stream_add_point(ev, stop, &iwe, buf);
		ev = iwe_stream_add_point(info, ev, stop, &iwe, buf);
		}
		}

		@@ -737,7 +738,8 @@ static int gelic_wl_get_scan(struct net_device *netdev,
		if (wl->scan_age == 0 \|\|
		time_after(scan_info->last_scanned + wl->scan_age,
		this_time))
		ev = gelic_wl_translate_scan(netdev, ev, stop,
		ev = gelic_wl_translate_scan(netdev, info,
		ev, stop,
		scan_info);
		else
		pr_debug("%s:entry too old\n", __func__);

drivers/net/wireless/Kconfig

+0 −24

Original line number	Diff line number	Diff line
		@@ -14,30 +14,6 @@ config WLAN_PRE80211
		This option does not affect the kernel build, it only
		lets you choose drivers.

		config STRIP
		tristate "STRIP (Metricom starmode radio IP)"
		depends on INET && WLAN_PRE80211
		select WIRELESS_EXT
		---help---
		Say Y if you have a Metricom radio and intend to use Starmode Radio
		IP. STRIP is a radio protocol developed for the MosquitoNet project
		(on the WWW at <http://mosquitonet.stanford.edu/>) to send Internet
		traffic using Metricom radios. Metricom radios are small, battery
		powered, 100kbit/sec packet radio transceivers, about the size and
		weight of a cellular telephone. (You may also have heard them called
		"Metricom modems" but we avoid the term "modem" because it misleads
		many people into thinking that you can plug a Metricom modem into a
		phone line and use it as a modem.)

		You can use STRIP on any Linux machine with a serial port, although
		it is obviously most useful for people with laptop computers. If you
		think you might get a Metricom radio in the future, there is no harm
		in saying Y to STRIP now, except that it makes the kernel a bit
		bigger.

		To compile this as a module, choose M here: the module will be
		called strip.

		config ARLAN
		tristate "Aironet Arlan 655 & IC2200 DS support"
		depends on ISA && !64BIT && WLAN_PRE80211