[802.11] Enhance support for driver PHY differences

The prior net80211 model of physical-layer behavior for drivers was
overly simplistic and limited the drivers that could be written.  To
be more flexible, split the driver-provided list of supported rates by
band, and add a means for specifying a list of supported channels.
Allow drivers to specify a hardware channel value that will be tied to
uses of the channel.

Expose net80211_duration() to drivers, and make the rate it uses in
its computations configurable, so that it can be used in calculating
durations that must be set in hardware for ACK and CTS packets. Add
net80211_cts_duration() for the common case of calculating the
duration for a CTS packet.

Signed-off-by: Michael Brown <mcb30@etherboot.org>

src/drivers/net/rtl818x/rtl818x.c

 			plcp_len |= 1 << 15;
 	}
 
+	entry = &priv->tx_ring[priv->tx_prod];
+
 	if (dev->phy_flags & NET80211_PHY_USE_PROTECTION) {
 		tx_flags |= RTL818X_TX_DESC_FLAG_CTS;
 		tx_flags |= priv->hw_rtscts_rate << 19;
+		entry->rts_duration = net80211_cts_duration(dev, len);
+	} else {
+		entry->rts_duration = 0;
 	}
 
-	entry = &priv->tx_ring[priv->tx_prod];
-
 	if (entry->flags & RTL818X_TX_DESC_FLAG_OWN) {
 		/* card hasn't processed the old packet yet! */
 		return -EBUSY;
 	priv->tx_buf[priv->tx_prod] = iob;
 	priv->tx_prod = (priv->tx_prod + 1) % RTL818X_TX_RING_SIZE;
 
-	entry->rts_duration = 0;
 	entry->plcp_len = cpu_to_le16(plcp_len);
 	entry->tx_buf = cpu_to_le32(virt_to_bus(iob->data));
 	entry->frame_len = cpu_to_le32(len);
 	.write = rtl818x_spi_write_bit,
 };
 
-/* The net80211 code makes a copy of this, so we're OK modifying the
-   static version as we initialize the card, as long as we don't
-   depend on possibly-modified values in case there are multiple cards. */
-static struct net80211_hw_info rtl818x_hwinfo = {
-	/* MAC address filled in at runtime */
-	/* modes filled in at runtime */
-	.bands = NET80211_BAND_2GHZ,
-	.flags = NET80211_HW_RX_HAS_FCS,
-	.signal_type = NET80211_SIGNAL_ARBITRARY,
-	/* supported rates filled in at runtime */
-	.signal_max = 65,
-	.channel_change_time = 1000, /* no idea what the actual value is */
-};
-
+#if DBGLVL_MAX
 static const char *rtl818x_rf_names[] = {
 	NULL,			/* no 0 */
 	"Intersil", "RFMD",	/* unsupported 1-2 */
 	"RTL8255",		/* unsupported 10 */
 };
 #define RTL818X_NR_RF_NAMES 11
