Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 28f49d8f authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/linville/wireless-next-2.6

parents 332e4af8 ff28bd94

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