+#endif
 
 struct net80211_device_operations rtl818x_operations = {
 	.open = rtl818x_start,
 	const char *chip_name;
 	u32 reg;
 	u16 eeprom_val;
+	struct net80211_hw_info *hwinfo;
+
+	hwinfo = zalloc(sizeof(*hwinfo));
+	if (!hwinfo) {
+		DBG("rtl818x: hwinfo alloc failed\n");
+		return -ENOMEM;
+	}
 
 	adjust_pci_device(pdev);
 
 
 	priv->r8185 = reg & RTL818X_TX_CONF_R8185_ABC;
 
-	memcpy(rtl818x_hwinfo.supported_rates, rtl818x_rates,
+	hwinfo->bands = NET80211_BAND_BIT_2GHZ;
+	hwinfo->flags = NET80211_HW_RX_HAS_FCS;
+	hwinfo->signal_type = NET80211_SIGNAL_ARBITRARY;
+	hwinfo->signal_max = 65;
+	hwinfo->channel_change_time = 1000;
+
+	memcpy(hwinfo->rates[NET80211_BAND_2GHZ], rtl818x_rates,
 	       sizeof(*rtl818x_rates) * RTL818X_NR_RATES);
 
 	if (priv->r8185) {
-		rtl818x_hwinfo.modes = NET80211_MODE_B | NET80211_MODE_G;
-		rtl818x_hwinfo.nr_supported_rates = RTL818X_NR_RATES;
+		hwinfo->modes = NET80211_MODE_B | NET80211_MODE_G;
+		hwinfo->nr_rates[NET80211_BAND_2GHZ] = RTL818X_NR_RATES;
 	} else {
-		rtl818x_hwinfo.modes = NET80211_MODE_B;
-		rtl818x_hwinfo.nr_supported_rates = RTL818X_NR_B_RATES;
+		hwinfo->modes = NET80211_MODE_B;
+		hwinfo->nr_rates[NET80211_BAND_2GHZ] = RTL818X_NR_B_RATES;
 	}
 
 	priv->spibit.basher.op = &rtl818x_basher_ops;
 	}
 
 	if (!priv->rf) {
+#if DBGLVL_MAX
 		if (eeprom_val < RTL818X_NR_RF_NAMES &&
 		    rtl818x_rf_names[eeprom_val] != NULL)
 			DBG("rtl818x: %s RF frontend not supported!\n",
 		else
 			DBG("rtl818x: RF frontend #%d not recognized!\n",
 			    eeprom_val);
+#endif
 
 		err = -ENOSYS;
 		goto err_free_dev;
 	}
 
 	/* read the MAC address */
-	nvs_read(&priv->eeprom.nvs, 0x7, rtl818x_hwinfo.hwaddr, 6);
+	nvs_read(&priv->eeprom.nvs, 0x7, hwinfo->hwaddr, 6);
 
 	/* CCK TX power */
 	for (i = 0; i < 14; i += 2) {
 
 	rtl818x_iowrite8(priv, &priv->map->EEPROM_CMD, RTL818X_EEPROM_CMD_NORMAL);
 
-	err = net80211_register(dev, &rtl818x_operations, &rtl818x_hwinfo);
+	err = net80211_register(dev, &rtl818x_operations, hwinfo);
 	if (err) {
 		DBG("rtl818x: cannot register device\n");
 		goto err_free_dev;
 	}
 
+	free(hwinfo);
+
 	DBG("rtl818x: Realtek RTL818%s (RF chip %s) with address %s\n",
 	    chip_name, priv->rf->name, netdev_hwaddr(dev->netdev));
 
  err_free_dev:
 	pci_set_drvdata(pdev, NULL);
 	net80211_free(dev);
+	free(hwinfo);
 	return err;
 }
 

src/include/gpxe/net80211.h

 /** @{ */
 
 /** The 2.4 GHz ISM band, unlicensed in most countries */
-#define NET80211_BAND_2GHZ	(1 << 0)
+#define NET80211_BAND_2GHZ	0
 /** The band from 4.9 GHz to 5.7 GHz, which tends to be more restricted */
-#define NET80211_BAND_5GHZ	(1 << 1)
+#define NET80211_BAND_5GHZ	1
+/** Number of RF bands */
+#define NET80211_NR_BANDS	2
+
+/** Bitmask for the 2GHz band */
+#define NET80211_BAND_BIT_2GHZ	(1 << 0)
+/** Bitmask for the 5GHz band */
+#define NET80211_BAND_BIT_5GHZ	(1 << 1)
 
 /** @} */
 
 	 */
 	u16 center_freq;
 
+	/** Hardware channel value */
+	u16 hw_value;
+
 	/** Maximum allowable transmit power, in dBm
 	 *
 	 * This should be interpreted as EIRP, the power supplied to
 	 */
 	unsigned signal_max;
 
-	/** List of transmission rates supported by the card
+	/** List of RF channels supported by the card */
+	struct net80211_channel channels[NET80211_MAX_CHANNELS];
+
+	/** Number of supported channels */
+	int nr_channels;
+
+	/** List of transmission rates supported by the card, indexed by band
 	 *
 	 * Rates should be in 100kbps increments (e.g. 11 Mbps would
 	 * be represented as the number 110).
 	 */
-	u16 supported_rates[NET80211_MAX_RATES];
+	u16 rates[NET80211_NR_BANDS][NET80211_MAX_RATES];
 
-	/** Number of supported rates */
-	int nr_supported_rates;
+	/** Number of supported rates, indexed by band */
+	int nr_rates[NET80211_NR_BANDS];
 
 	/** Estimate of the time required to change channels, in microseconds
 	 *
 int net80211_register ( struct net80211_device *dev,
 			struct net80211_device_operations *ops,
 			struct net80211_hw_info *hw );
+u16 net80211_duration ( struct net80211_device *dev, int bytes, u16 rate );
 void net80211_rx ( struct net80211_device *dev, struct io_buffer *iob,
 		   int signal, u16 rate );
 void net80211_rx_err ( struct net80211_device *dev,
 void net80211_free ( struct net80211_device *dev );
 /** @} */
 
+/**
+ * Calculate duration field for a CTS control frame
+ *
+ * @v dev	802.11 device
+ * @v size	Size of the packet being cleared to send
+ *
+ * A CTS control frame's duration field captures the frame being
+ * protected and its 10-byte ACK.
+ */
+static inline u16 net80211_cts_duration ( struct net80211_device *dev,
+					  int size )
+{
+	return ( net80211_duration ( dev, 10,
+				     dev->rates[dev->rtscts_rate] ) +
+		 net80211_duration ( dev, size, dev->rates[dev->rate] ) );
+}
 
 #endif

src/net/80211/net80211.c

  * @defgroup net80211_linklayer 802.11 link-layer protocol functions
  * @{
  */
-static u16 net80211_duration ( struct net80211_device *dev, int bytes );
 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 void net80211_add_channels ( struct net80211_device *dev, int start,
 				    int len, int txpower );
+static void net80211_filter_hw_channels ( struct net80211_device *dev );
 static void net80211_set_rtscts_rate ( struct net80211_device *dev );
 static int net80211_process_capab ( struct net80211_device *dev,
 				    u16 capab );
  *
  * No other frame types are currently supported by gPXE.
  */
-static u16 net80211_duration ( struct net80211_device *dev, int bytes )
+u16 net80211_duration ( struct net80211_device *dev, int bytes, u16 rate )
 {
 	struct net80211_channel *chan = &dev->channels[dev->channel];
-	u16 rate = dev->rates[dev->rate];
 	u32 kbps = rate * 100;
 
 	if ( chan->band == NET80211_BAND_5GHZ || net80211_rate_is_erp ( rate ) ) {
 
 	/* 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, dev->rates[dev->rate] );
 
 	memcpy ( hdr->addr1, dev->bssid, ETH_ALEN );
 	memcpy ( hdr->addr2, ll_source, ETH_ALEN );
 
 	hdr->fc = IEEE80211_THIS_VERSION | IEEE80211_TYPE_MGMT |
 	    ( fc & ~IEEE80211_FC_PROTECTED );
-	hdr->duration = net80211_duration ( dev, 10 );
+	hdr->duration = net80211_duration ( dev, 10, dev->rates[dev->rate] );
 	hdr->seq = IEEE80211_MAKESEQ ( ++dev->last_tx_seqnr, 0 );
 
 	memcpy ( hdr->addr1, dest, ETH_ALEN );	/* DA = RA */
 	for ( i = dev->nr_channels; len-- && i < NET80211_MAX_CHANNELS; i++ ) {
 		dev->channels[i].channel_nr = chan;
 		dev->channels[i].maxpower = txpower;
+		dev->channels[i].hw_value = 0;
 
 		if ( chan >= 1 && chan <= 14 ) {
 			dev->channels[i].band = NET80211_BAND_2GHZ;
 	dev->nr_channels = i;
 }
 
+/**
+ * Filter 802.11 device channels for hardware capabilities
+ *
+ * @v dev	802.11 device
+ *
+ * Hardware may support fewer channels than regulatory restrictions
+ * allow; this function filters out channels in dev->channels that are
+ * not supported by the hardware list in dev->hwinfo. It also copies
+ * over the net80211_channel::hw_value and limits maximum TX power
+ * appropriately.
+ *
+ * Channels are matched based on center frequency, ignoring band and
+ * channel number.
+ *
+ * If the driver specifies no supported channels, the effect will be
+ * as though all were supported.
+ */
+static void net80211_filter_hw_channels ( struct net80211_device *dev )
+{
+	int delta = 0, i = 0;
+	int old_freq = dev->channels[dev->channel].center_freq;
+	struct net80211_channel *chan, *hwchan;
+
+	if ( ! dev->hw->nr_channels )
+		return;
+
+	dev->channel = 0;
+	for ( chan = dev->channels; chan < dev->channels + dev->nr_channels;
+	      chan++, i++ ) {
+		int ok = 0;
+		for ( hwchan = dev->hw->channels;
+		      hwchan < dev->hw->channels + dev->hw->nr_channels;
+		      hwchan++ ) {
+			if ( hwchan->center_freq == chan->center_freq ) {
+				ok = 1;
+				break;
+			}
+		}
+
+		if ( ! ok )
+			delta++;
+		else {
+			chan->hw_value = hwchan->hw_value;
+			if ( hwchan->maxpower != 0 &&
+			     chan->maxpower > hwchan->maxpower )
+				chan->maxpower = hwchan->maxpower;
+			if ( old_freq == chan->center_freq )
+				dev->channel = i - delta;
+			if ( delta )
+				chan[-delta] = *chan;
+		}
+	}
+
+	dev->nr_channels -= delta;
+
+	if ( dev->channels[dev->channel].center_freq != old_freq )
+		dev->op->config ( dev, NET80211_CFG_CHANNEL );
+}
+
 /**
  * Update 802.11 device state to reflect received capabilities field
  *
 	int have_rates = 0, i;
 	int ds_channel = 0;
 	int changed = 0;
+	int band = dev->channels[dev->channel].band;
 
 	if ( ( void * ) ie >= ie_end )
 		return 0;
 							t->band.max_txpower );
 				}
 			}
+			net80211_filter_hw_channels ( dev );
 			break;
 
 		case IEEE80211_IE_ERP_INFO:
 		dev->rate = 0;
 		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[j] ==
-				     dev->rates[i] ) {
+			for ( j = 0; j < dev->hw->nr_rates[band]; j++ ) {
+				if ( dev->hw->rates[band][j] == dev->rates[i] ){
 					ok = 1;
 					break;
 				}
 			int band = dev->hw->bands;
 
 			if ( active )
-				band &= ~NET80211_BAND_5GHZ;
+				band &= ~NET80211_BAND_BIT_5GHZ;
 
 			rc = net80211_prepare_probe ( dev, band, active );
 			if ( rc )
 {
 	assert ( dev->netdev->state & NETDEV_OPEN );
 
-	if ( active && band != NET80211_BAND_2GHZ ) {
+	if ( active && ( band & NET80211_BAND_BIT_5GHZ ) ) {
 		DBGC ( dev, "802.11 %p cannot perform active scanning on "
 		       "5GHz band\n", dev );
 		return -EINVAL_ACTIVE_SCAN;
 	if ( active )
 		net80211_add_channels ( dev, 1, 11, NET80211_REG_TXPOWER );
 	else {
-		if ( band & NET80211_BAND_2GHZ )
+		if ( band & NET80211_BAND_BIT_2GHZ )
 			net80211_add_channels ( dev, 1, 14,
 						NET80211_REG_TXPOWER );
-		if ( band & NET80211_BAND_5GHZ )
+		if ( band & NET80211_BAND_BIT_5GHZ )
 			net80211_add_channels ( dev, 36, 8,
 						NET80211_REG_TXPOWER );
 	}
 
+	net80211_filter_hw_channels ( dev );
+
 	/* Use channel 1 for now */
 	dev->channel = 0;
 	dev->op->config ( dev, NET80211_CFG_CHANNEL );
 
-	/* Always do active probes at 1Mbps */
+	/* Always do active probes at lowest (presumably first) speed */
 	dev->rate = 0;
 	dev->nr_rates = 1;
-	dev->rates[0] = 10;
+	dev->rates[0] = dev->hw->rates[dev->channels[0].band][0];
 	dev->op->config ( dev, NET80211_CFG_RATE );
 
 	return 0;